node-autoit-koffi 1.0.0

package/dist/index.js

@@ -0,0 +1,2067 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opt = exports.mouseWheel = exports.mouseUp = exports.mouseMove = exports.mouseGetPos = exports.mouseGetCursor = exports.mouseDown = exports.mouseClickDrag = exports.mouseClick = exports.isAdmin = exports.driveMapGet = exports.driveMapDel = exports.driveMapAdd = exports.controlTreeViewByHandle = exports.controlTreeView = exports.controlShowByHandle = exports.controlShow = exports.controlSetTextByHandle = exports.controlSetText = exports.controlSendByHandle = exports.controlSend = exports.controlMoveByHandle = exports.controlMove = exports.controlHideByHandle = exports.controlHide = exports.controlGetTextByHandle = exports.controlGetText = exports.controlGetPosByHandle = exports.controlGetPos = exports.controlGetHandleAsText = exports.controlGetHandle = exports.controlGetFocusByHandle = exports.controlGetFocus = exports.controlFocusByHandle = exports.controlFocus = exports.controlEnableByHandle = exports.controlEnable = exports.controlDisableByHandle = exports.controlDisable = exports.controlListViewByHandle = exports.controlListView = exports.controlCommandByHandle = exports.controlCommand = exports.controlClickByHandle = exports.controlClick = exports.clipPut = exports.clipGet = exports.autoItSetOption = exports.error = exports.init = void 0;
+exports.winMove = exports.winMinimizeAllUndo = exports.winMinimizeAll = exports.winMenuSelectItemByHandle = exports.winMenuSelectItem = exports.winKillByHandle = exports.winKill = exports.winGetTitleByHandle = exports.winGetTitle = exports.winGetTextByHandle = exports.winGetText = exports.winGetStateByHandle = exports.winGetState = exports.winGetProcessByHandle = exports.winGetProcess = exports.winGetPosByHandle = exports.winGetPos = exports.winGetHandleAsText = exports.winGetHandle = exports.winGetClientSizeByHandle = exports.winGetClientSize = exports.winGetClassListByHandle = exports.winGetClassList = exports.winGetCaretPos = exports.winExistsByHandle = exports.winExists = exports.winCloseByHandle = exports.winClose = exports.winActiveByHandle = exports.winActive = exports.winActivateByHandle = exports.winActivate = exports.toolTip = exports.statusbarGetTextByHandle = exports.statusbarGetText = exports.sleep = exports.shutdown = exports.send = exports.runAsWait = exports.runAs = exports.runWait = exports.run = exports.processWaitClose = exports.processWait = exports.processSetPriority = exports.processExists = exports.processClose = exports.pixelSearch = exports.pixelGetColor = exports.pixelChecksum = void 0;
+exports.winWaitNotActiveByHandle = exports.winWaitNotActive = exports.winWaitCloseByHandle = exports.winWaitClose = exports.winWaitActiveByHandle = exports.winWaitActive = exports.winWaitByHandle = exports.winWait = exports.winSetTransByHandle = exports.winSetTrans = exports.winSetTitleByHandle = exports.winSetTitle = exports.winSetStateByHandle = exports.winSetState = exports.winSetOnTopByHandle = exports.winSetOnTop = exports.winMoveByHandle = void 0;
+const util_1 = require("./util");
+const koffi = __importStar(require("koffi"));
+const wchar_1 = __importDefault(require("./wchar"));
+const dll = (0, util_1.getDll)();
+if (!dll)
+    throw new Error("This operating system is not supported!");
+const lib = koffi.load(dll);
+koffi.struct("LPRECT", {
+    left: "long",
+    top: "long",
+    right: "long",
+    bottom: "long",
+});
+koffi.struct("LPPOINT", {
+    x: "long",
+    y: "long",
+});
+koffi.pointer("LPWSTR", "uint16_t*");
+const fn = {};
+// Generated code:
+const init = () => {
+    if (!fn.hasOwnProperty("init")) {
+        fn["init"] = lib.func("AU3_Init", "void", []);
+    }
+    return new Promise((resolve, reject) => {
+        fn["init"].async((err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.init = init;
+const error = () => {
+    if (!fn.hasOwnProperty("error")) {
+        fn["error"] = lib.func("AU3_error", "int", []);
+    }
+    return new Promise((resolve, reject) => {
+        fn["error"].async((err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.error = error;
+const autoItSetOption = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("autoItSetOption")) {
+        fn["autoItSetOption"] = lib.func("AU3_AutoItSetOption", "int", [
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["autoItSetOption"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.autoItSetOption = autoItSetOption;
+const clipGet = (arg1 = 512) => {
+    if (!fn.hasOwnProperty("clipGet")) {
+        fn["clipGet"] = lib.func("AU3_ClipGet", "void", ["LPWSTR", "int"]);
+    }
+    let result = Buffer.alloc(arg1 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["clipGet"].async(result, arg1, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.clipGet = clipGet;
+const clipPut = (arg0) => {
+    if (!fn.hasOwnProperty("clipPut")) {
+        fn["clipPut"] = lib.func("AU3_ClipPut", "void", ["string16"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["clipPut"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.clipPut = clipPut;
+const controlClick = (arg0, arg1 = "", arg2, arg3 = "LEFT", arg4 = 1, arg5 = -2147483647, arg6 = -2147483647) => {
+    if (!fn.hasOwnProperty("controlClick")) {
+        fn["controlClick"] = lib.func("AU3_ControlClick", "int", [
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "int",
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlClick"].async(arg0, arg1, arg2, arg3, arg4, arg5, arg6, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlClick = controlClick;
+const controlClickByHandle = (arg0, arg1, arg2 = "LEFT", arg3 = 1, arg4 = -2147483647, arg5 = -2147483647) => {
+    if (!fn.hasOwnProperty("controlClickByHandle")) {
+        fn["controlClickByHandle"] = lib.func("AU3_ControlClickByHandle", "int", [
+            "int",
+            "int",
+            "string16",
+            "int",
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlClickByHandle"].async(arg0, arg1, arg2, arg3, arg4, arg5, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlClickByHandle = controlClickByHandle;
+const controlCommand = (arg0, arg1 = "", arg2, arg3, arg4 = "", arg6 = 256) => {
+    if (!fn.hasOwnProperty("controlCommand")) {
+        fn["controlCommand"] = lib.func("AU3_ControlCommand", "void", [
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg6 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlCommand"].async(arg0, arg1, arg2, arg3, arg4, result, arg6, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlCommand = controlCommand;
+const controlCommandByHandle = (arg0, arg1, arg2, arg3 = "", arg5 = 256) => {
+    if (!fn.hasOwnProperty("controlCommandByHandle")) {
+        fn["controlCommandByHandle"] = lib.func("AU3_ControlCommandByHandle", "void", ["int", "int", "string16", "string16", "LPWSTR", "int"]);
+    }
+    let result = Buffer.alloc(arg5 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlCommandByHandle"].async(arg0, arg1, arg2, arg3, result, arg5, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlCommandByHandle = controlCommandByHandle;
+const controlListView = (arg0, arg1 = "", arg2, arg3, arg4 = "", arg5 = "", arg7 = 256) => {
+    if (!fn.hasOwnProperty("controlListView")) {
+        fn["controlListView"] = lib.func("AU3_ControlListView", "void", [
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg7 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlListView"].async(arg0, arg1, arg2, arg3, arg4, arg5, result, arg7, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlListView = controlListView;
+const controlListViewByHandle = (arg0, arg1, arg2, arg3 = "", arg4 = "", arg6 = 256) => {
+    if (!fn.hasOwnProperty("controlListViewByHandle")) {
+        fn["controlListViewByHandle"] = lib.func("AU3_ControlListViewByHandle", "void", ["int", "int", "string16", "string16", "string16", "LPWSTR", "int"]);
+    }
+    let result = Buffer.alloc(arg6 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlListViewByHandle"].async(arg0, arg1, arg2, arg3, arg4, result, arg6, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlListViewByHandle = controlListViewByHandle;
+const controlDisable = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("controlDisable")) {
+        fn["controlDisable"] = lib.func("AU3_ControlDisable", "int", [
+            "string16",
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlDisable"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlDisable = controlDisable;
+const controlDisableByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("controlDisableByHandle")) {
+        fn["controlDisableByHandle"] = lib.func("AU3_ControlDisableByHandle", "int", ["int", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlDisableByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlDisableByHandle = controlDisableByHandle;
+const controlEnable = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("controlEnable")) {
+        fn["controlEnable"] = lib.func("AU3_ControlEnable", "int", [
+            "string16",
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlEnable"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlEnable = controlEnable;
+const controlEnableByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("controlEnableByHandle")) {
+        fn["controlEnableByHandle"] = lib.func("AU3_ControlEnableByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlEnableByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlEnableByHandle = controlEnableByHandle;
+const controlFocus = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("controlFocus")) {
+        fn["controlFocus"] = lib.func("AU3_ControlFocus", "int", [
+            "string16",
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlFocus"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlFocus = controlFocus;
+const controlFocusByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("controlFocusByHandle")) {
+        fn["controlFocusByHandle"] = lib.func("AU3_ControlFocusByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlFocusByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlFocusByHandle = controlFocusByHandle;
+const controlGetFocus = (arg0, arg1 = "", arg3 = 256) => {
+    if (!fn.hasOwnProperty("controlGetFocus")) {
+        fn["controlGetFocus"] = lib.func("AU3_ControlGetFocus", "void", [
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg3 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlGetFocus"].async(arg0, arg1, result, arg3, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlGetFocus = controlGetFocus;
+const controlGetFocusByHandle = (arg0, arg2 = 256) => {
+    if (!fn.hasOwnProperty("controlGetFocusByHandle")) {
+        fn["controlGetFocusByHandle"] = lib.func("AU3_ControlGetFocusByHandle", "void", ["int", "LPWSTR", "int"]);
+    }
+    let result = Buffer.alloc(arg2 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlGetFocusByHandle"].async(arg0, result, arg2, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlGetFocusByHandle = controlGetFocusByHandle;
+const controlGetHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("controlGetHandle")) {
+        fn["controlGetHandle"] = lib.func("AU3_ControlGetHandle", "int", [
+            "int",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlGetHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlGetHandle = controlGetHandle;
+const controlGetHandleAsText = (arg0, arg1 = "", arg2, arg4 = 256) => {
+    if (!fn.hasOwnProperty("controlGetHandleAsText")) {
+        fn["controlGetHandleAsText"] = lib.func("AU3_ControlGetHandleAsText", "void", ["string16", "string16", "string16", "LPWSTR", "int"]);
+    }
+    let result = Buffer.alloc(arg4 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlGetHandleAsText"].async(arg0, arg1, arg2, result, arg4, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlGetHandleAsText = controlGetHandleAsText;
+const controlGetPos = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("controlGetPos")) {
+        fn["controlGetPos"] = lib.func("AU3_ControlGetPos", "int", [
+            "string16",
+            "string16",
+            "string16",
+            "_Out_ LPRECT*",
+        ]);
+    }
+    let result = {};
+    return new Promise((resolve, reject) => {
+        fn["controlGetPos"].async(arg0, arg1, arg2, result, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+exports.controlGetPos = controlGetPos;
+const controlGetPosByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("controlGetPosByHandle")) {
+        fn["controlGetPosByHandle"] = lib.func("AU3_ControlGetPosByHandle", "int", [
+            "int",
+            "int",
+            "_Out_ LPRECT*",
+        ]);
+    }
+    let result = {};
+    return new Promise((resolve, reject) => {
+        fn["controlGetPosByHandle"].async(arg0, arg1, result, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+exports.controlGetPosByHandle = controlGetPosByHandle;
+const controlGetText = (arg0, arg1 = "", arg2, arg4 = 512) => {
+    if (!fn.hasOwnProperty("controlGetText")) {
+        fn["controlGetText"] = lib.func("AU3_ControlGetText", "void", [
+            "string16",
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg4 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlGetText"].async(arg0, arg1, arg2, result, arg4, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlGetText = controlGetText;
+const controlGetTextByHandle = (arg0, arg1, arg3 = 512) => {
+    if (!fn.hasOwnProperty("controlGetTextByHandle")) {
+        fn["controlGetTextByHandle"] = lib.func("AU3_ControlGetTextByHandle", "void", ["int", "int", "LPWSTR", "int"]);
+    }
+    let result = Buffer.alloc(arg3 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlGetTextByHandle"].async(arg0, arg1, result, arg3, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlGetTextByHandle = controlGetTextByHandle;
+const controlHide = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("controlHide")) {
+        fn["controlHide"] = lib.func("AU3_ControlHide", "int", [
+            "string16",
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlHide"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlHide = controlHide;
+const controlHideByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("controlHideByHandle")) {
+        fn["controlHideByHandle"] = lib.func("AU3_ControlHideByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlHideByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlHideByHandle = controlHideByHandle;
+const controlMove = (arg0, arg1 = "", arg2, arg3, arg4, arg5 = -1, arg6 = -1) => {
+    if (!fn.hasOwnProperty("controlMove")) {
+        fn["controlMove"] = lib.func("AU3_ControlMove", "int", [
+            "string16",
+            "string16",
+            "string16",
+            "int",
+            "int",
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlMove"].async(arg0, arg1, arg2, arg3, arg4, arg5, arg6, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlMove = controlMove;
+const controlMoveByHandle = (arg0, arg1, arg2, arg3, arg4 = -1, arg5 = -1) => {
+    if (!fn.hasOwnProperty("controlMoveByHandle")) {
+        fn["controlMoveByHandle"] = lib.func("AU3_ControlMoveByHandle", "int", [
+            "int",
+            "int",
+            "int",
+            "int",
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlMoveByHandle"].async(arg0, arg1, arg2, arg3, arg4, arg5, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlMoveByHandle = controlMoveByHandle;
+const controlSend = (arg0, arg1 = "", arg2, arg3, arg4 = 0) => {
+    if (!fn.hasOwnProperty("controlSend")) {
+        fn["controlSend"] = lib.func("AU3_ControlSend", "int", [
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlSend"].async(arg0, arg1, arg2, arg3, arg4, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlSend = controlSend;
+const controlSendByHandle = (arg0, arg1, arg2, arg3 = 0) => {
+    if (!fn.hasOwnProperty("controlSendByHandle")) {
+        fn["controlSendByHandle"] = lib.func("AU3_ControlSendByHandle", "int", [
+            "int",
+            "int",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlSendByHandle"].async(arg0, arg1, arg2, arg3, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlSendByHandle = controlSendByHandle;
+const controlSetText = (arg0, arg1 = "", arg2, arg3) => {
+    if (!fn.hasOwnProperty("controlSetText")) {
+        fn["controlSetText"] = lib.func("AU3_ControlSetText", "int", [
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlSetText"].async(arg0, arg1, arg2, arg3, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlSetText = controlSetText;
+const controlSetTextByHandle = (arg0, arg1, arg2) => {
+    if (!fn.hasOwnProperty("controlSetTextByHandle")) {
+        fn["controlSetTextByHandle"] = lib.func("AU3_ControlSetTextByHandle", "int", ["int", "int", "string16"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlSetTextByHandle"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlSetTextByHandle = controlSetTextByHandle;
+const controlShow = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("controlShow")) {
+        fn["controlShow"] = lib.func("AU3_ControlShow", "int", [
+            "string16",
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlShow"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlShow = controlShow;
+const controlShowByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("controlShowByHandle")) {
+        fn["controlShowByHandle"] = lib.func("AU3_ControlShowByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["controlShowByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.controlShowByHandle = controlShowByHandle;
+const controlTreeView = (arg0, arg1 = "", arg2, arg3, arg4 = "", arg5 = "", arg7 = 256) => {
+    if (!fn.hasOwnProperty("controlTreeView")) {
+        fn["controlTreeView"] = lib.func("AU3_ControlTreeView", "void", [
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg7 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlTreeView"].async(arg0, arg1, arg2, arg3, arg4, arg5, result, arg7, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlTreeView = controlTreeView;
+const controlTreeViewByHandle = (arg0, arg1, arg2, arg3 = "", arg4 = "", arg6 = 256) => {
+    if (!fn.hasOwnProperty("controlTreeViewByHandle")) {
+        fn["controlTreeViewByHandle"] = lib.func("AU3_ControlTreeViewByHandle", "void", ["int", "int", "string16", "string16", "string16", "LPWSTR", "int"]);
+    }
+    let result = Buffer.alloc(arg6 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["controlTreeViewByHandle"].async(arg0, arg1, arg2, arg3, arg4, result, arg6, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.controlTreeViewByHandle = controlTreeViewByHandle;
+const driveMapAdd = (arg0, arg1, arg2, arg3 = "", arg4 = "", arg6 = 256) => {
+    if (!fn.hasOwnProperty("driveMapAdd")) {
+        fn["driveMapAdd"] = lib.func("AU3_DriveMapAdd", "void", [
+            "string16",
+            "string16",
+            "int",
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg6 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["driveMapAdd"].async(arg0, arg1, arg2, arg3, arg4, result, arg6, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.driveMapAdd = driveMapAdd;
+const driveMapDel = (arg0) => {
+    if (!fn.hasOwnProperty("driveMapDel")) {
+        fn["driveMapDel"] = lib.func("AU3_DriveMapDel", "int", ["string16"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["driveMapDel"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.driveMapDel = driveMapDel;
+const driveMapGet = (arg0, arg2 = 256) => {
+    if (!fn.hasOwnProperty("driveMapGet")) {
+        fn["driveMapGet"] = lib.func("AU3_DriveMapGet", "void", [
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg2 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["driveMapGet"].async(arg0, result, arg2, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.driveMapGet = driveMapGet;
+const isAdmin = () => {
+    if (!fn.hasOwnProperty("isAdmin")) {
+        fn["isAdmin"] = lib.func("AU3_IsAdmin", "int", []);
+    }
+    return new Promise((resolve, reject) => {
+        fn["isAdmin"].async((err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.isAdmin = isAdmin;
+const mouseClick = (arg0 = "LEFT", arg1 = -2147483647, arg2 = -2147483647, arg3 = 1, arg4 = -1) => {
+    if (!fn.hasOwnProperty("mouseClick")) {
+        fn["mouseClick"] = lib.func("AU3_MouseClick", "int", [
+            "string16",
+            "int",
+            "int",
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["mouseClick"].async(arg0, arg1, arg2, arg3, arg4, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.mouseClick = mouseClick;
+const mouseClickDrag = (arg0, arg1, arg2, arg3, arg4, arg5 = -1) => {
+    if (!fn.hasOwnProperty("mouseClickDrag")) {
+        fn["mouseClickDrag"] = lib.func("AU3_MouseClickDrag", "int", [
+            "string16",
+            "int",
+            "int",
+            "int",
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["mouseClickDrag"].async(arg0, arg1, arg2, arg3, arg4, arg5, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.mouseClickDrag = mouseClickDrag;
+const mouseDown = (arg0 = "LEFT") => {
+    if (!fn.hasOwnProperty("mouseDown")) {
+        fn["mouseDown"] = lib.func("AU3_MouseDown", "void", ["string16"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["mouseDown"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.mouseDown = mouseDown;
+const mouseGetCursor = () => {
+    if (!fn.hasOwnProperty("mouseGetCursor")) {
+        fn["mouseGetCursor"] = lib.func("AU3_MouseGetCursor", "int", []);
+    }
+    return new Promise((resolve, reject) => {
+        fn["mouseGetCursor"].async((err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.mouseGetCursor = mouseGetCursor;
+const mouseGetPos = () => {
+    if (!fn.hasOwnProperty("mouseGetPos")) {
+        fn["mouseGetPos"] = lib.func("AU3_MouseGetPos", "void", ["_Out_ LPPOINT*"]);
+    }
+    let result = {};
+    return new Promise((resolve, reject) => {
+        fn["mouseGetPos"].async(result, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+exports.mouseGetPos = mouseGetPos;
+const mouseMove = (arg0, arg1, arg2 = -1) => {
+    if (!fn.hasOwnProperty("mouseMove")) {
+        fn["mouseMove"] = lib.func("AU3_MouseMove", "int", ["int", "int", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["mouseMove"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.mouseMove = mouseMove;
+const mouseUp = (arg0 = "LEFT") => {
+    if (!fn.hasOwnProperty("mouseUp")) {
+        fn["mouseUp"] = lib.func("AU3_MouseUp", "void", ["string16"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["mouseUp"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.mouseUp = mouseUp;
+const mouseWheel = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("mouseWheel")) {
+        fn["mouseWheel"] = lib.func("AU3_MouseWheel", "void", ["string16", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["mouseWheel"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.mouseWheel = mouseWheel;
+const opt = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("opt")) {
+        fn["opt"] = lib.func("AU3_Opt", "int", ["string16", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["opt"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.opt = opt;
+const pixelChecksum = (arg1 = 1) => {
+    if (!fn.hasOwnProperty("pixelChecksum")) {
+        fn["pixelChecksum"] = lib.func("AU3_PixelChecksum", "uint", [
+            "LPRECT",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["pixelChecksum"].async(arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.pixelChecksum = pixelChecksum;
+const pixelGetColor = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("pixelGetColor")) {
+        fn["pixelGetColor"] = lib.func("AU3_PixelGetColor", "int", ["int", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["pixelGetColor"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.pixelGetColor = pixelGetColor;
+const pixelSearch = (arg1, arg2 = 0, arg3 = 1) => {
+    if (!fn.hasOwnProperty("pixelSearch")) {
+        fn["pixelSearch"] = lib.func("AU3_PixelSearch", "void", [
+            "LPRECT",
+            "int",
+            "int",
+            "int",
+            "_Out_ LPPOINT*",
+        ]);
+    }
+    let result = {};
+    return new Promise((resolve, reject) => {
+        fn["pixelSearch"].async(arg1, arg2, arg3, result, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+exports.pixelSearch = pixelSearch;
+const processClose = (arg0) => {
+    if (!fn.hasOwnProperty("processClose")) {
+        fn["processClose"] = lib.func("AU3_ProcessClose", "int", ["string16"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["processClose"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.processClose = processClose;
+const processExists = (arg0) => {
+    if (!fn.hasOwnProperty("processExists")) {
+        fn["processExists"] = lib.func("AU3_ProcessExists", "int", ["string16"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["processExists"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.processExists = processExists;
+const processSetPriority = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("processSetPriority")) {
+        fn["processSetPriority"] = lib.func("AU3_ProcessSetPriority", "int", [
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["processSetPriority"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.processSetPriority = processSetPriority;
+const processWait = (arg0, arg1 = 0) => {
+    if (!fn.hasOwnProperty("processWait")) {
+        fn["processWait"] = lib.func("AU3_ProcessWait", "int", ["string16", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["processWait"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.processWait = processWait;
+const processWaitClose = (arg0, arg1 = 0) => {
+    if (!fn.hasOwnProperty("processWaitClose")) {
+        fn["processWaitClose"] = lib.func("AU3_ProcessWaitClose", "int", [
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["processWaitClose"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.processWaitClose = processWaitClose;
+const run = (arg0, arg1 = "", arg2 = 1) => {
+    if (!fn.hasOwnProperty("run")) {
+        fn["run"] = lib.func("AU3_Run", "int", ["string16", "string16", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["run"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.run = run;
+const runWait = (arg0, arg1 = "", arg2 = 1) => {
+    if (!fn.hasOwnProperty("runWait")) {
+        fn["runWait"] = lib.func("AU3_RunWait", "int", [
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["runWait"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.runWait = runWait;
+const runAs = (arg0, arg1, arg2, arg3, arg4, arg5 = "", arg6 = 1) => {
+    if (!fn.hasOwnProperty("runAs")) {
+        fn["runAs"] = lib.func("AU3_RunAs", "int", [
+            "string16",
+            "string16",
+            "string16",
+            "int",
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["runAs"].async(arg0, arg1, arg2, arg3, arg4, arg5, arg6, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.runAs = runAs;
+const runAsWait = (arg0, arg1, arg2, arg3, arg4, arg5 = "", arg6 = 1) => {
+    if (!fn.hasOwnProperty("runAsWait")) {
+        fn["runAsWait"] = lib.func("AU3_RunAsWait", "int", [
+            "string16",
+            "string16",
+            "string16",
+            "int",
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["runAsWait"].async(arg0, arg1, arg2, arg3, arg4, arg5, arg6, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.runAsWait = runAsWait;
+const send = (arg0, arg1 = 0) => {
+    if (!fn.hasOwnProperty("send")) {
+        fn["send"] = lib.func("AU3_Send", "void", ["string16", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["send"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.send = send;
+const shutdown = (arg0) => {
+    if (!fn.hasOwnProperty("shutdown")) {
+        fn["shutdown"] = lib.func("AU3_Shutdown", "int", ["int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["shutdown"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.shutdown = shutdown;
+const sleep = (arg0) => {
+    if (!fn.hasOwnProperty("sleep")) {
+        fn["sleep"] = lib.func("AU3_Sleep", "void", ["int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["sleep"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.sleep = sleep;
+const statusbarGetText = (arg0, arg1 = "", arg2 = 1, arg4 = 256) => {
+    if (!fn.hasOwnProperty("statusbarGetText")) {
+        fn["statusbarGetText"] = lib.func("AU3_StatusbarGetText", "int", [
+            "string16",
+            "string16",
+            "int",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg4 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["statusbarGetText"].async(arg0, arg1, arg2, result, arg4, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.statusbarGetText = statusbarGetText;
+const statusbarGetTextByHandle = (arg0, arg1 = 1, arg3 = 256) => {
+    if (!fn.hasOwnProperty("statusbarGetTextByHandle")) {
+        fn["statusbarGetTextByHandle"] = lib.func("AU3_StatusbarGetTextByHandle", "int", ["int", "int", "LPWSTR", "int"]);
+    }
+    let result = Buffer.alloc(arg3 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["statusbarGetTextByHandle"].async(arg0, arg1, result, arg3, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.statusbarGetTextByHandle = statusbarGetTextByHandle;
+const toolTip = (arg0, arg1 = -2147483647, arg2 = -2147483647) => {
+    if (!fn.hasOwnProperty("toolTip")) {
+        fn["toolTip"] = lib.func("AU3_ToolTip", "void", ["string16", "int", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["toolTip"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.toolTip = toolTip;
+const winActivate = (arg0, arg1 = "") => {
+    if (!fn.hasOwnProperty("winActivate")) {
+        fn["winActivate"] = lib.func("AU3_WinActivate", "int", [
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winActivate"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winActivate = winActivate;
+const winActivateByHandle = (arg0) => {
+    if (!fn.hasOwnProperty("winActivateByHandle")) {
+        fn["winActivateByHandle"] = lib.func("AU3_WinActivateByHandle", "int", [
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winActivateByHandle"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winActivateByHandle = winActivateByHandle;
+const winActive = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("winActive")) {
+        fn["winActive"] = lib.func("AU3_WinActive", "int", [
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winActive"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winActive = winActive;
+const winActiveByHandle = (arg0) => {
+    if (!fn.hasOwnProperty("winActiveByHandle")) {
+        fn["winActiveByHandle"] = lib.func("AU3_WinActiveByHandle", "int", ["int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winActiveByHandle"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winActiveByHandle = winActiveByHandle;
+const winClose = (arg0, arg1 = "") => {
+    if (!fn.hasOwnProperty("winClose")) {
+        fn["winClose"] = lib.func("AU3_WinClose", "int", ["string16", "string16"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winClose"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winClose = winClose;
+const winCloseByHandle = (arg0) => {
+    if (!fn.hasOwnProperty("winCloseByHandle")) {
+        fn["winCloseByHandle"] = lib.func("AU3_WinCloseByHandle", "int", ["int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winCloseByHandle"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winCloseByHandle = winCloseByHandle;
+const winExists = (arg0, arg1 = "") => {
+    if (!fn.hasOwnProperty("winExists")) {
+        fn["winExists"] = lib.func("AU3_WinExists", "int", [
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winExists"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winExists = winExists;
+const winExistsByHandle = (arg0) => {
+    if (!fn.hasOwnProperty("winExistsByHandle")) {
+        fn["winExistsByHandle"] = lib.func("AU3_WinExistsByHandle", "int", ["int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winExistsByHandle"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winExistsByHandle = winExistsByHandle;
+const winGetCaretPos = () => {
+    if (!fn.hasOwnProperty("winGetCaretPos")) {
+        fn["winGetCaretPos"] = lib.func("AU3_WinGetCaretPos", "int", [
+            "_Out_ LPPOINT*",
+        ]);
+    }
+    let result = {};
+    return new Promise((resolve, reject) => {
+        fn["winGetCaretPos"].async(result, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+exports.winGetCaretPos = winGetCaretPos;
+const winGetClassList = (arg0, arg1 = "", arg3 = 512) => {
+    if (!fn.hasOwnProperty("winGetClassList")) {
+        fn["winGetClassList"] = lib.func("AU3_WinGetClassList", "void", [
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg3 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["winGetClassList"].async(arg0, arg1, result, arg3, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.winGetClassList = winGetClassList;
+const winGetClassListByHandle = (arg0, arg2 = 512) => {
+    if (!fn.hasOwnProperty("winGetClassListByHandle")) {
+        fn["winGetClassListByHandle"] = lib.func("AU3_WinGetClassListByHandle", "void", ["int", "LPWSTR", "int"]);
+    }
+    let result = Buffer.alloc(arg2 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["winGetClassListByHandle"].async(arg0, result, arg2, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.winGetClassListByHandle = winGetClassListByHandle;
+const winGetClientSize = (arg0, arg1 = "") => {
+    if (!fn.hasOwnProperty("winGetClientSize")) {
+        fn["winGetClientSize"] = lib.func("AU3_WinGetClientSize", "int", [
+            "string16",
+            "string16",
+            "_Out_ LPRECT*",
+        ]);
+    }
+    let result = {};
+    return new Promise((resolve, reject) => {
+        fn["winGetClientSize"].async(arg0, arg1, result, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+exports.winGetClientSize = winGetClientSize;
+const winGetClientSizeByHandle = (arg0) => {
+    if (!fn.hasOwnProperty("winGetClientSizeByHandle")) {
+        fn["winGetClientSizeByHandle"] = lib.func("AU3_WinGetClientSizeByHandle", "int", ["int", "_Out_ LPRECT*"]);
+    }
+    let result = {};
+    return new Promise((resolve, reject) => {
+        fn["winGetClientSizeByHandle"].async(arg0, result, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+exports.winGetClientSizeByHandle = winGetClientSizeByHandle;
+const winGetHandle = (arg0, arg1 = "") => {
+    if (!fn.hasOwnProperty("winGetHandle")) {
+        fn["winGetHandle"] = lib.func("AU3_WinGetHandle", "int", [
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winGetHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winGetHandle = winGetHandle;
+const winGetHandleAsText = (arg0, arg1 = "", arg3 = 256) => {
+    if (!fn.hasOwnProperty("winGetHandleAsText")) {
+        fn["winGetHandleAsText"] = lib.func("AU3_WinGetHandleAsText", "void", [
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg3 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["winGetHandleAsText"].async(arg0, arg1, result, arg3, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.winGetHandleAsText = winGetHandleAsText;
+const winGetPos = (arg0, arg1 = "") => {
+    if (!fn.hasOwnProperty("winGetPos")) {
+        fn["winGetPos"] = lib.func("AU3_WinGetPos", "int", [
+            "string16",
+            "string16",
+            "_Out_ LPRECT*",
+        ]);
+    }
+    let result = {};
+    return new Promise((resolve, reject) => {
+        fn["winGetPos"].async(arg0, arg1, result, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+exports.winGetPos = winGetPos;
+const winGetPosByHandle = (arg0) => {
+    if (!fn.hasOwnProperty("winGetPosByHandle")) {
+        fn["winGetPosByHandle"] = lib.func("AU3_WinGetPosByHandle", "int", [
+            "int",
+            "_Out_ LPRECT*",
+        ]);
+    }
+    let result = {};
+    return new Promise((resolve, reject) => {
+        fn["winGetPosByHandle"].async(arg0, result, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+exports.winGetPosByHandle = winGetPosByHandle;
+const winGetProcess = (arg0, arg1 = "") => {
+    if (!fn.hasOwnProperty("winGetProcess")) {
+        fn["winGetProcess"] = lib.func("AU3_WinGetProcess", "uint32", [
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winGetProcess"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winGetProcess = winGetProcess;
+const winGetProcessByHandle = (arg0) => {
+    if (!fn.hasOwnProperty("winGetProcessByHandle")) {
+        fn["winGetProcessByHandle"] = lib.func("AU3_WinGetProcessByHandle", "uint32", ["int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winGetProcessByHandle"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winGetProcessByHandle = winGetProcessByHandle;
+const winGetState = (arg0, arg1 = "") => {
+    if (!fn.hasOwnProperty("winGetState")) {
+        fn["winGetState"] = lib.func("AU3_WinGetState", "int", [
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winGetState"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winGetState = winGetState;
+const winGetStateByHandle = (arg0) => {
+    if (!fn.hasOwnProperty("winGetStateByHandle")) {
+        fn["winGetStateByHandle"] = lib.func("AU3_WinGetStateByHandle", "int", [
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winGetStateByHandle"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winGetStateByHandle = winGetStateByHandle;
+const winGetText = (arg0, arg1 = "", arg3 = 512) => {
+    if (!fn.hasOwnProperty("winGetText")) {
+        fn["winGetText"] = lib.func("AU3_WinGetText", "void", [
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg3 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["winGetText"].async(arg0, arg1, result, arg3, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.winGetText = winGetText;
+const winGetTextByHandle = (arg0, arg2 = 512) => {
+    if (!fn.hasOwnProperty("winGetTextByHandle")) {
+        fn["winGetTextByHandle"] = lib.func("AU3_WinGetTextByHandle", "void", [
+            "int",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg2 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["winGetTextByHandle"].async(arg0, result, arg2, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.winGetTextByHandle = winGetTextByHandle;
+const winGetTitle = (arg0, arg1 = "", arg3 = 512) => {
+    if (!fn.hasOwnProperty("winGetTitle")) {
+        fn["winGetTitle"] = lib.func("AU3_WinGetTitle", "void", [
+            "string16",
+            "string16",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg3 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["winGetTitle"].async(arg0, arg1, result, arg3, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.winGetTitle = winGetTitle;
+const winGetTitleByHandle = (arg0, arg2 = 512) => {
+    if (!fn.hasOwnProperty("winGetTitleByHandle")) {
+        fn["winGetTitleByHandle"] = lib.func("AU3_WinGetTitleByHandle", "void", [
+            "int",
+            "LPWSTR",
+            "int",
+        ]);
+    }
+    let result = Buffer.alloc(arg2 * wchar_1.default.size);
+    return new Promise((resolve, reject) => {
+        fn["winGetTitleByHandle"].async(arg0, result, arg2, (err, _) => {
+            if (err)
+                reject(err);
+            else
+                resolve((0, util_1.getWString)(result));
+        });
+    });
+};
+exports.winGetTitleByHandle = winGetTitleByHandle;
+const winKill = (arg0, arg1 = "") => {
+    if (!fn.hasOwnProperty("winKill")) {
+        fn["winKill"] = lib.func("AU3_WinKill", "int", ["string16", "string16"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winKill"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winKill = winKill;
+const winKillByHandle = (arg0) => {
+    if (!fn.hasOwnProperty("winKillByHandle")) {
+        fn["winKillByHandle"] = lib.func("AU3_WinKillByHandle", "int", ["int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winKillByHandle"].async(arg0, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winKillByHandle = winKillByHandle;
+const winMenuSelectItem = (arg0, arg1 = "", arg2, arg3 = "", arg4 = "", arg5 = "", arg6 = "", arg7 = "", arg8 = "", arg9 = "") => {
+    if (!fn.hasOwnProperty("winMenuSelectItem")) {
+        fn["winMenuSelectItem"] = lib.func("AU3_WinMenuSelectItem", "int", [
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winMenuSelectItem"].async(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winMenuSelectItem = winMenuSelectItem;
+const winMenuSelectItemByHandle = (arg0, arg1, arg2 = "", arg3 = "", arg4 = "", arg5 = "", arg6 = "", arg7 = "", arg8 = "") => {
+    if (!fn.hasOwnProperty("winMenuSelectItemByHandle")) {
+        fn["winMenuSelectItemByHandle"] = lib.func("AU3_WinMenuSelectItemByHandle", "int", [
+            "int",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winMenuSelectItemByHandle"].async(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winMenuSelectItemByHandle = winMenuSelectItemByHandle;
+const winMinimizeAll = () => {
+    if (!fn.hasOwnProperty("winMinimizeAll")) {
+        fn["winMinimizeAll"] = lib.func("AU3_WinMinimizeAll", "void", []);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winMinimizeAll"].async((err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winMinimizeAll = winMinimizeAll;
+const winMinimizeAllUndo = () => {
+    if (!fn.hasOwnProperty("winMinimizeAllUndo")) {
+        fn["winMinimizeAllUndo"] = lib.func("AU3_WinMinimizeAllUndo", "void", []);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winMinimizeAllUndo"].async((err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winMinimizeAllUndo = winMinimizeAllUndo;
+const winMove = (arg0, arg1 = "", arg2, arg3, arg4 = -1, arg5 = -1) => {
+    if (!fn.hasOwnProperty("winMove")) {
+        fn["winMove"] = lib.func("AU3_WinMove", "int", [
+            "string16",
+            "string16",
+            "int",
+            "int",
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winMove"].async(arg0, arg1, arg2, arg3, arg4, arg5, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winMove = winMove;
+const winMoveByHandle = (arg0, arg1, arg2, arg3 = -1, arg4 = -1) => {
+    if (!fn.hasOwnProperty("winMoveByHandle")) {
+        fn["winMoveByHandle"] = lib.func("AU3_WinMoveByHandle", "int", [
+            "int",
+            "int",
+            "int",
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winMoveByHandle"].async(arg0, arg1, arg2, arg3, arg4, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winMoveByHandle = winMoveByHandle;
+const winSetOnTop = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("winSetOnTop")) {
+        fn["winSetOnTop"] = lib.func("AU3_WinSetOnTop", "int", [
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winSetOnTop"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winSetOnTop = winSetOnTop;
+const winSetOnTopByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("winSetOnTopByHandle")) {
+        fn["winSetOnTopByHandle"] = lib.func("AU3_WinSetOnTopByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winSetOnTopByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winSetOnTopByHandle = winSetOnTopByHandle;
+const winSetState = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("winSetState")) {
+        fn["winSetState"] = lib.func("AU3_WinSetState", "int", [
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winSetState"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winSetState = winSetState;
+const winSetStateByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("winSetStateByHandle")) {
+        fn["winSetStateByHandle"] = lib.func("AU3_WinSetStateByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winSetStateByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winSetStateByHandle = winSetStateByHandle;
+const winSetTitle = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("winSetTitle")) {
+        fn["winSetTitle"] = lib.func("AU3_WinSetTitle", "int", [
+            "string16",
+            "string16",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winSetTitle"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winSetTitle = winSetTitle;
+const winSetTitleByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("winSetTitleByHandle")) {
+        fn["winSetTitleByHandle"] = lib.func("AU3_WinSetTitleByHandle", "int", [
+            "int",
+            "string16",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winSetTitleByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winSetTitleByHandle = winSetTitleByHandle;
+const winSetTrans = (arg0, arg1 = "", arg2) => {
+    if (!fn.hasOwnProperty("winSetTrans")) {
+        fn["winSetTrans"] = lib.func("AU3_WinSetTrans", "int", [
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winSetTrans"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winSetTrans = winSetTrans;
+const winSetTransByHandle = (arg0, arg1) => {
+    if (!fn.hasOwnProperty("winSetTransByHandle")) {
+        fn["winSetTransByHandle"] = lib.func("AU3_WinSetTransByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winSetTransByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winSetTransByHandle = winSetTransByHandle;
+const winWait = (arg0, arg1 = "", arg2 = 0) => {
+    if (!fn.hasOwnProperty("winWait")) {
+        fn["winWait"] = lib.func("AU3_WinWait", "int", [
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winWait"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winWait = winWait;
+const winWaitByHandle = (arg0, arg1 = 0) => {
+    if (!fn.hasOwnProperty("winWaitByHandle")) {
+        fn["winWaitByHandle"] = lib.func("AU3_WinWaitByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winWaitByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winWaitByHandle = winWaitByHandle;
+const winWaitActive = (arg0, arg1 = "", arg2 = 0) => {
+    if (!fn.hasOwnProperty("winWaitActive")) {
+        fn["winWaitActive"] = lib.func("AU3_WinWaitActive", "int", [
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winWaitActive"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winWaitActive = winWaitActive;
+const winWaitActiveByHandle = (arg0, arg1 = 0) => {
+    if (!fn.hasOwnProperty("winWaitActiveByHandle")) {
+        fn["winWaitActiveByHandle"] = lib.func("AU3_WinWaitActiveByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winWaitActiveByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winWaitActiveByHandle = winWaitActiveByHandle;
+const winWaitClose = (arg0, arg1 = "", arg2 = 0) => {
+    if (!fn.hasOwnProperty("winWaitClose")) {
+        fn["winWaitClose"] = lib.func("AU3_WinWaitClose", "int", [
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winWaitClose"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winWaitClose = winWaitClose;
+const winWaitCloseByHandle = (arg0, arg1 = 0) => {
+    if (!fn.hasOwnProperty("winWaitCloseByHandle")) {
+        fn["winWaitCloseByHandle"] = lib.func("AU3_WinWaitCloseByHandle", "int", [
+            "int",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winWaitCloseByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winWaitCloseByHandle = winWaitCloseByHandle;
+const winWaitNotActive = (arg0, arg1 = "", arg2 = 0) => {
+    if (!fn.hasOwnProperty("winWaitNotActive")) {
+        fn["winWaitNotActive"] = lib.func("AU3_WinWaitNotActive", "int", [
+            "string16",
+            "string16",
+            "int",
+        ]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winWaitNotActive"].async(arg0, arg1, arg2, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winWaitNotActive = winWaitNotActive;
+const winWaitNotActiveByHandle = (arg0, arg1 = 0) => {
+    if (!fn.hasOwnProperty("winWaitNotActiveByHandle")) {
+        fn["winWaitNotActiveByHandle"] = lib.func("AU3_WinWaitNotActiveByHandle", "int", ["int", "int"]);
+    }
+    return new Promise((resolve, reject) => {
+        fn["winWaitNotActiveByHandle"].async(arg0, arg1, (err, res) => {
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        });
+    });
+};
+exports.winWaitNotActiveByHandle = winWaitNotActiveByHandle;