2 年之前 · 8c58e778ad
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
 
				+unpackage
			
--- a/Asistent/.hbuilderx/launch.json
+++ b/Asistent/.hbuilderx/launch.json
@@ -0,0 +1,26 @@
 
				+{
			
 
				+    // launch.json 配置了启动调试时相关设置，configurations下节点名称可为 app-plus/h5/mp-weixin/mp-baidu/mp-alipay/mp-qq/mp-toutiao/mp-360/
			
 
				+    // launchtype项可配置值为local或remote, local代表前端连本地云函数，remote代表前端连云端云函数
			
 
				+    "version" : "0.0",
			
 
				+    "configurations" : [
			
 
				+        {
			
 
				+        	"app-plus" : 
			
 
				+        	{
			
 
				+        		"launchtype" : "local"
			
 
				+        	},
			
 
				+        	"default" : 
			
 
				+        	{
			
 
				+        		"launchtype" : "local"
			
 
				+        	},
			
 
				+        	"mp-weixin" : 
			
 
				+        	{
			
 
				+        		"launchtype" : "local"
			
 
				+        	},
			
 
				+        	"type" : "uniCloud"
			
 
				+        },
			
 
				+        {
			
 
				+            "playground" : "standard",
			
 
				+            "type" : "uni-app:app-android"
			
 
				+        }
			
 
				+    ]
			
 
				+}
			
--- a/Asistent/App.vue
+++ b/Asistent/App.vue
@@ -0,0 +1,29 @@
 
				+<script>
			
 
				+	export default {
			
 
				+		onLaunch: function() {
			
 
				+			console.log('App Launch')
			
 
				+		},
			
 
				+		onShow: function() {
			
 
				+			console.log('App Show')
			
 
				+		},
			
 
				+		onHide: function() {
			
 
				+			console.log('App Hide')
			
 
				+		}
			
 
				+	}
			
 
				+</script>
			
 
				+
			
 
				+<style lang="scss">
			
 
				+	/*每个页面公共css */
			
 
				+	@import '@/uni_modules/uni-scss/index.scss';
			
 
				+
			
 
				+	/* #ifndef APP-NVUE */
			
 
				+	@import '@/static/customicons.css';
			
 
				+
			
 
				+	// 设置整个项目的背景色
			
 
				+	page {
			
 
				+		// background-color: #f5f5f5;
			
 
				+		background-color: #fff;
			
 
				+	}
			
 
				+
			
 
				+	/* #endif */
			
 
				+</style>
			
--- a/Asistent/grpc
+++ b/Asistent/grpc
@@ -0,0 +1 @@
 
				+Subproject commit d67c6d16572b2b2bf192d347aa913de3b988d8e1
			
--- a/Asistent/index.html
+++ b/Asistent/index.html
@@ -0,0 +1,20 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+  <head>
			
 
				+    <meta charset="UTF-8" />
			
 
				+    <script>
			
 
				+      var coverSupport = 'CSS' in window && typeof CSS.supports === 'function' && (CSS.supports('top: env(a)') ||
			
 
				+        CSS.supports('top: constant(a)'))
			
 
				+      document.write(
			
 
				+        '<meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0' +
			
 
				+        (coverSupport ? ', viewport-fit=cover' : '') + '" />')
			
 
				+    </script>
			
 
				+    <title></title>
			
 
				+    <!--preload-links-->
			
 
				+    <!--app-context-->
			
 
				+  </head>
			
 
				+  <body>
			
 
				+    <div id="app"><!--app-html--></div>
			
 
				+    <script type="module" src="/main.js"></script>
			
 
				+  </body>
			
 
				+</html>
			
--- a/Asistent/main.js
+++ b/Asistent/main.js
@@ -0,0 +1,45 @@
 
				+// #ifndef VUE3
			
 
				+import Vue from 'vue'
			
 
				+import App from './App'
			
 
				+import {
			
 
				+	ApiAppClient
			
 
				+} from "./grpc/app_api_grpc_web_pb.js"
			
 
				+import nfc from './utils/ouu-nfc.js'
			
 
				+
			
 
				+Vue.config.productionTip = false
			
 
				+
			
 
				+App.mpType = 'app'
			
 
				+
			
 
				+// 建立grpc连接服务 
			
 
				+
			
 
				+// 测试版
			
 
				+// let client = new ApiAppClient("http://192.168.0.3:10000", null, null)
			
 
				+// let client = new ApiAppClient("http://t-otapi.beswell.com:10000", null, null)
			
 
				+
			
 
				+// 正式版
			
 
				+let client = new ApiAppClient("http://otapi.beswell.com:10000", null, null)
			
 
				+
			
 
				+// 挂载为全局方法 
			
 
				+Vue.prototype.$client = client
			
 
				+Vue.prototype.$nfc = nfc
			
 
				+
			
 
				+nfc.listenNFCStatus();
			
 
				+
			
 
				+const app = new Vue({
			
 
				+	...App
			
 
				+})
			
 
				+app.$mount()
			
 
				+// #endif
			
 
				+
			
 
				+// #ifdef VUE3
			
 
				+import {
			
 
				+	createSSRApp
			
 
				+} from 'vue'
			
 
				+import App from './App.vue'
			
 
				+export function createApp() {
			
 
				+	const app = createSSRApp(App)
			
 
				+	return {
			
 
				+		app
			
 
				+	}
			
 
				+}
			
 
				+// #endif
			
--- a/Asistent/manifest.json
+++ b/Asistent/manifest.json
@@ -0,0 +1,83 @@
 
				+{
			
 
				+    "name" : "Assitent",
			
 
				+    "appid" : "__UNI__E5E85BC",
			
 
				+    "description" : "小飞龙定向助手",
			
 
				+    "versionName" : "1.0.0",
			
 
				+    "versionCode" : "100",
			
 
				+    "transformPx" : false,
			
 
				+    "app-plus" : {
			
 
				+        /* 5+App特有相关 */
			
 
				+        "usingComponents" : true,
			
 
				+        "nvueCompiler" : "uni-app",
			
 
				+        "nvueStyleCompiler" : "uni-app",
			
 
				+        "splashscreen" : {
			
 
				+            "alwaysShowBeforeRender" : true,
			
 
				+            "waiting" : true,
			
 
				+            "autoclose" : true,
			
 
				+            "delay" : 0
			
 
				+        },
			
 
				+        "modules" : {
			
 
				+            "Barcode" : {},
			
 
				+            "Geolocation" : {}
			
 
				+        },
			
 
				+        /* 模块配置 */
			
 
				+        "distribute" : {
			
 
				+            /* 应用发布信息 */
			
 
				+            "android" : {
			
 
				+                /* android打包配置 */
			
 
				+                "permissions" : [
			
 
				+                    "<uses-feature android:name=\"android.hardware.camera\"/>",
			
 
				+                    "<uses-feature android:name=\"android.hardware.camera.autofocus\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.ACCESS_COARSE_LOCATION\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.ACCESS_FINE_LOCATION\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.ACCESS_NETWORK_STATE\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.ACCESS_WIFI_STATE\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.BIND_NFC_SERVICE\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.CAMERA\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.CHANGE_NETWORK_STATE\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.CHANGE_WIFI_STATE\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.FLASHLIGHT\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.GET_ACCOUNTS\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.MOUNT_UNMOUNT_FILESYSTEMS\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.NFC\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.READ_LOGS\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.READ_PHONE_STATE\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.VIBRATE\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.WAKE_LOCK\"/>",
			
 
				+                    "<uses-permission android:name=\"android.permission.WRITE_SETTINGS\"/>"
			
 
				+                ]
			
 
				+            },
			
 
				+            "ios" : {
			
 
				+                "dSYMs" : false
			
 
				+            },
			
 
				+            /* ios打包配置 */
			
 
				+            "sdkConfigs" : {
			
 
				+                "geolocation" : {
			
 
				+                    "system" : {
			
 
				+                        "__platform__" : [ "ios", "android" ]
			
 
				+                    }
			
 
				+                },
			
 
				+                "ad" : {}
			
 
				+            }
			
 
				+        }
			
 
				+    },
			
 
				+    /* SDK配置 */
			
 
				+    "quickapp" : {},
			
 
				+    /* 快应用特有相关 */
			
 
				+    "mp-weixin" : {
			
 
				+        /* 小程序特有相关 */
			
 
				+        "appid" : "",
			
 
				+        "setting" : {
			
 
				+            "urlCheck" : false
			
 
				+        },
			
 
				+        "usingComponents" : true
			
 
				+    },
			
 
				+    "vueVersion" : "2",
			
 
				+    "h5" : {
			
 
				+        "optimization" : {
			
 
				+            "treeShaking" : {
			
 
				+                "enable" : true
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+}
			
--- a/Asistent/node_modules/.package-lock.json
+++ b/Asistent/node_modules/.package-lock.json
@@ -0,0 +1,104 @@
 
				+{
			
 
				+  "name": "Asistent",
			
 
				+  "lockfileVersion": 2,
			
 
				+  "requires": true,
			
 
				+  "packages": {
			
 
				+    "node_modules/@protobufjs/aspromise": {
			
 
				+      "version": "1.1.2",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
			
 
				+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ=="
			
 
				+    },
			
 
				+    "node_modules/@protobufjs/base64": {
			
 
				+      "version": "1.1.2",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/base64/-/base64-1.1.2.tgz",
			
 
				+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg=="
			
 
				+    },
			
 
				+    "node_modules/@protobufjs/codegen": {
			
 
				+      "version": "2.0.4",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/codegen/-/codegen-2.0.4.tgz",
			
 
				+      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg=="
			
 
				+    },
			
 
				+    "node_modules/@protobufjs/eventemitter": {
			
 
				+      "version": "1.1.0",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
			
 
				+      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q=="
			
 
				+    },
			
 
				+    "node_modules/@protobufjs/fetch": {
			
 
				+      "version": "1.1.0",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/fetch/-/fetch-1.1.0.tgz",
			
 
				+      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
			
 
				+      "dependencies": {
			
 
				+        "@protobufjs/aspromise": "^1.1.1",
			
 
				+        "@protobufjs/inquire": "^1.1.0"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@protobufjs/float": {
			
 
				+      "version": "1.0.2",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/float/-/float-1.0.2.tgz",
			
 
				+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ=="
			
 
				+    },
			
 
				+    "node_modules/@protobufjs/inquire": {
			
 
				+      "version": "1.1.0",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/inquire/-/inquire-1.1.0.tgz",
			
 
				+      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q=="
			
 
				+    },
			
 
				+    "node_modules/@protobufjs/path": {
			
 
				+      "version": "1.1.2",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/path/-/path-1.1.2.tgz",
			
 
				+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA=="
			
 
				+    },
			
 
				+    "node_modules/@protobufjs/pool": {
			
 
				+      "version": "1.1.0",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/pool/-/pool-1.1.0.tgz",
			
 
				+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw=="
			
 
				+    },
			
 
				+    "node_modules/@protobufjs/utf8": {
			
 
				+      "version": "1.1.0",
			
 
				+      "resolved": "https://registry.npmmirror.com/@protobufjs/utf8/-/utf8-1.1.0.tgz",
			
 
				+      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw=="
			
 
				+    },
			
 
				+    "node_modules/@types/node": {
			
 
				+      "version": "18.15.1",
			
 
				+      "resolved": "https://registry.npmmirror.com/@types/node/-/node-18.15.1.tgz",
			
 
				+      "integrity": "sha512-U2TWca8AeHSmbpi314QBESRk7oPjSZjDsR+c+H4ECC1l+kFgpZf8Ydhv3SJpPy51VyZHHqxlb6mTTqYNNRVAIw=="
			
 
				+    },
			
 
				+    "node_modules/base-64": {
			
 
				+      "version": "1.0.0",
			
 
				+      "resolved": "https://registry.npmmirror.com/base-64/-/base-64-1.0.0.tgz",
			
 
				+      "integrity": "sha512-kwDPIFCGx0NZHog36dj+tHiwP4QMzsZ3AgMViUBKI0+V5n4U0ufTCUMhnQ04diaRI8EX/QcPfql7zlhZ7j4zgg=="
			
 
				+    },
			
 
				+    "node_modules/grpc-web": {
			
 
				+      "version": "1.4.2",
			
 
				+      "resolved": "https://registry.npmmirror.com/grpc-web/-/grpc-web-1.4.2.tgz",
			
 
				+      "integrity": "sha512-gUxWq42l5ldaRplcKb4Pw5O4XBONWZgz3vxIIXnfIeJj8Jc3wYiq2O4c9xzx/NGbbPEej4rhI62C9eTENwLGNw=="
			
 
				+    },
			
 
				+    "node_modules/long": {
			
 
				+      "version": "5.2.1",
			
 
				+      "resolved": "https://registry.npmmirror.com/long/-/long-5.2.1.tgz",
			
 
				+      "integrity": "sha512-GKSNGeNAtw8IryjjkhZxuKB3JzlcLTwjtiQCHKvqQet81I93kXslhDQruGI/QsddO83mcDToBVy7GqGS/zYf/A=="
			
 
				+    },
			
 
				+    "node_modules/protobufjs": {
			
 
				+      "version": "7.2.2",
			
 
				+      "resolved": "https://registry.npmmirror.com/protobufjs/-/protobufjs-7.2.2.tgz",
			
 
				+      "integrity": "sha512-++PrQIjrom+bFDPpfmqXfAGSQs40116JRrqqyf53dymUMvvb5d/LMRyicRoF1AUKoXVS1/IgJXlEgcpr4gTF3Q==",
			
 
				+      "hasInstallScript": true,
			
 
				+      "dependencies": {
			
 
				+        "@protobufjs/aspromise": "^1.1.2",
			
 
				+        "@protobufjs/base64": "^1.1.2",
			
 
				+        "@protobufjs/codegen": "^2.0.4",
			
 
				+        "@protobufjs/eventemitter": "^1.1.0",
			
 
				+        "@protobufjs/fetch": "^1.1.0",
			
 
				+        "@protobufjs/float": "^1.0.2",
			
 
				+        "@protobufjs/inquire": "^1.1.0",
			
 
				+        "@protobufjs/path": "^1.1.2",
			
 
				+        "@protobufjs/pool": "^1.1.0",
			
 
				+        "@protobufjs/utf8": "^1.1.0",
			
 
				+        "@types/node": ">=13.7.0",
			
 
				+        "long": "^5.0.0"
			
 
				+      },
			
 
				+      "engines": {
			
 
				+        "node": ">=12.0.0"
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/aspromise/LICENSE
+++ b/Asistent/node_modules/@protobufjs/aspromise/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/aspromise/README.md
+++ b/Asistent/node_modules/@protobufjs/aspromise/README.md
@@ -0,0 +1,13 @@
 
				+@protobufjs/aspromise
			
 
				+=====================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/aspromise.svg)](https://www.npmjs.com/package/@protobufjs/aspromise)
			
 
				+
			
 
				+Returns a promise from a node-style callback function.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **asPromise(fn: `function`, ctx: `Object`, ...params: `*`): `Promise<*>`**<br />
			
 
				+  Returns a promise from a node-style callback function.
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/aspromise/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/aspromise/index.d.ts
@@ -0,0 +1,13 @@
 
				+export = asPromise;
			
 
				+
			
 
				+type asPromiseCallback = (error: Error | null, ...params: any[]) => {};
			
 
				+
			
 
				+/**
			
 
				+ * Returns a promise from a node-style callback function.
			
 
				+ * @memberof util
			
 
				+ * @param {asPromiseCallback} fn Function to call
			
 
				+ * @param {*} ctx Function context
			
 
				+ * @param {...*} params Function arguments
			
 
				+ * @returns {Promise<*>} Promisified function
			
 
				+ */
			
 
				+declare function asPromise(fn: asPromiseCallback, ctx: any, ...params: any[]): Promise<any>;
			
--- a/Asistent/node_modules/@protobufjs/aspromise/index.js
+++ b/Asistent/node_modules/@protobufjs/aspromise/index.js
@@ -0,0 +1,52 @@
 
				+"use strict";
			
 
				+module.exports = asPromise;
			
 
				+
			
 
				+/**
			
 
				+ * Callback as used by {@link util.asPromise}.
			
 
				+ * @typedef asPromiseCallback
			
 
				+ * @type {function}
			
 
				+ * @param {Error|null} error Error, if any
			
 
				+ * @param {...*} params Additional arguments
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Returns a promise from a node-style callback function.
			
 
				+ * @memberof util
			
 
				+ * @param {asPromiseCallback} fn Function to call
			
 
				+ * @param {*} ctx Function context
			
 
				+ * @param {...*} params Function arguments
			
 
				+ * @returns {Promise<*>} Promisified function
			
 
				+ */
			
 
				+function asPromise(fn, ctx/*, varargs */) {
			
 
				+    var params  = new Array(arguments.length - 1),
			
 
				+        offset  = 0,
			
 
				+        index   = 2,
			
 
				+        pending = true;
			
 
				+    while (index < arguments.length)
			
 
				+        params[offset++] = arguments[index++];
			
 
				+    return new Promise(function executor(resolve, reject) {
			
 
				+        params[offset] = function callback(err/*, varargs */) {
			
 
				+            if (pending) {
			
 
				+                pending = false;
			
 
				+                if (err)
			
 
				+                    reject(err);
			
 
				+                else {
			
 
				+                    var params = new Array(arguments.length - 1),
			
 
				+                        offset = 0;
			
 
				+                    while (offset < params.length)
			
 
				+                        params[offset++] = arguments[offset];
			
 
				+                    resolve.apply(null, params);
			
 
				+                }
			
 
				+            }
			
 
				+        };
			
 
				+        try {
			
 
				+            fn.apply(ctx || null, params);
			
 
				+        } catch (err) {
			
 
				+            if (pending) {
			
 
				+                pending = false;
			
 
				+                reject(err);
			
 
				+            }
			
 
				+        }
			
 
				+    });
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/aspromise/package.json
+++ b/Asistent/node_modules/@protobufjs/aspromise/package.json
@@ -0,0 +1,21 @@
 
				+{
			
 
				+  "name": "@protobufjs/aspromise",
			
 
				+  "description": "Returns a promise from a node-style callback function.",
			
 
				+  "version": "1.1.2",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts",
			
 
				+  "devDependencies": {
			
 
				+    "istanbul": "^0.4.5",
			
 
				+    "tape": "^4.6.3"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "test": "tape tests/*.js",
			
 
				+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/aspromise/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/aspromise/tests/index.js
@@ -0,0 +1,130 @@
 
				+var tape = require("tape");
			
 
				+
			
 
				+var asPromise = require("..");
			
 
				+
			
 
				+tape.test("aspromise", function(test) {
			
 
				+
			
 
				+    test.test(this.name + " - resolve", function(test) {
			
 
				+
			
 
				+        function fn(arg1, arg2, callback) {
			
 
				+            test.equal(this, ctx, "function should be called with this = ctx");
			
 
				+            test.equal(arg1, 1, "function should be called with arg1 = 1");
			
 
				+            test.equal(arg2, 2, "function should be called with arg2 = 2");
			
 
				+            callback(null, arg2);
			
 
				+        }
			
 
				+
			
 
				+        var ctx = {};
			
 
				+
			
 
				+        var promise = asPromise(fn, ctx, 1, 2);
			
 
				+        promise.then(function(arg2) {
			
 
				+            test.equal(arg2, 2, "promise should be resolved with arg2 = 2");
			
 
				+            test.end();
			
 
				+        }).catch(function(err) {
			
 
				+            test.fail("promise should not be rejected (" + err + ")");
			
 
				+        });
			
 
				+    });
			
 
				+
			
 
				+    test.test(this.name + " - reject", function(test) {
			
 
				+
			
 
				+        function fn(arg1, arg2, callback) {
			
 
				+            test.equal(this, ctx, "function should be called with this = ctx");
			
 
				+            test.equal(arg1, 1, "function should be called with arg1 = 1");
			
 
				+            test.equal(arg2, 2, "function should be called with arg2 = 2");
			
 
				+            callback(arg1);
			
 
				+        }
			
 
				+
			
 
				+        var ctx = {};
			
 
				+
			
 
				+        var promise = asPromise(fn, ctx, 1, 2);
			
 
				+        promise.then(function() {
			
 
				+            test.fail("promise should not be resolved");
			
 
				+        }).catch(function(err) {
			
 
				+            test.equal(err, 1, "promise should be rejected with err = 1");
			
 
				+            test.end();
			
 
				+        });
			
 
				+    });
			
 
				+
			
 
				+    test.test(this.name + " - resolve twice", function(test) {
			
 
				+
			
 
				+        function fn(arg1, arg2, callback) {
			
 
				+            test.equal(this, ctx, "function should be called with this = ctx");
			
 
				+            test.equal(arg1, 1, "function should be called with arg1 = 1");
			
 
				+            test.equal(arg2, 2, "function should be called with arg2 = 2");
			
 
				+            callback(null, arg2);
			
 
				+            callback(null, arg1);
			
 
				+        }
			
 
				+
			
 
				+        var ctx = {};
			
 
				+        var count = 0;
			
 
				+
			
 
				+        var promise = asPromise(fn, ctx, 1, 2);
			
 
				+        promise.then(function(arg2) {
			
 
				+            test.equal(arg2, 2, "promise should be resolved with arg2 = 2");
			
 
				+            if (++count > 1)
			
 
				+                test.fail("promise should not be resolved twice");
			
 
				+            test.end();
			
 
				+        }).catch(function(err) {
			
 
				+            test.fail("promise should not be rejected (" + err + ")");
			
 
				+        });
			
 
				+    });
			
 
				+
			
 
				+    test.test(this.name + " - reject twice", function(test) {
			
 
				+
			
 
				+        function fn(arg1, arg2, callback) {
			
 
				+            test.equal(this, ctx, "function should be called with this = ctx");
			
 
				+            test.equal(arg1, 1, "function should be called with arg1 = 1");
			
 
				+            test.equal(arg2, 2, "function should be called with arg2 = 2");
			
 
				+            callback(arg1);
			
 
				+            callback(arg2);
			
 
				+        }
			
 
				+
			
 
				+        var ctx = {};
			
 
				+        var count = 0;
			
 
				+
			
 
				+        var promise = asPromise(fn, ctx, 1, 2);
			
 
				+        promise.then(function() {
			
 
				+            test.fail("promise should not be resolved");
			
 
				+        }).catch(function(err) {
			
 
				+            test.equal(err, 1, "promise should be rejected with err = 1");
			
 
				+            if (++count > 1)
			
 
				+                test.fail("promise should not be rejected twice");
			
 
				+            test.end();
			
 
				+        });
			
 
				+    });
			
 
				+
			
 
				+    test.test(this.name + " - reject error", function(test) {
			
 
				+
			
 
				+        function fn(callback) {
			
 
				+            test.ok(arguments.length === 1 && typeof callback === "function", "function should be called with just a callback");
			
 
				+            throw 3;
			
 
				+        }
			
 
				+
			
 
				+        var promise = asPromise(fn, null);
			
 
				+        promise.then(function() {
			
 
				+            test.fail("promise should not be resolved");
			
 
				+        }).catch(function(err) {
			
 
				+            test.equal(err, 3, "promise should be rejected with err = 3");
			
 
				+            test.end();
			
 
				+        });
			
 
				+    });
			
 
				+
			
 
				+    test.test(this.name + " - reject and error", function(test) {
			
 
				+
			
 
				+        function fn(callback) {
			
 
				+            callback(3);
			
 
				+            throw 4;
			
 
				+        }
			
 
				+
			
 
				+        var count = 0;
			
 
				+
			
 
				+        var promise = asPromise(fn, null);
			
 
				+        promise.then(function() {
			
 
				+            test.fail("promise should not be resolved");
			
 
				+        }).catch(function(err) {
			
 
				+            test.equal(err, 3, "promise should be rejected with err = 3");
			
 
				+            if (++count > 1)
			
 
				+                test.fail("promise should not be rejected twice");
			
 
				+            test.end();
			
 
				+        });
			
 
				+    });
			
 
				+});
			
--- a/Asistent/node_modules/@protobufjs/base64/LICENSE
+++ b/Asistent/node_modules/@protobufjs/base64/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/base64/README.md
+++ b/Asistent/node_modules/@protobufjs/base64/README.md
@@ -0,0 +1,19 @@
 
				+@protobufjs/base64
			
 
				+==================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/base64.svg)](https://www.npmjs.com/package/@protobufjs/base64)
			
 
				+
			
 
				+A minimal base64 implementation for number arrays.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **base64.length(string: `string`): `number`**<br />
			
 
				+  Calculates the byte length of a base64 encoded string.
			
 
				+
			
 
				+* **base64.encode(buffer: `Uint8Array`, start: `number`, end: `number`): `string`**<br />
			
 
				+  Encodes a buffer to a base64 encoded string.
			
 
				+
			
 
				+* **base64.decode(string: `string`, buffer: `Uint8Array`, offset: `number`): `number`**<br />
			
 
				+  Decodes a base64 encoded string to a buffer.
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/base64/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/base64/index.d.ts
@@ -0,0 +1,32 @@
 
				+/**
			
 
				+ * Calculates the byte length of a base64 encoded string.
			
 
				+ * @param {string} string Base64 encoded string
			
 
				+ * @returns {number} Byte length
			
 
				+ */
			
 
				+export function length(string: string): number;
			
 
				+
			
 
				+/**
			
 
				+ * Encodes a buffer to a base64 encoded string.
			
 
				+ * @param {Uint8Array} buffer Source buffer
			
 
				+ * @param {number} start Source start
			
 
				+ * @param {number} end Source end
			
 
				+ * @returns {string} Base64 encoded string
			
 
				+ */
			
 
				+export function encode(buffer: Uint8Array, start: number, end: number): string;
			
 
				+
			
 
				+/**
			
 
				+ * Decodes a base64 encoded string to a buffer.
			
 
				+ * @param {string} string Source string
			
 
				+ * @param {Uint8Array} buffer Destination buffer
			
 
				+ * @param {number} offset Destination offset
			
 
				+ * @returns {number} Number of bytes written
			
 
				+ * @throws {Error} If encoding is invalid
			
 
				+ */
			
 
				+export function decode(string: string, buffer: Uint8Array, offset: number): number;
			
 
				+
			
 
				+/**
			
 
				+ * Tests if the specified string appears to be base64 encoded.
			
 
				+ * @param {string} string String to test
			
 
				+ * @returns {boolean} `true` if it appears to be base64 encoded, otherwise false
			
 
				+ */
			
 
				+export function test(string: string): boolean;
			
--- a/Asistent/node_modules/@protobufjs/base64/index.js
+++ b/Asistent/node_modules/@protobufjs/base64/index.js
@@ -0,0 +1,139 @@
 
				+"use strict";
			
 
				+
			
 
				+/**
			
 
				+ * A minimal base64 implementation for number arrays.
			
 
				+ * @memberof util
			
 
				+ * @namespace
			
 
				+ */
			
 
				+var base64 = exports;
			
 
				+
			
 
				+/**
			
 
				+ * Calculates the byte length of a base64 encoded string.
			
 
				+ * @param {string} string Base64 encoded string
			
 
				+ * @returns {number} Byte length
			
 
				+ */
			
 
				+base64.length = function length(string) {
			
 
				+    var p = string.length;
			
 
				+    if (!p)
			
 
				+        return 0;
			
 
				+    var n = 0;
			
 
				+    while (--p % 4 > 1 && string.charAt(p) === "=")
			
 
				+        ++n;
			
 
				+    return Math.ceil(string.length * 3) / 4 - n;
			
 
				+};
			
 
				+
			
 
				+// Base64 encoding table
			
 
				+var b64 = new Array(64);
			
 
				+
			
 
				+// Base64 decoding table
			
 
				+var s64 = new Array(123);
			
 
				+
			
 
				+// 65..90, 97..122, 48..57, 43, 47
			
 
				+for (var i = 0; i < 64;)
			
 
				+    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
			
 
				+
			
 
				+/**
			
 
				+ * Encodes a buffer to a base64 encoded string.
			
 
				+ * @param {Uint8Array} buffer Source buffer
			
 
				+ * @param {number} start Source start
			
 
				+ * @param {number} end Source end
			
 
				+ * @returns {string} Base64 encoded string
			
 
				+ */
			
 
				+base64.encode = function encode(buffer, start, end) {
			
 
				+    var parts = null,
			
 
				+        chunk = [];
			
 
				+    var i = 0, // output index
			
 
				+        j = 0, // goto index
			
 
				+        t;     // temporary
			
 
				+    while (start < end) {
			
 
				+        var b = buffer[start++];
			
 
				+        switch (j) {
			
 
				+            case 0:
			
 
				+                chunk[i++] = b64[b >> 2];
			
 
				+                t = (b & 3) << 4;
			
 
				+                j = 1;
			
 
				+                break;
			
 
				+            case 1:
			
 
				+                chunk[i++] = b64[t | b >> 4];
			
 
				+                t = (b & 15) << 2;
			
 
				+                j = 2;
			
 
				+                break;
			
 
				+            case 2:
			
 
				+                chunk[i++] = b64[t | b >> 6];
			
 
				+                chunk[i++] = b64[b & 63];
			
 
				+                j = 0;
			
 
				+                break;
			
 
				+        }
			
 
				+        if (i > 8191) {
			
 
				+            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
			
 
				+            i = 0;
			
 
				+        }
			
 
				+    }
			
 
				+    if (j) {
			
 
				+        chunk[i++] = b64[t];
			
 
				+        chunk[i++] = 61;
			
 
				+        if (j === 1)
			
 
				+            chunk[i++] = 61;
			
 
				+    }
			
 
				+    if (parts) {
			
 
				+        if (i)
			
 
				+            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
			
 
				+        return parts.join("");
			
 
				+    }
			
 
				+    return String.fromCharCode.apply(String, chunk.slice(0, i));
			
 
				+};
			
 
				+
			
 
				+var invalidEncoding = "invalid encoding";
			
 
				+
			
 
				+/**
			
 
				+ * Decodes a base64 encoded string to a buffer.
			
 
				+ * @param {string} string Source string
			
 
				+ * @param {Uint8Array} buffer Destination buffer
			
 
				+ * @param {number} offset Destination offset
			
 
				+ * @returns {number} Number of bytes written
			
 
				+ * @throws {Error} If encoding is invalid
			
 
				+ */
			
 
				+base64.decode = function decode(string, buffer, offset) {
			
 
				+    var start = offset;
			
 
				+    var j = 0, // goto index
			
 
				+        t;     // temporary
			
 
				+    for (var i = 0; i < string.length;) {
			
 
				+        var c = string.charCodeAt(i++);
			
 
				+        if (c === 61 && j > 1)
			
 
				+            break;
			
 
				+        if ((c = s64[c]) === undefined)
			
 
				+            throw Error(invalidEncoding);
			
 
				+        switch (j) {
			
 
				+            case 0:
			
 
				+                t = c;
			
 
				+                j = 1;
			
 
				+                break;
			
 
				+            case 1:
			
 
				+                buffer[offset++] = t << 2 | (c & 48) >> 4;
			
 
				+                t = c;
			
 
				+                j = 2;
			
 
				+                break;
			
 
				+            case 2:
			
 
				+                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
			
 
				+                t = c;
			
 
				+                j = 3;
			
 
				+                break;
			
 
				+            case 3:
			
 
				+                buffer[offset++] = (t & 3) << 6 | c;
			
 
				+                j = 0;
			
 
				+                break;
			
 
				+        }
			
 
				+    }
			
 
				+    if (j === 1)
			
 
				+        throw Error(invalidEncoding);
			
 
				+    return offset - start;
			
 
				+};
			
 
				+
			
 
				+/**
			
 
				+ * Tests if the specified string appears to be base64 encoded.
			
 
				+ * @param {string} string String to test
			
 
				+ * @returns {boolean} `true` if probably base64 encoded, otherwise false
			
 
				+ */
			
 
				+base64.test = function test(string) {
			
 
				+    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
			
 
				+};
			
--- a/Asistent/node_modules/@protobufjs/base64/package.json
+++ b/Asistent/node_modules/@protobufjs/base64/package.json
@@ -0,0 +1,21 @@
 
				+{
			
 
				+  "name": "@protobufjs/base64",
			
 
				+  "description": "A minimal base64 implementation for number arrays.",
			
 
				+  "version": "1.1.2",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts",
			
 
				+  "devDependencies": {
			
 
				+    "istanbul": "^0.4.5",
			
 
				+    "tape": "^4.6.3"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "test": "tape tests/*.js",
			
 
				+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/base64/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/base64/tests/index.js
@@ -0,0 +1,46 @@
 
				+var tape = require("tape");
			
 
				+
			
 
				+var base64 = require("..");
			
 
				+
			
 
				+var strings = {
			
 
				+    "": "",
			
 
				+    "a": "YQ==",
			
 
				+    "ab": "YWI=",
			
 
				+    "abcdefg": "YWJjZGVmZw==",
			
 
				+    "abcdefgh": "YWJjZGVmZ2g=",
			
 
				+    "abcdefghi": "YWJjZGVmZ2hp"
			
 
				+};
			
 
				+
			
 
				+tape.test("base64", function(test) {
			
 
				+
			
 
				+    Object.keys(strings).forEach(function(str) {
			
 
				+        var enc = strings[str];
			
 
				+
			
 
				+        test.equal(base64.test(enc), true, "should detect '" + enc + "' to be base64 encoded");
			
 
				+
			
 
				+        var len = base64.length(enc);
			
 
				+        test.equal(len, str.length, "should calculate '" + enc + "' as " + str.length + " bytes");
			
 
				+
			
 
				+        var buf = new Array(len);
			
 
				+        var len2 = base64.decode(enc, buf, 0);
			
 
				+        test.equal(len2, len, "should decode '" + enc + "' to " + len + " bytes");
			
 
				+
			
 
				+        test.equal(String.fromCharCode.apply(String, buf), str, "should decode '" + enc + "' to '" + str + "'");
			
 
				+
			
 
				+        var enc2 = base64.encode(buf, 0, buf.length);
			
 
				+        test.equal(enc2, enc, "should encode '" + str + "' to '" + enc + "'");
			
 
				+
			
 
				+    });
			
 
				+
			
 
				+    test.throws(function() {
			
 
				+        var buf = new Array(10);
			
 
				+        base64.decode("YQ!", buf, 0);
			
 
				+    }, Error, "should throw if encoding is invalid");
			
 
				+
			
 
				+    test.throws(function() {
			
 
				+        var buf = new Array(10);
			
 
				+        base64.decode("Y", buf, 0);
			
 
				+    }, Error, "should throw if string is truncated");
			
 
				+
			
 
				+    test.end();
			
 
				+});
			
--- a/Asistent/node_modules/@protobufjs/codegen/LICENSE
+++ b/Asistent/node_modules/@protobufjs/codegen/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/codegen/README.md
+++ b/Asistent/node_modules/@protobufjs/codegen/README.md
@@ -0,0 +1,49 @@
 
				+@protobufjs/codegen
			
 
				+===================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/codegen.svg)](https://www.npmjs.com/package/@protobufjs/codegen)
			
 
				+
			
 
				+A minimalistic code generation utility.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **codegen([functionParams: `string[]`], [functionName: string]): `Codegen`**<br />
			
 
				+  Begins generating a function.
			
 
				+
			
 
				+* **codegen.verbose = `false`**<br />
			
 
				+  When set to true, codegen will log generated code to console. Useful for debugging.
			
 
				+
			
 
				+Invoking **codegen** returns an appender function that appends code to the function's body and returns itself:
			
 
				+
			
 
				+* **Codegen(formatString: `string`, [...formatParams: `any`]): Codegen**<br />
			
 
				+  Appends code to the function's body. The format string can contain placeholders specifying the types of inserted format parameters:
			
 
				+
			
 
				+  * `%d`: Number (integer or floating point value)
			
 
				+  * `%f`: Floating point value
			
 
				+  * `%i`: Integer value
			
 
				+  * `%j`: JSON.stringify'ed value
			
 
				+  * `%s`: String value
			
 
				+  * `%%`: Percent sign<br />
			
 
				+
			
 
				+* **Codegen([scope: `Object.<string,*>`]): `Function`**<br />
			
 
				+  Finishes the function and returns it.
			
 
				+
			
 
				+* **Codegen.toString([functionNameOverride: `string`]): `string`**<br />
			
 
				+  Returns the function as a string.
			
 
				+
			
 
				+Example
			
 
				+-------
			
 
				+
			
 
				+```js
			
 
				+var codegen = require("@protobufjs/codegen");
			
 
				+
			
 
				+var add = codegen(["a", "b"], "add") // A function with parameters "a" and "b" named "add"
			
 
				+  ("// awesome comment")             // adds the line to the function's body
			
 
				+  ("return a + b - c + %d", 1)       // replaces %d with 1 and adds the line to the body
			
 
				+  ({ c: 1 });                        // adds "c" with a value of 1 to the function's scope
			
 
				+
			
 
				+console.log(add.toString()); // function add(a, b) { return a + b - c + 1 }
			
 
				+console.log(add(1, 2));      // calculates 1 + 2 - 1 + 1 = 3
			
 
				+```
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/codegen/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/codegen/index.d.ts
@@ -0,0 +1,31 @@
 
				+export = codegen;
			
 
				+
			
 
				+/**
			
 
				+ * Appends code to the function's body.
			
 
				+ * @param [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
			
 
				+ * @param [formatParams] Format parameters
			
 
				+ * @returns Itself or the generated function if finished
			
 
				+ * @throws {Error} If format parameter counts do not match
			
 
				+ */
			
 
				+type Codegen = (formatStringOrScope?: (string|{ [k: string]: any }), ...formatParams: any[]) => (Codegen|Function);
			
 
				+
			
 
				+/**
			
 
				+ * Begins generating a function.
			
 
				+ * @param functionParams Function parameter names
			
 
				+ * @param [functionName] Function name if not anonymous
			
 
				+ * @returns Appender that appends code to the function's body
			
 
				+ */
			
 
				+declare function codegen(functionParams: string[], functionName?: string): Codegen;
			
 
				+
			
 
				+/**
			
 
				+ * Begins generating a function.
			
 
				+ * @param [functionName] Function name if not anonymous
			
 
				+ * @returns Appender that appends code to the function's body
			
 
				+ */
			
 
				+declare function codegen(functionName?: string): Codegen;
			
 
				+
			
 
				+declare namespace codegen {
			
 
				+
			
 
				+    /** When set to `true`, codegen will log generated code to console. Useful for debugging. */
			
 
				+    let verbose: boolean;
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/codegen/index.js
+++ b/Asistent/node_modules/@protobufjs/codegen/index.js
@@ -0,0 +1,99 @@
 
				+"use strict";
			
 
				+module.exports = codegen;
			
 
				+
			
 
				+/**
			
 
				+ * Begins generating a function.
			
 
				+ * @memberof util
			
 
				+ * @param {string[]} functionParams Function parameter names
			
 
				+ * @param {string} [functionName] Function name if not anonymous
			
 
				+ * @returns {Codegen} Appender that appends code to the function's body
			
 
				+ */
			
 
				+function codegen(functionParams, functionName) {
			
 
				+
			
 
				+    /* istanbul ignore if */
			
 
				+    if (typeof functionParams === "string") {
			
 
				+        functionName = functionParams;
			
 
				+        functionParams = undefined;
			
 
				+    }
			
 
				+
			
 
				+    var body = [];
			
 
				+
			
 
				+    /**
			
 
				+     * Appends code to the function's body or finishes generation.
			
 
				+     * @typedef Codegen
			
 
				+     * @type {function}
			
 
				+     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
			
 
				+     * @param {...*} [formatParams] Format parameters
			
 
				+     * @returns {Codegen|Function} Itself or the generated function if finished
			
 
				+     * @throws {Error} If format parameter counts do not match
			
 
				+     */
			
 
				+
			
 
				+    function Codegen(formatStringOrScope) {
			
 
				+        // note that explicit array handling below makes this ~50% faster
			
 
				+
			
 
				+        // finish the function
			
 
				+        if (typeof formatStringOrScope !== "string") {
			
 
				+            var source = toString();
			
 
				+            if (codegen.verbose)
			
 
				+                console.log("codegen: " + source); // eslint-disable-line no-console
			
 
				+            source = "return " + source;
			
 
				+            if (formatStringOrScope) {
			
 
				+                var scopeKeys   = Object.keys(formatStringOrScope),
			
 
				+                    scopeParams = new Array(scopeKeys.length + 1),
			
 
				+                    scopeValues = new Array(scopeKeys.length),
			
 
				+                    scopeOffset = 0;
			
 
				+                while (scopeOffset < scopeKeys.length) {
			
 
				+                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
			
 
				+                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
			
 
				+                }
			
 
				+                scopeParams[scopeOffset] = source;
			
 
				+                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
			
 
				+            }
			
 
				+            return Function(source)(); // eslint-disable-line no-new-func
			
 
				+        }
			
 
				+
			
 
				+        // otherwise append to body
			
 
				+        var formatParams = new Array(arguments.length - 1),
			
 
				+            formatOffset = 0;
			
 
				+        while (formatOffset < formatParams.length)
			
 
				+            formatParams[formatOffset] = arguments[++formatOffset];
			
 
				+        formatOffset = 0;
			
 
				+        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
			
 
				+            var value = formatParams[formatOffset++];
			
 
				+            switch ($1) {
			
 
				+                case "d": case "f": return String(Number(value));
			
 
				+                case "i": return String(Math.floor(value));
			
 
				+                case "j": return JSON.stringify(value);
			
 
				+                case "s": return String(value);
			
 
				+            }
			
 
				+            return "%";
			
 
				+        });
			
 
				+        if (formatOffset !== formatParams.length)
			
 
				+            throw Error("parameter count mismatch");
			
 
				+        body.push(formatStringOrScope);
			
 
				+        return Codegen;
			
 
				+    }
			
 
				+
			
 
				+    function toString(functionNameOverride) {
			
 
				+        return "function " + (functionNameOverride || functionName || "") + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
			
 
				+    }
			
 
				+
			
 
				+    Codegen.toString = toString;
			
 
				+    return Codegen;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Begins generating a function.
			
 
				+ * @memberof util
			
 
				+ * @function codegen
			
 
				+ * @param {string} [functionName] Function name if not anonymous
			
 
				+ * @returns {Codegen} Appender that appends code to the function's body
			
 
				+ * @variation 2
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * When set to `true`, codegen will log generated code to console. Useful for debugging.
			
 
				+ * @name util.codegen.verbose
			
 
				+ * @type {boolean}
			
 
				+ */
			
 
				+codegen.verbose = false;
			
--- a/Asistent/node_modules/@protobufjs/codegen/package.json
+++ b/Asistent/node_modules/@protobufjs/codegen/package.json
@@ -0,0 +1,13 @@
 
				+{
			
 
				+  "name": "@protobufjs/codegen",
			
 
				+  "description": "A minimalistic code generation utility.",
			
 
				+  "version": "2.0.4",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts"
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/codegen/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/codegen/tests/index.js
@@ -0,0 +1,13 @@
 
				+var codegen = require("..");
			
 
				+
			
 
				+// new require("benchmark").Suite().add("add", function() {
			
 
				+
			
 
				+var add = codegen(["a", "b"], "add")
			
 
				+  ("// awesome comment")
			
 
				+  ("return a + b - c + %d", 1)
			
 
				+  ({ c: 1 });
			
 
				+
			
 
				+if (add(1, 2) !== 3)
			
 
				+  throw Error("failed");
			
 
				+
			
 
				+// }).on("cycle", function(event) { process.stdout.write(String(event.target) + "\n"); }).run();
			
--- a/Asistent/node_modules/@protobufjs/eventemitter/LICENSE
+++ b/Asistent/node_modules/@protobufjs/eventemitter/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/eventemitter/README.md
+++ b/Asistent/node_modules/@protobufjs/eventemitter/README.md
@@ -0,0 +1,22 @@
 
				+@protobufjs/eventemitter
			
 
				+========================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/eventemitter.svg)](https://www.npmjs.com/package/@protobufjs/eventemitter)
			
 
				+
			
 
				+A minimal event emitter.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **new EventEmitter()**<br />
			
 
				+  Constructs a new event emitter instance.
			
 
				+
			
 
				+* **EventEmitter#on(evt: `string`, fn: `function`, [ctx: `Object`]): `EventEmitter`**<br />
			
 
				+  Registers an event listener.
			
 
				+
			
 
				+* **EventEmitter#off([evt: `string`], [fn: `function`]): `EventEmitter`**<br />
			
 
				+  Removes an event listener or any matching listeners if arguments are omitted.
			
 
				+
			
 
				+* **EventEmitter#emit(evt: `string`, ...args: `*`): `EventEmitter`**<br />
			
 
				+  Emits an event by calling its listeners with the specified arguments.
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/eventemitter/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/eventemitter/index.d.ts
@@ -0,0 +1,43 @@
 
				+export = EventEmitter;
			
 
				+
			
 
				+/**
			
 
				+ * Constructs a new event emitter instance.
			
 
				+ * @classdesc A minimal event emitter.
			
 
				+ * @memberof util
			
 
				+ * @constructor
			
 
				+ */
			
 
				+declare class EventEmitter {
			
 
				+
			
 
				+    /**
			
 
				+     * Constructs a new event emitter instance.
			
 
				+     * @classdesc A minimal event emitter.
			
 
				+     * @memberof util
			
 
				+     * @constructor
			
 
				+     */
			
 
				+    constructor();
			
 
				+
			
 
				+    /**
			
 
				+     * Registers an event listener.
			
 
				+     * @param {string} evt Event name
			
 
				+     * @param {function} fn Listener
			
 
				+     * @param {*} [ctx] Listener context
			
 
				+     * @returns {util.EventEmitter} `this`
			
 
				+     */
			
 
				+    on(evt: string, fn: () => any, ctx?: any): EventEmitter;
			
 
				+
			
 
				+    /**
			
 
				+     * Removes an event listener or any matching listeners if arguments are omitted.
			
 
				+     * @param {string} [evt] Event name. Removes all listeners if omitted.
			
 
				+     * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
			
 
				+     * @returns {util.EventEmitter} `this`
			
 
				+     */
			
 
				+    off(evt?: string, fn?: () => any): EventEmitter;
			
 
				+
			
 
				+    /**
			
 
				+     * Emits an event by calling its listeners with the specified arguments.
			
 
				+     * @param {string} evt Event name
			
 
				+     * @param {...*} args Arguments
			
 
				+     * @returns {util.EventEmitter} `this`
			
 
				+     */
			
 
				+    emit(evt: string, ...args: any[]): EventEmitter;
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/eventemitter/index.js
+++ b/Asistent/node_modules/@protobufjs/eventemitter/index.js
@@ -0,0 +1,76 @@
 
				+"use strict";
			
 
				+module.exports = EventEmitter;
			
 
				+
			
 
				+/**
			
 
				+ * Constructs a new event emitter instance.
			
 
				+ * @classdesc A minimal event emitter.
			
 
				+ * @memberof util
			
 
				+ * @constructor
			
 
				+ */
			
 
				+function EventEmitter() {
			
 
				+
			
 
				+    /**
			
 
				+     * Registered listeners.
			
 
				+     * @type {Object.<string,*>}
			
 
				+     * @private
			
 
				+     */
			
 
				+    this._listeners = {};
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Registers an event listener.
			
 
				+ * @param {string} evt Event name
			
 
				+ * @param {function} fn Listener
			
 
				+ * @param {*} [ctx] Listener context
			
 
				+ * @returns {util.EventEmitter} `this`
			
 
				+ */
			
 
				+EventEmitter.prototype.on = function on(evt, fn, ctx) {
			
 
				+    (this._listeners[evt] || (this._listeners[evt] = [])).push({
			
 
				+        fn  : fn,
			
 
				+        ctx : ctx || this
			
 
				+    });
			
 
				+    return this;
			
 
				+};
			
 
				+
			
 
				+/**
			
 
				+ * Removes an event listener or any matching listeners if arguments are omitted.
			
 
				+ * @param {string} [evt] Event name. Removes all listeners if omitted.
			
 
				+ * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
			
 
				+ * @returns {util.EventEmitter} `this`
			
 
				+ */
			
 
				+EventEmitter.prototype.off = function off(evt, fn) {
			
 
				+    if (evt === undefined)
			
 
				+        this._listeners = {};
			
 
				+    else {
			
 
				+        if (fn === undefined)
			
 
				+            this._listeners[evt] = [];
			
 
				+        else {
			
 
				+            var listeners = this._listeners[evt];
			
 
				+            for (var i = 0; i < listeners.length;)
			
 
				+                if (listeners[i].fn === fn)
			
 
				+                    listeners.splice(i, 1);
			
 
				+                else
			
 
				+                    ++i;
			
 
				+        }
			
 
				+    }
			
 
				+    return this;
			
 
				+};
			
 
				+
			
 
				+/**
			
 
				+ * Emits an event by calling its listeners with the specified arguments.
			
 
				+ * @param {string} evt Event name
			
 
				+ * @param {...*} args Arguments
			
 
				+ * @returns {util.EventEmitter} `this`
			
 
				+ */
			
 
				+EventEmitter.prototype.emit = function emit(evt) {
			
 
				+    var listeners = this._listeners[evt];
			
 
				+    if (listeners) {
			
 
				+        var args = [],
			
 
				+            i = 1;
			
 
				+        for (; i < arguments.length;)
			
 
				+            args.push(arguments[i++]);
			
 
				+        for (i = 0; i < listeners.length;)
			
 
				+            listeners[i].fn.apply(listeners[i++].ctx, args);
			
 
				+    }
			
 
				+    return this;
			
 
				+};
			
--- a/Asistent/node_modules/@protobufjs/eventemitter/package.json
+++ b/Asistent/node_modules/@protobufjs/eventemitter/package.json
@@ -0,0 +1,21 @@
 
				+{
			
 
				+  "name": "@protobufjs/eventemitter",
			
 
				+  "description": "A minimal event emitter.",
			
 
				+  "version": "1.1.0",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts",
			
 
				+  "devDependencies": {
			
 
				+    "istanbul": "^0.4.5",
			
 
				+    "tape": "^4.6.3"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "test": "tape tests/*.js",
			
 
				+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/eventemitter/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/eventemitter/tests/index.js
@@ -0,0 +1,47 @@
 
				+var tape = require("tape");
			
 
				+
			
 
				+var EventEmitter = require("..");
			
 
				+
			
 
				+tape.test("eventemitter", function(test) {
			
 
				+
			
 
				+    var ee = new EventEmitter();
			
 
				+    var fn;
			
 
				+    var ctx = {};
			
 
				+
			
 
				+    test.doesNotThrow(function() {
			
 
				+        ee.emit("a", 1);
			
 
				+        ee.off();
			
 
				+        ee.off("a");
			
 
				+        ee.off("a", function() {});
			
 
				+    }, "should not throw if no listeners are registered");
			
 
				+    
			
 
				+    test.equal(ee.on("a", function(arg1) {
			
 
				+        test.equal(this, ctx, "should be called with this = ctx");
			
 
				+        test.equal(arg1, 1, "should be called with arg1 = 1");
			
 
				+    }, ctx), ee, "should return itself when registering events");
			
 
				+    ee.emit("a", 1);
			
 
				+
			
 
				+    ee.off("a");
			
 
				+    test.same(ee._listeners, { a: [] }, "should remove all listeners of the respective event when calling off(evt)");
			
 
				+
			
 
				+    ee.off();
			
 
				+    test.same(ee._listeners, {}, "should remove all listeners when just calling off()");
			
 
				+
			
 
				+    ee.on("a", fn = function(arg1) {
			
 
				+        test.equal(this, ctx, "should be called with this = ctx");
			
 
				+        test.equal(arg1, 1, "should be called with arg1 = 1");
			
 
				+    }, ctx).emit("a", 1);
			
 
				+
			
 
				+    ee.off("a", fn);
			
 
				+    test.same(ee._listeners, { a: [] }, "should remove the exact listener when calling off(evt, fn)");
			
 
				+
			
 
				+    ee.on("a", function() {
			
 
				+        test.equal(this, ee, "should be called with this = ee");
			
 
				+    }).emit("a");
			
 
				+
			
 
				+    test.doesNotThrow(function() {
			
 
				+        ee.off("a", fn);
			
 
				+    }, "should not throw if no such listener is found");
			
 
				+
			
 
				+    test.end();
			
 
				+});
			
--- a/Asistent/node_modules/@protobufjs/fetch/LICENSE
+++ b/Asistent/node_modules/@protobufjs/fetch/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/fetch/README.md
+++ b/Asistent/node_modules/@protobufjs/fetch/README.md
@@ -0,0 +1,13 @@
 
				+@protobufjs/fetch
			
 
				+=================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/fetch.svg)](https://www.npmjs.com/package/@protobufjs/fetch)
			
 
				+
			
 
				+Fetches the contents of a file accross node and browsers.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **fetch(path: `string`, [options: { binary: boolean } ], [callback: `function(error: ?Error, [contents: string])`]): `Promise<string|Uint8Array>|undefined`**
			
 
				+  Fetches the contents of a file.
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/fetch/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/fetch/index.d.ts
@@ -0,0 +1,56 @@
 
				+export = fetch;
			
 
				+
			
 
				+/**
			
 
				+ * Node-style callback as used by {@link util.fetch}.
			
 
				+ * @typedef FetchCallback
			
 
				+ * @type {function}
			
 
				+ * @param {?Error} error Error, if any, otherwise `null`
			
 
				+ * @param {string} [contents] File contents, if there hasn't been an error
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+type FetchCallback = (error: Error, contents?: string) => void;
			
 
				+
			
 
				+/**
			
 
				+ * Options as used by {@link util.fetch}.
			
 
				+ * @typedef FetchOptions
			
 
				+ * @type {Object}
			
 
				+ * @property {boolean} [binary=false] Whether expecting a binary response
			
 
				+ * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
			
 
				+ */
			
 
				+
			
 
				+interface FetchOptions {
			
 
				+    binary?: boolean;
			
 
				+    xhr?: boolean
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Fetches the contents of a file.
			
 
				+ * @memberof util
			
 
				+ * @param {string} filename File path or url
			
 
				+ * @param {FetchOptions} options Fetch options
			
 
				+ * @param {FetchCallback} callback Callback function
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+declare function fetch(filename: string, options: FetchOptions, callback: FetchCallback): void;
			
 
				+
			
 
				+/**
			
 
				+ * Fetches the contents of a file.
			
 
				+ * @name util.fetch
			
 
				+ * @function
			
 
				+ * @param {string} path File path or url
			
 
				+ * @param {FetchCallback} callback Callback function
			
 
				+ * @returns {undefined}
			
 
				+ * @variation 2
			
 
				+ */
			
 
				+declare function fetch(path: string, callback: FetchCallback): void;
			
 
				+
			
 
				+/**
			
 
				+ * Fetches the contents of a file.
			
 
				+ * @name util.fetch
			
 
				+ * @function
			
 
				+ * @param {string} path File path or url
			
 
				+ * @param {FetchOptions} [options] Fetch options
			
 
				+ * @returns {Promise<string|Uint8Array>} Promise
			
 
				+ * @variation 3
			
 
				+ */
			
 
				+declare function fetch(path: string, options?: FetchOptions): Promise<(string|Uint8Array)>;
			
--- a/Asistent/node_modules/@protobufjs/fetch/index.js
+++ b/Asistent/node_modules/@protobufjs/fetch/index.js
@@ -0,0 +1,115 @@
 
				+"use strict";
			
 
				+module.exports = fetch;
			
 
				+
			
 
				+var asPromise = require("@protobufjs/aspromise"),
			
 
				+    inquire   = require("@protobufjs/inquire");
			
 
				+
			
 
				+var fs = inquire("fs");
			
 
				+
			
 
				+/**
			
 
				+ * Node-style callback as used by {@link util.fetch}.
			
 
				+ * @typedef FetchCallback
			
 
				+ * @type {function}
			
 
				+ * @param {?Error} error Error, if any, otherwise `null`
			
 
				+ * @param {string} [contents] File contents, if there hasn't been an error
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Options as used by {@link util.fetch}.
			
 
				+ * @typedef FetchOptions
			
 
				+ * @type {Object}
			
 
				+ * @property {boolean} [binary=false] Whether expecting a binary response
			
 
				+ * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Fetches the contents of a file.
			
 
				+ * @memberof util
			
 
				+ * @param {string} filename File path or url
			
 
				+ * @param {FetchOptions} options Fetch options
			
 
				+ * @param {FetchCallback} callback Callback function
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+function fetch(filename, options, callback) {
			
 
				+    if (typeof options === "function") {
			
 
				+        callback = options;
			
 
				+        options = {};
			
 
				+    } else if (!options)
			
 
				+        options = {};
			
 
				+
			
 
				+    if (!callback)
			
 
				+        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
			
 
				+
			
 
				+    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
			
 
				+    if (!options.xhr && fs && fs.readFile)
			
 
				+        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
			
 
				+            return err && typeof XMLHttpRequest !== "undefined"
			
 
				+                ? fetch.xhr(filename, options, callback)
			
 
				+                : err
			
 
				+                ? callback(err)
			
 
				+                : callback(null, options.binary ? contents : contents.toString("utf8"));
			
 
				+        });
			
 
				+
			
 
				+    // use the XHR version otherwise.
			
 
				+    return fetch.xhr(filename, options, callback);
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Fetches the contents of a file.
			
 
				+ * @name util.fetch
			
 
				+ * @function
			
 
				+ * @param {string} path File path or url
			
 
				+ * @param {FetchCallback} callback Callback function
			
 
				+ * @returns {undefined}
			
 
				+ * @variation 2
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Fetches the contents of a file.
			
 
				+ * @name util.fetch
			
 
				+ * @function
			
 
				+ * @param {string} path File path or url
			
 
				+ * @param {FetchOptions} [options] Fetch options
			
 
				+ * @returns {Promise<string|Uint8Array>} Promise
			
 
				+ * @variation 3
			
 
				+ */
			
 
				+
			
 
				+/**/
			
 
				+fetch.xhr = function fetch_xhr(filename, options, callback) {
			
 
				+    var xhr = new XMLHttpRequest();
			
 
				+    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
			
 
				+
			
 
				+        if (xhr.readyState !== 4)
			
 
				+            return undefined;
			
 
				+
			
 
				+        // local cors security errors return status 0 / empty string, too. afaik this cannot be
			
 
				+        // reliably distinguished from an actually empty file for security reasons. feel free
			
 
				+        // to send a pull request if you are aware of a solution.
			
 
				+        if (xhr.status !== 0 && xhr.status !== 200)
			
 
				+            return callback(Error("status " + xhr.status));
			
 
				+
			
 
				+        // if binary data is expected, make sure that some sort of array is returned, even if
			
 
				+        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
			
 
				+        if (options.binary) {
			
 
				+            var buffer = xhr.response;
			
 
				+            if (!buffer) {
			
 
				+                buffer = [];
			
 
				+                for (var i = 0; i < xhr.responseText.length; ++i)
			
 
				+                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
			
 
				+            }
			
 
				+            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
			
 
				+        }
			
 
				+        return callback(null, xhr.responseText);
			
 
				+    };
			
 
				+
			
 
				+    if (options.binary) {
			
 
				+        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
			
 
				+        if ("overrideMimeType" in xhr)
			
 
				+            xhr.overrideMimeType("text/plain; charset=x-user-defined");
			
 
				+        xhr.responseType = "arraybuffer";
			
 
				+    }
			
 
				+
			
 
				+    xhr.open("GET", filename);
			
 
				+    xhr.send();
			
 
				+};
			
--- a/Asistent/node_modules/@protobufjs/fetch/package.json
+++ b/Asistent/node_modules/@protobufjs/fetch/package.json
@@ -0,0 +1,25 @@
 
				+{
			
 
				+  "name": "@protobufjs/fetch",
			
 
				+  "description": "Fetches the contents of a file accross node and browsers.",
			
 
				+  "version": "1.1.0",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "dependencies": {
			
 
				+    "@protobufjs/aspromise": "^1.1.1",
			
 
				+    "@protobufjs/inquire": "^1.1.0"
			
 
				+  },
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts",
			
 
				+  "devDependencies": {
			
 
				+    "istanbul": "^0.4.5",
			
 
				+    "tape": "^4.6.3"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "test": "tape tests/*.js",
			
 
				+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/fetch/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/fetch/tests/index.js
@@ -0,0 +1,16 @@
 
				+var tape = require("tape");
			
 
				+
			
 
				+var fetch = require("..");
			
 
				+
			
 
				+tape.test("fetch", function(test) {
			
 
				+
			
 
				+    if (typeof Promise !== "undefined") {
			
 
				+        var promise = fetch("NOTFOUND");
			
 
				+        promise.catch(function() {});
			
 
				+        test.ok(promise instanceof Promise, "should return a promise if callback has been omitted");
			
 
				+    }
			
 
				+
			
 
				+    // TODO - some way to test this properly?
			
 
				+    
			
 
				+    test.end();
			
 
				+});
			
--- a/Asistent/node_modules/@protobufjs/float/LICENSE
+++ b/Asistent/node_modules/@protobufjs/float/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/float/README.md
+++ b/Asistent/node_modules/@protobufjs/float/README.md
@@ -0,0 +1,102 @@
 
				+@protobufjs/float
			
 
				+=================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/float.svg)](https://www.npmjs.com/package/@protobufjs/float)
			
 
				+
			
 
				+Reads / writes floats / doubles from / to buffers in both modern and ancient browsers. Fast.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **writeFloatLE(val: `number`, buf: `Uint8Array`, pos: `number`)**<br />
			
 
				+  Writes a 32 bit float to a buffer using little endian byte order.
			
 
				+
			
 
				+* **writeFloatBE(val: `number`, buf: `Uint8Array`, pos: `number`)**<br />
			
 
				+  Writes a 32 bit float to a buffer using big endian byte order.
			
 
				+
			
 
				+* **readFloatLE(buf: `Uint8Array`, pos: `number`): `number`**<br />
			
 
				+  Reads a 32 bit float from a buffer using little endian byte order.
			
 
				+
			
 
				+* **readFloatBE(buf: `Uint8Array`, pos: `number`): `number`**<br />
			
 
				+  Reads a 32 bit float from a buffer using big endian byte order.
			
 
				+
			
 
				+* **writeDoubleLE(val: `number`, buf: `Uint8Array`, pos: `number`)**<br />
			
 
				+  Writes a 64 bit double to a buffer using little endian byte order.
			
 
				+
			
 
				+* **writeDoubleBE(val: `number`, buf: `Uint8Array`, pos: `number`)**<br />
			
 
				+  Writes a 64 bit double to a buffer using big endian byte order.
			
 
				+
			
 
				+* **readDoubleLE(buf: `Uint8Array`, pos: `number`): `number`**<br />
			
 
				+  Reads a 64 bit double from a buffer using little endian byte order.
			
 
				+
			
 
				+* **readDoubleBE(buf: `Uint8Array`, pos: `number`): `number`**<br />
			
 
				+  Reads a 64 bit double from a buffer using big endian byte order.
			
 
				+
			
 
				+Performance
			
 
				+-----------
			
 
				+There is a simple benchmark included comparing raw read/write performance of this library (float), float's fallback for old browsers, the [ieee754](https://www.npmjs.com/package/ieee754) module and node's [buffer](https://nodejs.org/api/buffer.html). On an i7-2600k running node 6.9.1 it yields:
			
 
				+
			
 
				+```
			
 
				+benchmarking writeFloat performance ...
			
 
				+
			
 
				+float x 42,741,625 ops/sec ±1.75% (81 runs sampled)
			
 
				+float (fallback) x 11,272,532 ops/sec ±1.12% (85 runs sampled)
			
 
				+ieee754 x 8,653,337 ops/sec ±1.18% (84 runs sampled)
			
 
				+buffer x 12,412,414 ops/sec ±1.41% (83 runs sampled)
			
 
				+buffer (noAssert) x 13,471,149 ops/sec ±1.09% (84 runs sampled)
			
 
				+
			
 
				+                      float was fastest
			
 
				+           float (fallback) was 73.5% slower
			
 
				+                    ieee754 was 79.6% slower
			
 
				+                     buffer was 70.9% slower
			
 
				+          buffer (noAssert) was 68.3% slower
			
 
				+
			
 
				+benchmarking readFloat performance ...
			
 
				+
			
 
				+float x 44,382,729 ops/sec ±1.70% (84 runs sampled)
			
 
				+float (fallback) x 20,925,938 ops/sec ±0.86% (87 runs sampled)
			
 
				+ieee754 x 17,189,009 ops/sec ±1.01% (87 runs sampled)
			
 
				+buffer x 10,518,437 ops/sec ±1.04% (83 runs sampled)
			
 
				+buffer (noAssert) x 11,031,636 ops/sec ±1.15% (87 runs sampled)
			
 
				+
			
 
				+                      float was fastest
			
 
				+           float (fallback) was 52.5% slower
			
 
				+                    ieee754 was 61.0% slower
			
 
				+                     buffer was 76.1% slower
			
 
				+          buffer (noAssert) was 75.0% slower
			
 
				+
			
 
				+benchmarking writeDouble performance ...
			
 
				+
			
 
				+float x 38,624,906 ops/sec ±0.93% (83 runs sampled)
			
 
				+float (fallback) x 10,457,811 ops/sec ±1.54% (85 runs sampled)
			
 
				+ieee754 x 7,681,130 ops/sec ±1.11% (83 runs sampled)
			
 
				+buffer x 12,657,876 ops/sec ±1.03% (83 runs sampled)
			
 
				+buffer (noAssert) x 13,372,795 ops/sec ±0.84% (85 runs sampled)
			
 
				+
			
 
				+                      float was fastest
			
 
				+           float (fallback) was 73.1% slower
			
 
				+                    ieee754 was 80.1% slower
			
 
				+                     buffer was 67.3% slower
			
 
				+          buffer (noAssert) was 65.3% slower
			
 
				+
			
 
				+benchmarking readDouble performance ...
			
 
				+
			
 
				+float x 40,527,888 ops/sec ±1.05% (84 runs sampled)
			
 
				+float (fallback) x 18,696,480 ops/sec ±0.84% (86 runs sampled)
			
 
				+ieee754 x 14,074,028 ops/sec ±1.04% (87 runs sampled)
			
 
				+buffer x 10,092,367 ops/sec ±1.15% (84 runs sampled)
			
 
				+buffer (noAssert) x 10,623,793 ops/sec ±0.96% (84 runs sampled)
			
 
				+
			
 
				+                      float was fastest
			
 
				+           float (fallback) was 53.8% slower
			
 
				+                    ieee754 was 65.3% slower
			
 
				+                     buffer was 75.1% slower
			
 
				+          buffer (noAssert) was 73.8% slower
			
 
				+```
			
 
				+
			
 
				+To run it yourself:
			
 
				+
			
 
				+```
			
 
				+$> npm run bench
			
 
				+```
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/float/bench/index.js
+++ b/Asistent/node_modules/@protobufjs/float/bench/index.js
@@ -0,0 +1,87 @@
 
				+"use strict";
			
 
				+
			
 
				+var float = require(".."),
			
 
				+    ieee754 = require("ieee754"),
			
 
				+    newSuite = require("./suite");
			
 
				+
			
 
				+var F32 = Float32Array;
			
 
				+var F64 = Float64Array;
			
 
				+delete global.Float32Array;
			
 
				+delete global.Float64Array;
			
 
				+var floatFallback = float({});
			
 
				+global.Float32Array = F32;
			
 
				+global.Float64Array = F64;
			
 
				+
			
 
				+var buf = new Buffer(8);
			
 
				+
			
 
				+newSuite("writeFloat")
			
 
				+.add("float", function() {
			
 
				+    float.writeFloatLE(0.1, buf, 0);
			
 
				+})
			
 
				+.add("float (fallback)", function() {
			
 
				+    floatFallback.writeFloatLE(0.1, buf, 0);
			
 
				+})
			
 
				+.add("ieee754", function() {
			
 
				+    ieee754.write(buf, 0.1, 0, true, 23, 4);
			
 
				+})
			
 
				+.add("buffer", function() {
			
 
				+    buf.writeFloatLE(0.1, 0);
			
 
				+})
			
 
				+.add("buffer (noAssert)", function() {
			
 
				+    buf.writeFloatLE(0.1, 0, true);
			
 
				+})
			
 
				+.run();
			
 
				+
			
 
				+newSuite("readFloat")
			
 
				+.add("float", function() {
			
 
				+    float.readFloatLE(buf, 0);
			
 
				+})
			
 
				+.add("float (fallback)", function() {
			
 
				+    floatFallback.readFloatLE(buf, 0);
			
 
				+})
			
 
				+.add("ieee754", function() {
			
 
				+    ieee754.read(buf, 0, true, 23, 4);
			
 
				+})
			
 
				+.add("buffer", function() {
			
 
				+    buf.readFloatLE(0);
			
 
				+})
			
 
				+.add("buffer (noAssert)", function() {
			
 
				+    buf.readFloatLE(0, true);
			
 
				+})
			
 
				+.run();
			
 
				+
			
 
				+newSuite("writeDouble")
			
 
				+.add("float", function() {
			
 
				+    float.writeDoubleLE(0.1, buf, 0);
			
 
				+})
			
 
				+.add("float (fallback)", function() {
			
 
				+    floatFallback.writeDoubleLE(0.1, buf, 0);
			
 
				+})
			
 
				+.add("ieee754", function() {
			
 
				+    ieee754.write(buf, 0.1, 0, true, 52, 8);
			
 
				+})
			
 
				+.add("buffer", function() {
			
 
				+    buf.writeDoubleLE(0.1, 0);
			
 
				+})
			
 
				+.add("buffer (noAssert)", function() {
			
 
				+    buf.writeDoubleLE(0.1, 0, true);
			
 
				+})
			
 
				+.run();
			
 
				+
			
 
				+newSuite("readDouble")
			
 
				+.add("float", function() {
			
 
				+    float.readDoubleLE(buf, 0);
			
 
				+})
			
 
				+.add("float (fallback)", function() {
			
 
				+    floatFallback.readDoubleLE(buf, 0);
			
 
				+})
			
 
				+.add("ieee754", function() {
			
 
				+    ieee754.read(buf, 0, true, 52, 8);
			
 
				+})
			
 
				+.add("buffer", function() {
			
 
				+    buf.readDoubleLE(0);
			
 
				+})
			
 
				+.add("buffer (noAssert)", function() {
			
 
				+    buf.readDoubleLE(0, true);
			
 
				+})
			
 
				+.run();
			
--- a/Asistent/node_modules/@protobufjs/float/bench/suite.js
+++ b/Asistent/node_modules/@protobufjs/float/bench/suite.js
@@ -0,0 +1,46 @@
 
				+"use strict";
			
 
				+module.exports = newSuite;
			
 
				+
			
 
				+var benchmark = require("benchmark"),
			
 
				+    chalk     = require("chalk");
			
 
				+
			
 
				+var padSize = 27;
			
 
				+
			
 
				+function newSuite(name) {
			
 
				+    var benches = [];
			
 
				+    return new benchmark.Suite(name)
			
 
				+    .on("add", function(event) {
			
 
				+        benches.push(event.target);
			
 
				+    })
			
 
				+    .on("start", function() {
			
 
				+        process.stdout.write("benchmarking " + name + " performance ...\n\n");
			
 
				+    })
			
 
				+    .on("cycle", function(event) {
			
 
				+        process.stdout.write(String(event.target) + "\n");
			
 
				+    })
			
 
				+    .on("complete", function() {
			
 
				+        if (benches.length > 1) {
			
 
				+            var fastest = this.filter("fastest"), // eslint-disable-line no-invalid-this
			
 
				+                fastestHz = getHz(fastest[0]);
			
 
				+            process.stdout.write("\n" + chalk.white(pad(fastest[0].name, padSize)) + " was " + chalk.green("fastest") + "\n");
			
 
				+            benches.forEach(function(bench) {
			
 
				+                if (fastest.indexOf(bench) === 0)
			
 
				+                    return;
			
 
				+                var hz = hz = getHz(bench);
			
 
				+                var percent = (1 - hz / fastestHz) * 100;
			
 
				+                process.stdout.write(chalk.white(pad(bench.name, padSize)) + " was " + chalk.red(percent.toFixed(1) + "% slower") + "\n");
			
 
				+            });
			
 
				+        }
			
 
				+        process.stdout.write("\n");
			
 
				+    });
			
 
				+}
			
 
				+
			
 
				+function getHz(bench) {
			
 
				+    return 1 / (bench.stats.mean + bench.stats.moe);
			
 
				+}
			
 
				+
			
 
				+function pad(str, len, l) {
			
 
				+    while (str.length < len)
			
 
				+        str = l ? str + " " : " " + str;
			
 
				+    return str;
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/float/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/float/index.d.ts
@@ -0,0 +1,83 @@
 
				+/**
			
 
				+ * Writes a 32 bit float to a buffer using little endian byte order.
			
 
				+ * @name writeFloatLE
			
 
				+ * @function
			
 
				+ * @param {number} val Value to write
			
 
				+ * @param {Uint8Array} buf Target buffer
			
 
				+ * @param {number} pos Target buffer offset
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+export function writeFloatLE(val: number, buf: Uint8Array, pos: number): void;
			
 
				+
			
 
				+/**
			
 
				+ * Writes a 32 bit float to a buffer using big endian byte order.
			
 
				+ * @name writeFloatBE
			
 
				+ * @function
			
 
				+ * @param {number} val Value to write
			
 
				+ * @param {Uint8Array} buf Target buffer
			
 
				+ * @param {number} pos Target buffer offset
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+export function writeFloatBE(val: number, buf: Uint8Array, pos: number): void;
			
 
				+
			
 
				+/**
			
 
				+ * Reads a 32 bit float from a buffer using little endian byte order.
			
 
				+ * @name readFloatLE
			
 
				+ * @function
			
 
				+ * @param {Uint8Array} buf Source buffer
			
 
				+ * @param {number} pos Source buffer offset
			
 
				+ * @returns {number} Value read
			
 
				+ */
			
 
				+export function readFloatLE(buf: Uint8Array, pos: number): number;
			
 
				+
			
 
				+/**
			
 
				+ * Reads a 32 bit float from a buffer using big endian byte order.
			
 
				+ * @name readFloatBE
			
 
				+ * @function
			
 
				+ * @param {Uint8Array} buf Source buffer
			
 
				+ * @param {number} pos Source buffer offset
			
 
				+ * @returns {number} Value read
			
 
				+ */
			
 
				+export function readFloatBE(buf: Uint8Array, pos: number): number;
			
 
				+
			
 
				+/**
			
 
				+ * Writes a 64 bit double to a buffer using little endian byte order.
			
 
				+ * @name writeDoubleLE
			
 
				+ * @function
			
 
				+ * @param {number} val Value to write
			
 
				+ * @param {Uint8Array} buf Target buffer
			
 
				+ * @param {number} pos Target buffer offset
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+export function writeDoubleLE(val: number, buf: Uint8Array, pos: number): void;
			
 
				+
			
 
				+/**
			
 
				+ * Writes a 64 bit double to a buffer using big endian byte order.
			
 
				+ * @name writeDoubleBE
			
 
				+ * @function
			
 
				+ * @param {number} val Value to write
			
 
				+ * @param {Uint8Array} buf Target buffer
			
 
				+ * @param {number} pos Target buffer offset
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+export function writeDoubleBE(val: number, buf: Uint8Array, pos: number): void;
			
 
				+
			
 
				+/**
			
 
				+ * Reads a 64 bit double from a buffer using little endian byte order.
			
 
				+ * @name readDoubleLE
			
 
				+ * @function
			
 
				+ * @param {Uint8Array} buf Source buffer
			
 
				+ * @param {number} pos Source buffer offset
			
 
				+ * @returns {number} Value read
			
 
				+ */
			
 
				+export function readDoubleLE(buf: Uint8Array, pos: number): number;
			
 
				+
			
 
				+/**
			
 
				+ * Reads a 64 bit double from a buffer using big endian byte order.
			
 
				+ * @name readDoubleBE
			
 
				+ * @function
			
 
				+ * @param {Uint8Array} buf Source buffer
			
 
				+ * @param {number} pos Source buffer offset
			
 
				+ * @returns {number} Value read
			
 
				+ */
			
 
				+export function readDoubleBE(buf: Uint8Array, pos: number): number;
			
--- a/Asistent/node_modules/@protobufjs/float/index.js
+++ b/Asistent/node_modules/@protobufjs/float/index.js
@@ -0,0 +1,335 @@
 
				+"use strict";
			
 
				+
			
 
				+module.exports = factory(factory);
			
 
				+
			
 
				+/**
			
 
				+ * Reads / writes floats / doubles from / to buffers.
			
 
				+ * @name util.float
			
 
				+ * @namespace
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Writes a 32 bit float to a buffer using little endian byte order.
			
 
				+ * @name util.float.writeFloatLE
			
 
				+ * @function
			
 
				+ * @param {number} val Value to write
			
 
				+ * @param {Uint8Array} buf Target buffer
			
 
				+ * @param {number} pos Target buffer offset
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Writes a 32 bit float to a buffer using big endian byte order.
			
 
				+ * @name util.float.writeFloatBE
			
 
				+ * @function
			
 
				+ * @param {number} val Value to write
			
 
				+ * @param {Uint8Array} buf Target buffer
			
 
				+ * @param {number} pos Target buffer offset
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Reads a 32 bit float from a buffer using little endian byte order.
			
 
				+ * @name util.float.readFloatLE
			
 
				+ * @function
			
 
				+ * @param {Uint8Array} buf Source buffer
			
 
				+ * @param {number} pos Source buffer offset
			
 
				+ * @returns {number} Value read
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Reads a 32 bit float from a buffer using big endian byte order.
			
 
				+ * @name util.float.readFloatBE
			
 
				+ * @function
			
 
				+ * @param {Uint8Array} buf Source buffer
			
 
				+ * @param {number} pos Source buffer offset
			
 
				+ * @returns {number} Value read
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Writes a 64 bit double to a buffer using little endian byte order.
			
 
				+ * @name util.float.writeDoubleLE
			
 
				+ * @function
			
 
				+ * @param {number} val Value to write
			
 
				+ * @param {Uint8Array} buf Target buffer
			
 
				+ * @param {number} pos Target buffer offset
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Writes a 64 bit double to a buffer using big endian byte order.
			
 
				+ * @name util.float.writeDoubleBE
			
 
				+ * @function
			
 
				+ * @param {number} val Value to write
			
 
				+ * @param {Uint8Array} buf Target buffer
			
 
				+ * @param {number} pos Target buffer offset
			
 
				+ * @returns {undefined}
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Reads a 64 bit double from a buffer using little endian byte order.
			
 
				+ * @name util.float.readDoubleLE
			
 
				+ * @function
			
 
				+ * @param {Uint8Array} buf Source buffer
			
 
				+ * @param {number} pos Source buffer offset
			
 
				+ * @returns {number} Value read
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * Reads a 64 bit double from a buffer using big endian byte order.
			
 
				+ * @name util.float.readDoubleBE
			
 
				+ * @function
			
 
				+ * @param {Uint8Array} buf Source buffer
			
 
				+ * @param {number} pos Source buffer offset
			
 
				+ * @returns {number} Value read
			
 
				+ */
			
 
				+
			
 
				+// Factory function for the purpose of node-based testing in modified global environments
			
 
				+function factory(exports) {
			
 
				+
			
 
				+    // float: typed array
			
 
				+    if (typeof Float32Array !== "undefined") (function() {
			
 
				+
			
 
				+        var f32 = new Float32Array([ -0 ]),
			
 
				+            f8b = new Uint8Array(f32.buffer),
			
 
				+            le  = f8b[3] === 128;
			
 
				+
			
 
				+        function writeFloat_f32_cpy(val, buf, pos) {
			
 
				+            f32[0] = val;
			
 
				+            buf[pos    ] = f8b[0];
			
 
				+            buf[pos + 1] = f8b[1];
			
 
				+            buf[pos + 2] = f8b[2];
			
 
				+            buf[pos + 3] = f8b[3];
			
 
				+        }
			
 
				+
			
 
				+        function writeFloat_f32_rev(val, buf, pos) {
			
 
				+            f32[0] = val;
			
 
				+            buf[pos    ] = f8b[3];
			
 
				+            buf[pos + 1] = f8b[2];
			
 
				+            buf[pos + 2] = f8b[1];
			
 
				+            buf[pos + 3] = f8b[0];
			
 
				+        }
			
 
				+
			
 
				+        /* istanbul ignore next */
			
 
				+        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
			
 
				+        /* istanbul ignore next */
			
 
				+        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
			
 
				+
			
 
				+        function readFloat_f32_cpy(buf, pos) {
			
 
				+            f8b[0] = buf[pos    ];
			
 
				+            f8b[1] = buf[pos + 1];
			
 
				+            f8b[2] = buf[pos + 2];
			
 
				+            f8b[3] = buf[pos + 3];
			
 
				+            return f32[0];
			
 
				+        }
			
 
				+
			
 
				+        function readFloat_f32_rev(buf, pos) {
			
 
				+            f8b[3] = buf[pos    ];
			
 
				+            f8b[2] = buf[pos + 1];
			
 
				+            f8b[1] = buf[pos + 2];
			
 
				+            f8b[0] = buf[pos + 3];
			
 
				+            return f32[0];
			
 
				+        }
			
 
				+
			
 
				+        /* istanbul ignore next */
			
 
				+        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
			
 
				+        /* istanbul ignore next */
			
 
				+        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
			
 
				+
			
 
				+    // float: ieee754
			
 
				+    })(); else (function() {
			
 
				+
			
 
				+        function writeFloat_ieee754(writeUint, val, buf, pos) {
			
 
				+            var sign = val < 0 ? 1 : 0;
			
 
				+            if (sign)
			
 
				+                val = -val;
			
 
				+            if (val === 0)
			
 
				+                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
			
 
				+            else if (isNaN(val))
			
 
				+                writeUint(2143289344, buf, pos);
			
 
				+            else if (val > 3.4028234663852886e+38) // +-Infinity
			
 
				+                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
			
 
				+            else if (val < 1.1754943508222875e-38) // denormal
			
 
				+                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
			
 
				+            else {
			
 
				+                var exponent = Math.floor(Math.log(val) / Math.LN2),
			
 
				+                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
			
 
				+                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
			
 
				+        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
			
 
				+
			
 
				+        function readFloat_ieee754(readUint, buf, pos) {
			
 
				+            var uint = readUint(buf, pos),
			
 
				+                sign = (uint >> 31) * 2 + 1,
			
 
				+                exponent = uint >>> 23 & 255,
			
 
				+                mantissa = uint & 8388607;
			
 
				+            return exponent === 255
			
 
				+                ? mantissa
			
 
				+                ? NaN
			
 
				+                : sign * Infinity
			
 
				+                : exponent === 0 // denormal
			
 
				+                ? sign * 1.401298464324817e-45 * mantissa
			
 
				+                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
			
 
				+        }
			
 
				+
			
 
				+        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
			
 
				+        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
			
 
				+
			
 
				+    })();
			
 
				+
			
 
				+    // double: typed array
			
 
				+    if (typeof Float64Array !== "undefined") (function() {
			
 
				+
			
 
				+        var f64 = new Float64Array([-0]),
			
 
				+            f8b = new Uint8Array(f64.buffer),
			
 
				+            le  = f8b[7] === 128;
			
 
				+
			
 
				+        function writeDouble_f64_cpy(val, buf, pos) {
			
 
				+            f64[0] = val;
			
 
				+            buf[pos    ] = f8b[0];
			
 
				+            buf[pos + 1] = f8b[1];
			
 
				+            buf[pos + 2] = f8b[2];
			
 
				+            buf[pos + 3] = f8b[3];
			
 
				+            buf[pos + 4] = f8b[4];
			
 
				+            buf[pos + 5] = f8b[5];
			
 
				+            buf[pos + 6] = f8b[6];
			
 
				+            buf[pos + 7] = f8b[7];
			
 
				+        }
			
 
				+
			
 
				+        function writeDouble_f64_rev(val, buf, pos) {
			
 
				+            f64[0] = val;
			
 
				+            buf[pos    ] = f8b[7];
			
 
				+            buf[pos + 1] = f8b[6];
			
 
				+            buf[pos + 2] = f8b[5];
			
 
				+            buf[pos + 3] = f8b[4];
			
 
				+            buf[pos + 4] = f8b[3];
			
 
				+            buf[pos + 5] = f8b[2];
			
 
				+            buf[pos + 6] = f8b[1];
			
 
				+            buf[pos + 7] = f8b[0];
			
 
				+        }
			
 
				+
			
 
				+        /* istanbul ignore next */
			
 
				+        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
			
 
				+        /* istanbul ignore next */
			
 
				+        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
			
 
				+
			
 
				+        function readDouble_f64_cpy(buf, pos) {
			
 
				+            f8b[0] = buf[pos    ];
			
 
				+            f8b[1] = buf[pos + 1];
			
 
				+            f8b[2] = buf[pos + 2];
			
 
				+            f8b[3] = buf[pos + 3];
			
 
				+            f8b[4] = buf[pos + 4];
			
 
				+            f8b[5] = buf[pos + 5];
			
 
				+            f8b[6] = buf[pos + 6];
			
 
				+            f8b[7] = buf[pos + 7];
			
 
				+            return f64[0];
			
 
				+        }
			
 
				+
			
 
				+        function readDouble_f64_rev(buf, pos) {
			
 
				+            f8b[7] = buf[pos    ];
			
 
				+            f8b[6] = buf[pos + 1];
			
 
				+            f8b[5] = buf[pos + 2];
			
 
				+            f8b[4] = buf[pos + 3];
			
 
				+            f8b[3] = buf[pos + 4];
			
 
				+            f8b[2] = buf[pos + 5];
			
 
				+            f8b[1] = buf[pos + 6];
			
 
				+            f8b[0] = buf[pos + 7];
			
 
				+            return f64[0];
			
 
				+        }
			
 
				+
			
 
				+        /* istanbul ignore next */
			
 
				+        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
			
 
				+        /* istanbul ignore next */
			
 
				+        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
			
 
				+
			
 
				+    // double: ieee754
			
 
				+    })(); else (function() {
			
 
				+
			
 
				+        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
			
 
				+            var sign = val < 0 ? 1 : 0;
			
 
				+            if (sign)
			
 
				+                val = -val;
			
 
				+            if (val === 0) {
			
 
				+                writeUint(0, buf, pos + off0);
			
 
				+                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
			
 
				+            } else if (isNaN(val)) {
			
 
				+                writeUint(0, buf, pos + off0);
			
 
				+                writeUint(2146959360, buf, pos + off1);
			
 
				+            } else if (val > 1.7976931348623157e+308) { // +-Infinity
			
 
				+                writeUint(0, buf, pos + off0);
			
 
				+                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
			
 
				+            } else {
			
 
				+                var mantissa;
			
 
				+                if (val < 2.2250738585072014e-308) { // denormal
			
 
				+                    mantissa = val / 5e-324;
			
 
				+                    writeUint(mantissa >>> 0, buf, pos + off0);
			
 
				+                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
			
 
				+                } else {
			
 
				+                    var exponent = Math.floor(Math.log(val) / Math.LN2);
			
 
				+                    if (exponent === 1024)
			
 
				+                        exponent = 1023;
			
 
				+                    mantissa = val * Math.pow(2, -exponent);
			
 
				+                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
			
 
				+                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
			
 
				+                }
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
			
 
				+        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
			
 
				+
			
 
				+        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
			
 
				+            var lo = readUint(buf, pos + off0),
			
 
				+                hi = readUint(buf, pos + off1);
			
 
				+            var sign = (hi >> 31) * 2 + 1,
			
 
				+                exponent = hi >>> 20 & 2047,
			
 
				+                mantissa = 4294967296 * (hi & 1048575) + lo;
			
 
				+            return exponent === 2047
			
 
				+                ? mantissa
			
 
				+                ? NaN
			
 
				+                : sign * Infinity
			
 
				+                : exponent === 0 // denormal
			
 
				+                ? sign * 5e-324 * mantissa
			
 
				+                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
			
 
				+        }
			
 
				+
			
 
				+        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
			
 
				+        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
			
 
				+
			
 
				+    })();
			
 
				+
			
 
				+    return exports;
			
 
				+}
			
 
				+
			
 
				+// uint helpers
			
 
				+
			
 
				+function writeUintLE(val, buf, pos) {
			
 
				+    buf[pos    ] =  val        & 255;
			
 
				+    buf[pos + 1] =  val >>> 8  & 255;
			
 
				+    buf[pos + 2] =  val >>> 16 & 255;
			
 
				+    buf[pos + 3] =  val >>> 24;
			
 
				+}
			
 
				+
			
 
				+function writeUintBE(val, buf, pos) {
			
 
				+    buf[pos    ] =  val >>> 24;
			
 
				+    buf[pos + 1] =  val >>> 16 & 255;
			
 
				+    buf[pos + 2] =  val >>> 8  & 255;
			
 
				+    buf[pos + 3] =  val        & 255;
			
 
				+}
			
 
				+
			
 
				+function readUintLE(buf, pos) {
			
 
				+    return (buf[pos    ]
			
 
				+          | buf[pos + 1] << 8
			
 
				+          | buf[pos + 2] << 16
			
 
				+          | buf[pos + 3] << 24) >>> 0;
			
 
				+}
			
 
				+
			
 
				+function readUintBE(buf, pos) {
			
 
				+    return (buf[pos    ] << 24
			
 
				+          | buf[pos + 1] << 16
			
 
				+          | buf[pos + 2] << 8
			
 
				+          | buf[pos + 3]) >>> 0;
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/float/package.json
+++ b/Asistent/node_modules/@protobufjs/float/package.json
@@ -0,0 +1,26 @@
 
				+{
			
 
				+  "name": "@protobufjs/float",
			
 
				+  "description": "Reads / writes floats / doubles from / to buffers in both modern and ancient browsers.",
			
 
				+  "version": "1.0.2",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "dependencies": {},
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts",
			
 
				+  "devDependencies": {
			
 
				+    "benchmark": "^2.1.4",
			
 
				+    "chalk": "^1.1.3",
			
 
				+    "ieee754": "^1.1.8",
			
 
				+    "istanbul": "^0.4.5",
			
 
				+    "tape": "^4.6.3"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "test": "tape tests/*.js",
			
 
				+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js",
			
 
				+    "bench": "node bench"
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/float/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/float/tests/index.js
@@ -0,0 +1,100 @@
 
				+var tape = require("tape");
			
 
				+
			
 
				+var float = require("..");
			
 
				+
			
 
				+tape.test("float", function(test) {
			
 
				+
			
 
				+    // default
			
 
				+    test.test(test.name + " - typed array", function(test) {
			
 
				+        runTest(float, test);
			
 
				+    });
			
 
				+
			
 
				+    // ieee754
			
 
				+    test.test(test.name + " - fallback", function(test) {
			
 
				+        var F32 = global.Float32Array,
			
 
				+            F64 = global.Float64Array;
			
 
				+        delete global.Float32Array;
			
 
				+        delete global.Float64Array;
			
 
				+        runTest(float({}), test);
			
 
				+        global.Float32Array = F32;
			
 
				+        global.Float64Array = F64;
			
 
				+    });
			
 
				+});
			
 
				+
			
 
				+function runTest(float, test) {
			
 
				+
			
 
				+    var common = [
			
 
				+        0,
			
 
				+        -0,
			
 
				+        Infinity,
			
 
				+        -Infinity,
			
 
				+        0.125,
			
 
				+        1024.5,
			
 
				+        -4096.5,
			
 
				+        NaN
			
 
				+    ];
			
 
				+
			
 
				+    test.test(test.name + " - using 32 bits", function(test) {
			
 
				+        common.concat([
			
 
				+            3.4028234663852886e+38,
			
 
				+            1.1754943508222875e-38,
			
 
				+            1.1754946310819804e-39
			
 
				+        ])
			
 
				+        .forEach(function(value) {
			
 
				+            var strval = value === 0 && 1 / value < 0 ? "-0" : value.toString();
			
 
				+            test.ok(
			
 
				+                checkValue(value, 4, float.readFloatLE, float.writeFloatLE, Buffer.prototype.writeFloatLE),
			
 
				+                "should write and read back " + strval + " (32 bit LE)"
			
 
				+            );
			
 
				+            test.ok(
			
 
				+                checkValue(value, 4, float.readFloatBE, float.writeFloatBE, Buffer.prototype.writeFloatBE),
			
 
				+                "should write and read back " + strval + " (32 bit BE)"
			
 
				+            );
			
 
				+        });
			
 
				+        test.end();
			
 
				+    });
			
 
				+
			
 
				+    test.test(test.name + " - using 64 bits", function(test) {
			
 
				+        common.concat([
			
 
				+            1.7976931348623157e+308,
			
 
				+            2.2250738585072014e-308,
			
 
				+            2.2250738585072014e-309
			
 
				+        ])
			
 
				+        .forEach(function(value) {
			
 
				+            var strval = value === 0 && 1 / value < 0 ? "-0" : value.toString();
			
 
				+            test.ok(
			
 
				+                checkValue(value, 8, float.readDoubleLE, float.writeDoubleLE, Buffer.prototype.writeDoubleLE),
			
 
				+                "should write and read back " + strval + " (64 bit LE)"
			
 
				+            );
			
 
				+            test.ok(
			
 
				+                checkValue(value, 8, float.readDoubleBE, float.writeDoubleBE, Buffer.prototype.writeDoubleBE),
			
 
				+                "should write and read back " + strval + " (64 bit BE)"
			
 
				+            );
			
 
				+        });
			
 
				+        test.end();
			
 
				+    });
			
 
				+
			
 
				+    test.end();
			
 
				+}
			
 
				+
			
 
				+function checkValue(value, size, read, write, write_comp) {
			
 
				+    var buffer = new Buffer(size);
			
 
				+    write(value, buffer, 0);
			
 
				+    var value_comp = read(buffer, 0);
			
 
				+    var strval = value === 0 && 1 / value < 0 ? "-0" : value.toString();
			
 
				+    if (value !== value) {
			
 
				+        if (value_comp === value_comp)
			
 
				+            return false;
			
 
				+    } else if (value_comp !== value)
			
 
				+        return false;
			
 
				+
			
 
				+    var buffer_comp = new Buffer(size);
			
 
				+    write_comp.call(buffer_comp, value, 0);
			
 
				+    for (var i = 0; i < size; ++i)
			
 
				+        if (buffer[i] !== buffer_comp[i]) {
			
 
				+            console.error(">", buffer, buffer_comp);
			
 
				+            return false;
			
 
				+        }
			
 
				+
			
 
				+    return true;
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/inquire/.npmignore
+++ b/Asistent/node_modules/@protobufjs/inquire/.npmignore
@@ -0,0 +1,3 @@
 
				+npm-debug.*
			
 
				+node_modules/
			
 
				+coverage/
			
--- a/Asistent/node_modules/@protobufjs/inquire/LICENSE
+++ b/Asistent/node_modules/@protobufjs/inquire/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/inquire/README.md
+++ b/Asistent/node_modules/@protobufjs/inquire/README.md
@@ -0,0 +1,13 @@
 
				+@protobufjs/inquire
			
 
				+===================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/inquire.svg)](https://www.npmjs.com/package/@protobufjs/inquire)
			
 
				+
			
 
				+Requires a module only if available and hides the require call from bundlers.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **inquire(moduleName: `string`): `?Object`**<br />
			
 
				+  Requires a module only if available.
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/inquire/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/inquire/index.d.ts
@@ -0,0 +1,9 @@
 
				+export = inquire;
			
 
				+
			
 
				+/**
			
 
				+ * Requires a module only if available.
			
 
				+ * @memberof util
			
 
				+ * @param {string} moduleName Module to require
			
 
				+ * @returns {?Object} Required module if available and not empty, otherwise `null`
			
 
				+ */
			
 
				+declare function inquire(moduleName: string): Object;
			
--- a/Asistent/node_modules/@protobufjs/inquire/index.js
+++ b/Asistent/node_modules/@protobufjs/inquire/index.js
@@ -0,0 +1,17 @@
 
				+"use strict";
			
 
				+module.exports = inquire;
			
 
				+
			
 
				+/**
			
 
				+ * Requires a module only if available.
			
 
				+ * @memberof util
			
 
				+ * @param {string} moduleName Module to require
			
 
				+ * @returns {?Object} Required module if available and not empty, otherwise `null`
			
 
				+ */
			
 
				+function inquire(moduleName) {
			
 
				+    try {
			
 
				+        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
			
 
				+        if (mod && (mod.length || Object.keys(mod).length))
			
 
				+            return mod;
			
 
				+    } catch (e) {} // eslint-disable-line no-empty
			
 
				+    return null;
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/inquire/package.json
+++ b/Asistent/node_modules/@protobufjs/inquire/package.json
@@ -0,0 +1,21 @@
 
				+{
			
 
				+  "name": "@protobufjs/inquire",
			
 
				+  "description": "Requires a module only if available and hides the require call from bundlers.",
			
 
				+  "version": "1.1.0",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts",
			
 
				+  "devDependencies": {
			
 
				+    "istanbul": "^0.4.5",
			
 
				+    "tape": "^4.6.3"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "test": "tape tests/*.js",
			
 
				+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/inquire/tests/data/array.js
+++ b/Asistent/node_modules/@protobufjs/inquire/tests/data/array.js
@@ -0,0 +1 @@
 
				+module.exports = [1];
			
--- a/Asistent/node_modules/@protobufjs/inquire/tests/data/emptyArray.js
+++ b/Asistent/node_modules/@protobufjs/inquire/tests/data/emptyArray.js
@@ -0,0 +1 @@
 
				+module.exports = [];
			
--- a/Asistent/node_modules/@protobufjs/inquire/tests/data/emptyObject.js
+++ b/Asistent/node_modules/@protobufjs/inquire/tests/data/emptyObject.js
@@ -0,0 +1 @@
 
				+module.exports = {};
			
--- a/Asistent/node_modules/@protobufjs/inquire/tests/data/object.js
+++ b/Asistent/node_modules/@protobufjs/inquire/tests/data/object.js
@@ -0,0 +1 @@
 
				+module.exports = { a: 1 };
			
--- a/Asistent/node_modules/@protobufjs/inquire/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/inquire/tests/index.js
@@ -0,0 +1,20 @@
 
				+var tape = require("tape");
			
 
				+
			
 
				+var inquire = require("..");
			
 
				+
			
 
				+tape.test("inquire", function(test) {
			
 
				+
			
 
				+    test.equal(inquire("buffer").Buffer, Buffer, "should be able to require \"buffer\"");
			
 
				+
			
 
				+    test.equal(inquire("%invalid"), null, "should not be able to require \"%invalid\"");
			
 
				+
			
 
				+    test.equal(inquire("./tests/data/emptyObject"), null, "should return null when requiring a module exporting an empty object");
			
 
				+
			
 
				+    test.equal(inquire("./tests/data/emptyArray"), null, "should return null when requiring a module exporting an empty array");
			
 
				+
			
 
				+    test.same(inquire("./tests/data/object"), { a: 1 }, "should return the object if a non-empty object");
			
 
				+
			
 
				+    test.same(inquire("./tests/data/array"), [ 1 ], "should return the module if a non-empty array");
			
 
				+
			
 
				+    test.end();
			
 
				+});
			
--- a/Asistent/node_modules/@protobufjs/path/LICENSE
+++ b/Asistent/node_modules/@protobufjs/path/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/path/README.md
+++ b/Asistent/node_modules/@protobufjs/path/README.md
@@ -0,0 +1,19 @@
 
				+@protobufjs/path
			
 
				+================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/path.svg)](https://www.npmjs.com/package/@protobufjs/path)
			
 
				+
			
 
				+A minimal path module to resolve Unix, Windows and URL paths alike.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **path.isAbsolute(path: `string`): `boolean`**<br />
			
 
				+  Tests if the specified path is absolute.
			
 
				+
			
 
				+* **path.normalize(path: `string`): `string`**<br />
			
 
				+  Normalizes the specified path.
			
 
				+
			
 
				+* **path.resolve(originPath: `string`, includePath: `string`, [alreadyNormalized=false: `boolean`]): `string`**<br />
			
 
				+  Resolves the specified include path against the specified origin path.
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/path/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/path/index.d.ts
@@ -0,0 +1,22 @@
 
				+/**
			
 
				+ * Tests if the specified path is absolute.
			
 
				+ * @param {string} path Path to test
			
 
				+ * @returns {boolean} `true` if path is absolute
			
 
				+ */
			
 
				+export function isAbsolute(path: string): boolean;
			
 
				+
			
 
				+/**
			
 
				+ * Normalizes the specified path.
			
 
				+ * @param {string} path Path to normalize
			
 
				+ * @returns {string} Normalized path
			
 
				+ */
			
 
				+export function normalize(path: string): string;
			
 
				+
			
 
				+/**
			
 
				+ * Resolves the specified include path against the specified origin path.
			
 
				+ * @param {string} originPath Path to the origin file
			
 
				+ * @param {string} includePath Include path relative to origin path
			
 
				+ * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
			
 
				+ * @returns {string} Path to the include file
			
 
				+ */
			
 
				+export function resolve(originPath: string, includePath: string, alreadyNormalized?: boolean): string;
			
--- a/Asistent/node_modules/@protobufjs/path/index.js
+++ b/Asistent/node_modules/@protobufjs/path/index.js
@@ -0,0 +1,65 @@
 
				+"use strict";
			
 
				+
			
 
				+/**
			
 
				+ * A minimal path module to resolve Unix, Windows and URL paths alike.
			
 
				+ * @memberof util
			
 
				+ * @namespace
			
 
				+ */
			
 
				+var path = exports;
			
 
				+
			
 
				+var isAbsolute =
			
 
				+/**
			
 
				+ * Tests if the specified path is absolute.
			
 
				+ * @param {string} path Path to test
			
 
				+ * @returns {boolean} `true` if path is absolute
			
 
				+ */
			
 
				+path.isAbsolute = function isAbsolute(path) {
			
 
				+    return /^(?:\/|\w+:)/.test(path);
			
 
				+};
			
 
				+
			
 
				+var normalize =
			
 
				+/**
			
 
				+ * Normalizes the specified path.
			
 
				+ * @param {string} path Path to normalize
			
 
				+ * @returns {string} Normalized path
			
 
				+ */
			
 
				+path.normalize = function normalize(path) {
			
 
				+    path = path.replace(/\\/g, "/")
			
 
				+               .replace(/\/{2,}/g, "/");
			
 
				+    var parts    = path.split("/"),
			
 
				+        absolute = isAbsolute(path),
			
 
				+        prefix   = "";
			
 
				+    if (absolute)
			
 
				+        prefix = parts.shift() + "/";
			
 
				+    for (var i = 0; i < parts.length;) {
			
 
				+        if (parts[i] === "..") {
			
 
				+            if (i > 0 && parts[i - 1] !== "..")
			
 
				+                parts.splice(--i, 2);
			
 
				+            else if (absolute)
			
 
				+                parts.splice(i, 1);
			
 
				+            else
			
 
				+                ++i;
			
 
				+        } else if (parts[i] === ".")
			
 
				+            parts.splice(i, 1);
			
 
				+        else
			
 
				+            ++i;
			
 
				+    }
			
 
				+    return prefix + parts.join("/");
			
 
				+};
			
 
				+
			
 
				+/**
			
 
				+ * Resolves the specified include path against the specified origin path.
			
 
				+ * @param {string} originPath Path to the origin file
			
 
				+ * @param {string} includePath Include path relative to origin path
			
 
				+ * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
			
 
				+ * @returns {string} Path to the include file
			
 
				+ */
			
 
				+path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
			
 
				+    if (!alreadyNormalized)
			
 
				+        includePath = normalize(includePath);
			
 
				+    if (isAbsolute(includePath))
			
 
				+        return includePath;
			
 
				+    if (!alreadyNormalized)
			
 
				+        originPath = normalize(originPath);
			
 
				+    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
			
 
				+};
			
--- a/Asistent/node_modules/@protobufjs/path/package.json
+++ b/Asistent/node_modules/@protobufjs/path/package.json
@@ -0,0 +1,21 @@
 
				+{
			
 
				+  "name": "@protobufjs/path",
			
 
				+  "description": "A minimal path module to resolve Unix, Windows and URL paths alike.",
			
 
				+  "version": "1.1.2",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts",
			
 
				+  "devDependencies": {
			
 
				+    "istanbul": "^0.4.5",
			
 
				+    "tape": "^4.6.3"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "test": "tape tests/*.js",
			
 
				+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/path/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/path/tests/index.js
@@ -0,0 +1,60 @@
 
				+var tape = require("tape");
			
 
				+
			
 
				+var path = require("..");
			
 
				+
			
 
				+tape.test("path", function(test) {
			
 
				+
			
 
				+    test.ok(path.isAbsolute("X:\\some\\path\\file.js"), "should identify absolute windows paths");
			
 
				+    test.ok(path.isAbsolute("/some/path/file.js"), "should identify absolute unix paths");
			
 
				+
			
 
				+    test.notOk(path.isAbsolute("some\\path\\file.js"), "should identify relative windows paths");
			
 
				+    test.notOk(path.isAbsolute("some/path/file.js"), "should identify relative unix paths");
			
 
				+
			
 
				+    var paths = [
			
 
				+        {
			
 
				+            actual: "X:\\some\\..\\.\\path\\\\file.js",
			
 
				+            normal: "X:/path/file.js",
			
 
				+            resolve: {
			
 
				+                origin: "X:/path/origin.js",
			
 
				+                expected: "X:/path/file.js"
			
 
				+            }
			
 
				+        }, {
			
 
				+            actual: "some\\..\\.\\path\\\\file.js",
			
 
				+            normal: "path/file.js",
			
 
				+            resolve: {
			
 
				+                origin: "X:/path/origin.js",
			
 
				+                expected: "X:/path/path/file.js"
			
 
				+            }
			
 
				+        }, {
			
 
				+            actual: "/some/.././path//file.js",
			
 
				+            normal: "/path/file.js",
			
 
				+            resolve: {
			
 
				+                origin: "/path/origin.js",
			
 
				+                expected: "/path/file.js"
			
 
				+            }
			
 
				+        }, {
			
 
				+            actual: "some/.././path//file.js",
			
 
				+            normal: "path/file.js",
			
 
				+            resolve: {
			
 
				+                origin: "",
			
 
				+                expected: "path/file.js"
			
 
				+            }
			
 
				+        }, {
			
 
				+            actual: ".././path//file.js",
			
 
				+            normal: "../path/file.js"
			
 
				+        }, {
			
 
				+            actual: "/.././path//file.js",
			
 
				+            normal: "/path/file.js"
			
 
				+        }
			
 
				+    ];
			
 
				+
			
 
				+    paths.forEach(function(p) {
			
 
				+        test.equal(path.normalize(p.actual), p.normal, "should normalize " + p.actual);
			
 
				+        if (p.resolve) {
			
 
				+            test.equal(path.resolve(p.resolve.origin, p.actual), p.resolve.expected, "should resolve " + p.actual);
			
 
				+            test.equal(path.resolve(p.resolve.origin, p.normal, true), p.resolve.expected, "should resolve " + p.normal + " (already normalized)");
			
 
				+        }
			
 
				+    });
			
 
				+
			
 
				+    test.end();
			
 
				+});
			
--- a/Asistent/node_modules/@protobufjs/pool/.npmignore
+++ b/Asistent/node_modules/@protobufjs/pool/.npmignore
@@ -0,0 +1,3 @@
 
				+npm-debug.*
			
 
				+node_modules/
			
 
				+coverage/
			
--- a/Asistent/node_modules/@protobufjs/pool/LICENSE
+++ b/Asistent/node_modules/@protobufjs/pool/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/pool/README.md
+++ b/Asistent/node_modules/@protobufjs/pool/README.md
@@ -0,0 +1,13 @@
 
				+@protobufjs/pool
			
 
				+================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/pool.svg)](https://www.npmjs.com/package/@protobufjs/pool)
			
 
				+
			
 
				+A general purpose buffer pool.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **pool(alloc: `function(size: number): Uint8Array`, slice: `function(this: Uint8Array, start: number, end: number): Uint8Array`, [size=8192: `number`]): `function(size: number): Uint8Array`**<br />
			
 
				+  Creates a pooled allocator.
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/pool/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/pool/index.d.ts
@@ -0,0 +1,32 @@
 
				+export = pool;
			
 
				+
			
 
				+/**
			
 
				+ * An allocator as used by {@link util.pool}.
			
 
				+ * @typedef PoolAllocator
			
 
				+ * @type {function}
			
 
				+ * @param {number} size Buffer size
			
 
				+ * @returns {Uint8Array} Buffer
			
 
				+ */
			
 
				+type PoolAllocator = (size: number) => Uint8Array;
			
 
				+
			
 
				+/**
			
 
				+ * A slicer as used by {@link util.pool}.
			
 
				+ * @typedef PoolSlicer
			
 
				+ * @type {function}
			
 
				+ * @param {number} start Start offset
			
 
				+ * @param {number} end End offset
			
 
				+ * @returns {Uint8Array} Buffer slice
			
 
				+ * @this {Uint8Array}
			
 
				+ */
			
 
				+type PoolSlicer = (this: Uint8Array, start: number, end: number) => Uint8Array;
			
 
				+
			
 
				+/**
			
 
				+ * A general purpose buffer pool.
			
 
				+ * @memberof util
			
 
				+ * @function
			
 
				+ * @param {PoolAllocator} alloc Allocator
			
 
				+ * @param {PoolSlicer} slice Slicer
			
 
				+ * @param {number} [size=8192] Slab size
			
 
				+ * @returns {PoolAllocator} Pooled allocator
			
 
				+ */
			
 
				+declare function pool(alloc: PoolAllocator, slice: PoolSlicer, size?: number): PoolAllocator;
			
--- a/Asistent/node_modules/@protobufjs/pool/index.js
+++ b/Asistent/node_modules/@protobufjs/pool/index.js
@@ -0,0 +1,48 @@
 
				+"use strict";
			
 
				+module.exports = pool;
			
 
				+
			
 
				+/**
			
 
				+ * An allocator as used by {@link util.pool}.
			
 
				+ * @typedef PoolAllocator
			
 
				+ * @type {function}
			
 
				+ * @param {number} size Buffer size
			
 
				+ * @returns {Uint8Array} Buffer
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * A slicer as used by {@link util.pool}.
			
 
				+ * @typedef PoolSlicer
			
 
				+ * @type {function}
			
 
				+ * @param {number} start Start offset
			
 
				+ * @param {number} end End offset
			
 
				+ * @returns {Uint8Array} Buffer slice
			
 
				+ * @this {Uint8Array}
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * A general purpose buffer pool.
			
 
				+ * @memberof util
			
 
				+ * @function
			
 
				+ * @param {PoolAllocator} alloc Allocator
			
 
				+ * @param {PoolSlicer} slice Slicer
			
 
				+ * @param {number} [size=8192] Slab size
			
 
				+ * @returns {PoolAllocator} Pooled allocator
			
 
				+ */
			
 
				+function pool(alloc, slice, size) {
			
 
				+    var SIZE   = size || 8192;
			
 
				+    var MAX    = SIZE >>> 1;
			
 
				+    var slab   = null;
			
 
				+    var offset = SIZE;
			
 
				+    return function pool_alloc(size) {
			
 
				+        if (size < 1 || size > MAX)
			
 
				+            return alloc(size);
			
 
				+        if (offset + size > SIZE) {
			
 
				+            slab = alloc(SIZE);
			
 
				+            offset = 0;
			
 
				+        }
			
 
				+        var buf = slice.call(slab, offset, offset += size);
			
 
				+        if (offset & 7) // align to 32 bit
			
 
				+            offset = (offset | 7) + 1;
			
 
				+        return buf;
			
 
				+    };
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/pool/package.json
+++ b/Asistent/node_modules/@protobufjs/pool/package.json
@@ -0,0 +1,21 @@
 
				+{
			
 
				+  "name": "@protobufjs/pool",
			
 
				+  "description": "A general purpose buffer pool.",
			
 
				+  "version": "1.1.0",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts",
			
 
				+  "devDependencies": {
			
 
				+    "istanbul": "^0.4.5",
			
 
				+    "tape": "^4.6.3"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "test": "tape tests/*.js",
			
 
				+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/pool/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/pool/tests/index.js
@@ -0,0 +1,33 @@
 
				+var tape = require("tape");
			
 
				+
			
 
				+var pool = require("..");
			
 
				+
			
 
				+if (typeof Uint8Array !== "undefined")
			
 
				+tape.test("pool", function(test) {
			
 
				+
			
 
				+    var alloc = pool(function(size) { return new Uint8Array(size); }, Uint8Array.prototype.subarray);
			
 
				+
			
 
				+    var buf1 = alloc(0);
			
 
				+    test.equal(buf1.length, 0, "should allocate a buffer of size 0");
			
 
				+
			
 
				+    var buf2 = alloc(1);
			
 
				+    test.equal(buf2.length, 1, "should allocate a buffer of size 1 (initializes slab)");
			
 
				+
			
 
				+    test.notEqual(buf2.buffer, buf1.buffer, "should not reference the same backing buffer if previous buffer had size 0");
			
 
				+    test.equal(buf2.byteOffset, 0, "should allocate at byteOffset 0 when using a new slab");
			
 
				+
			
 
				+    buf1 = alloc(1);
			
 
				+    test.equal(buf1.buffer, buf2.buffer, "should reference the same backing buffer when allocating a chunk fitting into the slab");
			
 
				+    test.equal(buf1.byteOffset, 8, "should align slices to 32 bit and this allocate at byteOffset 8");
			
 
				+
			
 
				+    var buf3 = alloc(4097);
			
 
				+    test.notEqual(buf3.buffer, buf2.buffer, "should not reference the same backing buffer when allocating a buffer larger than half the backing buffer's size");
			
 
				+
			
 
				+    buf2 = alloc(4096);
			
 
				+    test.equal(buf2.buffer, buf1.buffer, "should reference the same backing buffer when allocating a buffer smaller or equal than half the backing buffer's size");
			
 
				+
			
 
				+    buf1 = alloc(4096);
			
 
				+    test.notEqual(buf1.buffer, buf2.buffer, "should not reference the same backing buffer when the slab is exhausted (initializes new slab)");
			
 
				+
			
 
				+    test.end();
			
 
				+});
			
--- a/Asistent/node_modules/@protobufjs/utf8/.npmignore
+++ b/Asistent/node_modules/@protobufjs/utf8/.npmignore
@@ -0,0 +1,3 @@
 
				+npm-debug.*
			
 
				+node_modules/
			
 
				+coverage/
			
--- a/Asistent/node_modules/@protobufjs/utf8/LICENSE
+++ b/Asistent/node_modules/@protobufjs/utf8/LICENSE
@@ -0,0 +1,26 @@
 
				+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+* Redistributions of source code must retain the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer.
			
 
				+* Redistributions in binary form must reproduce the above copyright
			
 
				+  notice, this list of conditions and the following disclaimer in the
			
 
				+  documentation and/or other materials provided with the distribution.
			
 
				+* Neither the name of its author, nor the names of its contributors
			
 
				+  may be used to endorse or promote products derived from this software
			
 
				+  without specific prior written permission.
			
 
				+
			
 
				+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			
 
				+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			
 
				+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			
 
				+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			
 
				+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			
 
				+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			
 
				+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			
 
				+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			
 
				+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			
 
				+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			
 
				+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
			
--- a/Asistent/node_modules/@protobufjs/utf8/README.md
+++ b/Asistent/node_modules/@protobufjs/utf8/README.md
@@ -0,0 +1,20 @@
 
				+@protobufjs/utf8
			
 
				+================
			
 
				+[![npm](https://img.shields.io/npm/v/@protobufjs/utf8.svg)](https://www.npmjs.com/package/@protobufjs/utf8)
			
 
				+
			
 
				+A minimal UTF8 implementation for number arrays.
			
 
				+
			
 
				+API
			
 
				+---
			
 
				+
			
 
				+* **utf8.length(string: `string`): `number`**<br />
			
 
				+  Calculates the UTF8 byte length of a string.
			
 
				+
			
 
				+* **utf8.read(buffer: `Uint8Array`, start: `number`, end: `number`): `string`**<br />
			
 
				+  Reads UTF8 bytes as a string.
			
 
				+
			
 
				+* **utf8.write(string: `string`, buffer: `Uint8Array`, offset: `number`): `number`**<br />
			
 
				+  Writes a string as UTF8 bytes.
			
 
				+
			
 
				+
			
 
				+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
			
--- a/Asistent/node_modules/@protobufjs/utf8/index.d.ts
+++ b/Asistent/node_modules/@protobufjs/utf8/index.d.ts
@@ -0,0 +1,24 @@
 
				+/**
			
 
				+ * Calculates the UTF8 byte length of a string.
			
 
				+ * @param {string} string String
			
 
				+ * @returns {number} Byte length
			
 
				+ */
			
 
				+export function length(string: string): number;
			
 
				+
			
 
				+/**
			
 
				+ * Reads UTF8 bytes as a string.
			
 
				+ * @param {Uint8Array} buffer Source buffer
			
 
				+ * @param {number} start Source start
			
 
				+ * @param {number} end Source end
			
 
				+ * @returns {string} String read
			
 
				+ */
			
 
				+export function read(buffer: Uint8Array, start: number, end: number): string;
			
 
				+
			
 
				+/**
			
 
				+ * Writes a string as UTF8 bytes.
			
 
				+ * @param {string} string Source string
			
 
				+ * @param {Uint8Array} buffer Destination buffer
			
 
				+ * @param {number} offset Destination offset
			
 
				+ * @returns {number} Bytes written
			
 
				+ */
			
 
				+export function write(string: string, buffer: Uint8Array, offset: number): number;
			
--- a/Asistent/node_modules/@protobufjs/utf8/index.js
+++ b/Asistent/node_modules/@protobufjs/utf8/index.js
@@ -0,0 +1,105 @@
 
				+"use strict";
			
 
				+
			
 
				+/**
			
 
				+ * A minimal UTF8 implementation for number arrays.
			
 
				+ * @memberof util
			
 
				+ * @namespace
			
 
				+ */
			
 
				+var utf8 = exports;
			
 
				+
			
 
				+/**
			
 
				+ * Calculates the UTF8 byte length of a string.
			
 
				+ * @param {string} string String
			
 
				+ * @returns {number} Byte length
			
 
				+ */
			
 
				+utf8.length = function utf8_length(string) {
			
 
				+    var len = 0,
			
 
				+        c = 0;
			
 
				+    for (var i = 0; i < string.length; ++i) {
			
 
				+        c = string.charCodeAt(i);
			
 
				+        if (c < 128)
			
 
				+            len += 1;
			
 
				+        else if (c < 2048)
			
 
				+            len += 2;
			
 
				+        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
			
 
				+            ++i;
			
 
				+            len += 4;
			
 
				+        } else
			
 
				+            len += 3;
			
 
				+    }
			
 
				+    return len;
			
 
				+};
			
 
				+
			
 
				+/**
			
 
				+ * Reads UTF8 bytes as a string.
			
 
				+ * @param {Uint8Array} buffer Source buffer
			
 
				+ * @param {number} start Source start
			
 
				+ * @param {number} end Source end
			
 
				+ * @returns {string} String read
			
 
				+ */
			
 
				+utf8.read = function utf8_read(buffer, start, end) {
			
 
				+    var len = end - start;
			
 
				+    if (len < 1)
			
 
				+        return "";
			
 
				+    var parts = null,
			
 
				+        chunk = [],
			
 
				+        i = 0, // char offset
			
 
				+        t;     // temporary
			
 
				+    while (start < end) {
			
 
				+        t = buffer[start++];
			
 
				+        if (t < 128)
			
 
				+            chunk[i++] = t;
			
 
				+        else if (t > 191 && t < 224)
			
 
				+            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
			
 
				+        else if (t > 239 && t < 365) {
			
 
				+            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
			
 
				+            chunk[i++] = 0xD800 + (t >> 10);
			
 
				+            chunk[i++] = 0xDC00 + (t & 1023);
			
 
				+        } else
			
 
				+            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
			
 
				+        if (i > 8191) {
			
 
				+            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
			
 
				+            i = 0;
			
 
				+        }
			
 
				+    }
			
 
				+    if (parts) {
			
 
				+        if (i)
			
 
				+            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
			
 
				+        return parts.join("");
			
 
				+    }
			
 
				+    return String.fromCharCode.apply(String, chunk.slice(0, i));
			
 
				+};
			
 
				+
			
 
				+/**
			
 
				+ * Writes a string as UTF8 bytes.
			
 
				+ * @param {string} string Source string
			
 
				+ * @param {Uint8Array} buffer Destination buffer
			
 
				+ * @param {number} offset Destination offset
			
 
				+ * @returns {number} Bytes written
			
 
				+ */
			
 
				+utf8.write = function utf8_write(string, buffer, offset) {
			
 
				+    var start = offset,
			
 
				+        c1, // character 1
			
 
				+        c2; // character 2
			
 
				+    for (var i = 0; i < string.length; ++i) {
			
 
				+        c1 = string.charCodeAt(i);
			
 
				+        if (c1 < 128) {
			
 
				+            buffer[offset++] = c1;
			
 
				+        } else if (c1 < 2048) {
			
 
				+            buffer[offset++] = c1 >> 6       | 192;
			
 
				+            buffer[offset++] = c1       & 63 | 128;
			
 
				+        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
			
 
				+            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
			
 
				+            ++i;
			
 
				+            buffer[offset++] = c1 >> 18      | 240;
			
 
				+            buffer[offset++] = c1 >> 12 & 63 | 128;
			
 
				+            buffer[offset++] = c1 >> 6  & 63 | 128;
			
 
				+            buffer[offset++] = c1       & 63 | 128;
			
 
				+        } else {
			
 
				+            buffer[offset++] = c1 >> 12      | 224;
			
 
				+            buffer[offset++] = c1 >> 6  & 63 | 128;
			
 
				+            buffer[offset++] = c1       & 63 | 128;
			
 
				+        }
			
 
				+    }
			
 
				+    return offset - start;
			
 
				+};
			
--- a/Asistent/node_modules/@protobufjs/utf8/package.json
+++ b/Asistent/node_modules/@protobufjs/utf8/package.json
@@ -0,0 +1,21 @@
 
				+{
			
 
				+  "name": "@protobufjs/utf8",
			
 
				+  "description": "A minimal UTF8 implementation for number arrays.",
			
 
				+  "version": "1.1.0",
			
 
				+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/dcodeIO/protobuf.js.git"
			
 
				+  },
			
 
				+  "license": "BSD-3-Clause",
			
 
				+  "main": "index.js",
			
 
				+  "types": "index.d.ts",
			
 
				+  "devDependencies": {
			
 
				+    "istanbul": "^0.4.5",
			
 
				+    "tape": "^4.6.3"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "test": "tape tests/*.js",
			
 
				+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
			
 
				+  }
			
 
				+}
			
--- a/Asistent/node_modules/@protobufjs/utf8/tests/data/utf8.txt
+++ b/Asistent/node_modules/@protobufjs/utf8/tests/data/utf8.txt
@@ -0,0 +1,216 @@
 
				+UTF-8 encoded sample plain-text file
			
 
				+‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
			
 
				+
			
 
				+Markus Kuhn [ˈmaʳkʊs kuːn] <http://www.cl.cam.ac.uk/~mgk25/> — 2002-07-25 CC BY
			
 
				+
			
 
				+
			
 
				+The ASCII compatible UTF-8 encoding used in this plain-text file
			
 
				+is defined in Unicode, ISO 10646-1, and RFC 2279.
			
 
				+
			
 
				+
			
 
				+Using Unicode/UTF-8, you can write in emails and source code things such as
			
 
				+
			
 
				+Mathematics and sciences:
			
 
				+
			
 
				+  ∮ E⋅da = Q,  n → ∞, ∑ f(i) = ∏ g(i),      ⎧⎡⎛┌─────┐⎞⎤⎫
			
 
				+                                            ⎪⎢⎜│a²+b³ ⎟⎥⎪
			
 
				+  ∀x∈ℝ: ⌈x⌉ = −⌊−x⌋, α ∧ ¬β = ¬(¬α ∨ β),    ⎪⎢⎜│───── ⎟⎥⎪
			
 
				+                                            ⎪⎢⎜⎷ c₈   ⎟⎥⎪
			
 
				+  ℕ ⊆ ℕ₀ ⊂ ℤ ⊂ ℚ ⊂ ℝ ⊂ ℂ,                   ⎨⎢⎜       ⎟⎥⎬
			
 
				+                                            ⎪⎢⎜ ∞     ⎟⎥⎪
			
 
				+  ⊥ < a ≠ b ≡ c ≤ d ≪ ⊤ ⇒ (⟦A⟧ ⇔ ⟪B⟫),      ⎪⎢⎜ ⎲     ⎟⎥⎪
			
 
				+                                            ⎪⎢⎜ ⎳aⁱ-bⁱ⎟⎥⎪
			
 
				+  2H₂ + O₂ ⇌ 2H₂O, R = 4.7 kΩ, ⌀ 200 mm     ⎩⎣⎝i=1    ⎠⎦⎭
			
 
				+
			
 
				+Linguistics and dictionaries:
			
 
				+
			
 
				+  ði ıntəˈnæʃənəl fəˈnɛtık əsoʊsiˈeıʃn
			
 
				+  Y [ˈʏpsilɔn], Yen [jɛn], Yoga [ˈjoːgɑ]
			
 
				+
			
 
				+APL:
			
 
				+
			
 
				+  ((V⍳V)=⍳⍴V)/V←,V    ⌷←⍳→⍴∆∇⊃‾⍎⍕⌈
			
 
				+
			
 
				+Nicer typography in plain text files:
			
 
				+
			
 
				+  ╔══════════════════════════════════════════╗
			
 
				+  ║                                          ║
			
 
				+  ║   • ‘single’ and “double” quotes         ║
			
 
				+  ║                                          ║
			
 
				+  ║   • Curly apostrophes: “We’ve been here” ║
			
 
				+  ║                                          ║
			
 
				+  ║   • Latin-1 apostrophe and accents: '´`  ║
			
 
				+  ║                                          ║
			
 
				+  ║   • ‚deutsche‘ „Anführungszeichen“       ║
			
 
				+  ║                                          ║
			
 
				+  ║   • †, ‡, ‰, •, 3–4, —, −5/+5, ™, …      ║
			
 
				+  ║                                          ║
			
 
				+  ║   • ASCII safety test: 1lI|, 0OD, 8B     ║
			
 
				+  ║                      ╭─────────╮         ║
			
 
				+  ║   • the euro symbol: │ 14.95 € │         ║
			
 
				+  ║                      ╰─────────╯         ║
			
 
				+  ╚══════════════════════════════════════════╝
			
 
				+
			
 
				+Combining characters:
			
 
				+
			
 
				+  STARGΛ̊TE SG-1, a = v̇ = r̈, a⃑ ⊥ b⃑
			
 
				+
			
 
				+Greek (in Polytonic):
			
 
				+
			
 
				+  The Greek anthem:
			
 
				+
			
 
				+  Σὲ γνωρίζω ἀπὸ τὴν κόψη
			
 
				+  τοῦ σπαθιοῦ τὴν τρομερή,
			
 
				+  σὲ γνωρίζω ἀπὸ τὴν ὄψη
			
 
				+  ποὺ μὲ βία μετράει τὴ γῆ.
			
 
				+
			
 
				+  ᾿Απ᾿ τὰ κόκκαλα βγαλμένη
			
 
				+  τῶν ῾Ελλήνων τὰ ἱερά
			
 
				+  καὶ σὰν πρῶτα ἀνδρειωμένη
			
 
				+  χαῖρε, ὦ χαῖρε, ᾿Ελευθεριά!
			
 
				+
			
 
				+  From a speech of Demosthenes in the 4th century BC:
			
 
				+
			
 
				+  Οὐχὶ ταὐτὰ παρίσταταί μοι γιγνώσκειν, ὦ ἄνδρες ᾿Αθηναῖοι,
			
 
				+  ὅταν τ᾿ εἰς τὰ πράγματα ἀποβλέψω καὶ ὅταν πρὸς τοὺς
			
 
				+  λόγους οὓς ἀκούω· τοὺς μὲν γὰρ λόγους περὶ τοῦ
			
 
				+  τιμωρήσασθαι Φίλιππον ὁρῶ γιγνομένους, τὰ δὲ πράγματ᾿
			
 
				+  εἰς τοῦτο προήκοντα,  ὥσθ᾿ ὅπως μὴ πεισόμεθ᾿ αὐτοὶ
			
 
				+  πρότερον κακῶς σκέψασθαι δέον. οὐδέν οὖν ἄλλο μοι δοκοῦσιν
			
 
				+  οἱ τὰ τοιαῦτα λέγοντες ἢ τὴν ὑπόθεσιν, περὶ ἧς βουλεύεσθαι,
			
 
				+  οὐχὶ τὴν οὖσαν παριστάντες ὑμῖν ἁμαρτάνειν. ἐγὼ δέ, ὅτι μέν
			
 
				+  ποτ᾿ ἐξῆν τῇ πόλει καὶ τὰ αὑτῆς ἔχειν ἀσφαλῶς καὶ Φίλιππον
			
 
				+  τιμωρήσασθαι, καὶ μάλ᾿ ἀκριβῶς οἶδα· ἐπ᾿ ἐμοῦ γάρ, οὐ πάλαι
			
 
				+  γέγονεν ταῦτ᾿ ἀμφότερα· νῦν μέντοι πέπεισμαι τοῦθ᾿ ἱκανὸν
			
 
				+  προλαβεῖν ἡμῖν εἶναι τὴν πρώτην, ὅπως τοὺς συμμάχους
			
 
				+  σώσομεν. ἐὰν γὰρ τοῦτο βεβαίως ὑπάρξῃ, τότε καὶ περὶ τοῦ
			
 
				+  τίνα τιμωρήσεταί τις καὶ ὃν τρόπον ἐξέσται σκοπεῖν· πρὶν δὲ
			
 
				+  τὴν ἀρχὴν ὀρθῶς ὑποθέσθαι, μάταιον ἡγοῦμαι περὶ τῆς
			
 
				+  τελευτῆς ὁντινοῦν ποιεῖσθαι λόγον.
			
 
				+
			
 
				+  Δημοσθένους, Γ´ ᾿Ολυνθιακὸς
			
 
				+
			
 
				+Georgian:
			
 
				+
			
 
				+  From a Unicode conference invitation:
			
 
				+
			
 
				+  გთხოვთ ახლავე გაიაროთ რეგისტრაცია Unicode-ის მეათე საერთაშორისო
			
 
				+  კონფერენციაზე დასასწრებად, რომელიც გაიმართება 10-12 მარტს,
			
 
				+  ქ. მაინცში, გერმანიაში. კონფერენცია შეჰკრებს ერთად მსოფლიოს
			
 
				+  ექსპერტებს ისეთ დარგებში როგორიცაა ინტერნეტი და Unicode-ი,
			
 
				+  ინტერნაციონალიზაცია და ლოკალიზაცია, Unicode-ის გამოყენება
			
 
				+  ოპერაციულ სისტემებსა, და გამოყენებით პროგრამებში, შრიფტებში,
			
 
				+  ტექსტების დამუშავებასა და მრავალენოვან კომპიუტერულ სისტემებში.
			
 
				+
			
 
				+Russian:
			
 
				+
			
 
				+  From a Unicode conference invitation:
			
 
				+
			
 
				+  Зарегистрируйтесь сейчас на Десятую Международную Конференцию по
			
 
				+  Unicode, которая состоится 10-12 марта 1997 года в Майнце в Германии.
			
 
				+  Конференция соберет широкий круг экспертов по  вопросам глобального
			
 
				+  Интернета и Unicode, локализации и интернационализации, воплощению и
			
 
				+  применению Unicode в различных операционных системах и программных
			
 
				+  приложениях, шрифтах, верстке и многоязычных компьютерных системах.
			
 
				+
			
 
				+Thai (UCS Level 2):
			
 
				+
			
 
				+  Excerpt from a poetry on The Romance of The Three Kingdoms (a Chinese
			
 
				+  classic 'San Gua'):
			
 
				+
			
 
				+  [----------------------------|------------------------]
			
 
				+    ๏ แผ่นดินฮั่นเสื่อมโทรมแสนสังเวช  พระปกเกศกองบู๊กู้ขึ้นใหม่
			
 
				+  สิบสองกษัตริย์ก่อนหน้าแลถัดไป       สององค์ไซร้โง่เขลาเบาปัญญา
			
 
				+    ทรงนับถือขันทีเป็นที่พึ่ง           บ้านเมืองจึงวิปริตเป็นนักหนา
			
 
				+  โฮจิ๋นเรียกทัพทั่วหัวเมืองมา         หมายจะฆ่ามดชั่วตัวสำคัญ
			
 
				+    เหมือนขับไสไล่เสือจากเคหา      รับหมาป่าเข้ามาเลยอาสัญ
			
 
				+  ฝ่ายอ้องอุ้นยุแยกให้แตกกัน          ใช้สาวนั้นเป็นชนวนชื่นชวนใจ
			
 
				+    พลันลิฉุยกุยกีกลับก่อเหตุ          ช่างอาเพศจริงหนาฟ้าร้องไห้
			
 
				+  ต้องรบราฆ่าฟันจนบรรลัย           ฤๅหาใครค้ำชูกู้บรรลังก์ ฯ
			
 
				+
			
 
				+  (The above is a two-column text. If combining characters are handled
			
 
				+  correctly, the lines of the second column should be aligned with the
			
 
				+  | character above.)
			
 
				+
			
 
				+Ethiopian:
			
 
				+
			
 
				+  Proverbs in the Amharic language:
			
 
				+
			
 
				+  ሰማይ አይታረስ ንጉሥ አይከሰስ።
			
 
				+  ብላ ካለኝ እንደአባቴ በቆመጠኝ።
			
 
				+  ጌጥ ያለቤቱ ቁምጥና ነው።
			
 
				+  ደሀ በሕልሙ ቅቤ ባይጠጣ ንጣት በገደለው።
			
 
				+  የአፍ ወለምታ በቅቤ አይታሽም።
			
 
				+  አይጥ በበላ ዳዋ ተመታ።
			
 
				+  ሲተረጉሙ ይደረግሙ።
			
 
				+  ቀስ በቀስ፥ ዕንቁላል በእግሩ ይሄዳል።
			
 
				+  ድር ቢያብር አንበሳ ያስር።
			
 
				+  ሰው እንደቤቱ እንጅ እንደ ጉረቤቱ አይተዳደርም።
			
 
				+  እግዜር የከፈተውን ጉሮሮ ሳይዘጋው አይድርም።
			
 
				+  የጎረቤት ሌባ፥ ቢያዩት ይስቅ ባያዩት ያጠልቅ።
			
 
				+  ሥራ ከመፍታት ልጄን ላፋታት።
			
 
				+  ዓባይ ማደሪያ የለው፥ ግንድ ይዞ ይዞራል።
			
 
				+  የእስላም አገሩ መካ የአሞራ አገሩ ዋርካ።
			
 
				+  ተንጋሎ ቢተፉ ተመልሶ ባፉ።
			
 
				+  ወዳጅህ ማር ቢሆን ጨርስህ አትላሰው።
			
 
				+  እግርህን በፍራሽህ ልክ ዘርጋ።
			
 
				+
			
 
				+Runes:
			
 
				+
			
 
				+  ᚻᛖ ᚳᚹᚫᚦ ᚦᚫᛏ ᚻᛖ ᛒᚢᛞᛖ ᚩᚾ ᚦᚫᛗ ᛚᚪᚾᛞᛖ ᚾᚩᚱᚦᚹᛖᚪᚱᛞᚢᛗ ᚹᛁᚦ ᚦᚪ ᚹᛖᛥᚫ
			
 
				+
			
 
				+  (Old English, which transcribed into Latin reads 'He cwaeth that he
			
 
				+  bude thaem lande northweardum with tha Westsae.' and means 'He said
			
 
				+  that he lived in the northern land near the Western Sea.')
			
 
				+
			
 
				+Braille:
			
 
				+
			
 
				+  ⡌⠁⠧⠑ ⠼⠁⠒  ⡍⠜⠇⠑⠹⠰⠎ ⡣⠕⠌
			
 
				+
			
 
				+  ⡍⠜⠇⠑⠹ ⠺⠁⠎ ⠙⠑⠁⠙⠒ ⠞⠕ ⠃⠑⠛⠔ ⠺⠊⠹⠲ ⡹⠻⠑ ⠊⠎ ⠝⠕ ⠙⠳⠃⠞
			
 
				+  ⠱⠁⠞⠑⠧⠻ ⠁⠃⠳⠞ ⠹⠁⠞⠲ ⡹⠑ ⠗⠑⠛⠊⠌⠻ ⠕⠋ ⠙⠊⠎ ⠃⠥⠗⠊⠁⠇ ⠺⠁⠎
			
 
				+  ⠎⠊⠛⠝⠫ ⠃⠹ ⠹⠑ ⠊⠇⠻⠛⠹⠍⠁⠝⠂ ⠹⠑ ⠊⠇⠻⠅⠂ ⠹⠑ ⠥⠝⠙⠻⠞⠁⠅⠻⠂
			
 
				+  ⠁⠝⠙ ⠹⠑ ⠡⠊⠑⠋ ⠍⠳⠗⠝⠻⠲ ⡎⠊⠗⠕⠕⠛⠑ ⠎⠊⠛⠝⠫ ⠊⠞⠲ ⡁⠝⠙
			
 
				+  ⡎⠊⠗⠕⠕⠛⠑⠰⠎ ⠝⠁⠍⠑ ⠺⠁⠎ ⠛⠕⠕⠙ ⠥⠏⠕⠝ ⠰⡡⠁⠝⠛⠑⠂ ⠋⠕⠗ ⠁⠝⠹⠹⠔⠛ ⠙⠑
			
 
				+  ⠡⠕⠎⠑ ⠞⠕ ⠏⠥⠞ ⠙⠊⠎ ⠙⠁⠝⠙ ⠞⠕⠲
			
 
				+
			
 
				+  ⡕⠇⠙ ⡍⠜⠇⠑⠹ ⠺⠁⠎ ⠁⠎ ⠙⠑⠁⠙ ⠁⠎ ⠁ ⠙⠕⠕⠗⠤⠝⠁⠊⠇⠲
			
 
				+
			
 
				+  ⡍⠔⠙⠖ ⡊ ⠙⠕⠝⠰⠞ ⠍⠑⠁⠝ ⠞⠕ ⠎⠁⠹ ⠹⠁⠞ ⡊ ⠅⠝⠪⠂ ⠕⠋ ⠍⠹
			
 
				+  ⠪⠝ ⠅⠝⠪⠇⠫⠛⠑⠂ ⠱⠁⠞ ⠹⠻⠑ ⠊⠎ ⠏⠜⠞⠊⠊⠥⠇⠜⠇⠹ ⠙⠑⠁⠙ ⠁⠃⠳⠞
			
 
				+  ⠁ ⠙⠕⠕⠗⠤⠝⠁⠊⠇⠲ ⡊ ⠍⠊⠣⠞ ⠙⠁⠧⠑ ⠃⠑⠲ ⠔⠊⠇⠔⠫⠂ ⠍⠹⠎⠑⠇⠋⠂ ⠞⠕
			
 
				+  ⠗⠑⠛⠜⠙ ⠁ ⠊⠕⠋⠋⠔⠤⠝⠁⠊⠇ ⠁⠎ ⠹⠑ ⠙⠑⠁⠙⠑⠌ ⠏⠊⠑⠊⠑ ⠕⠋ ⠊⠗⠕⠝⠍⠕⠝⠛⠻⠹
			
 
				+  ⠔ ⠹⠑ ⠞⠗⠁⠙⠑⠲ ⡃⠥⠞ ⠹⠑ ⠺⠊⠎⠙⠕⠍ ⠕⠋ ⠳⠗ ⠁⠝⠊⠑⠌⠕⠗⠎
			
 
				+  ⠊⠎ ⠔ ⠹⠑ ⠎⠊⠍⠊⠇⠑⠆ ⠁⠝⠙ ⠍⠹ ⠥⠝⠙⠁⠇⠇⠪⠫ ⠙⠁⠝⠙⠎
			
 
				+  ⠩⠁⠇⠇ ⠝⠕⠞ ⠙⠊⠌⠥⠗⠃ ⠊⠞⠂ ⠕⠗ ⠹⠑ ⡊⠳⠝⠞⠗⠹⠰⠎ ⠙⠕⠝⠑ ⠋⠕⠗⠲ ⡹⠳
			
 
				+  ⠺⠊⠇⠇ ⠹⠻⠑⠋⠕⠗⠑ ⠏⠻⠍⠊⠞ ⠍⠑ ⠞⠕ ⠗⠑⠏⠑⠁⠞⠂ ⠑⠍⠏⠙⠁⠞⠊⠊⠁⠇⠇⠹⠂ ⠹⠁⠞
			
 
				+  ⡍⠜⠇⠑⠹ ⠺⠁⠎ ⠁⠎ ⠙⠑⠁⠙ ⠁⠎ ⠁ ⠙⠕⠕⠗⠤⠝⠁⠊⠇⠲
			
 
				+
			
 
				+  (The first couple of paragraphs of "A Christmas Carol" by Dickens)
			
 
				+
			
 
				+Compact font selection example text:
			
 
				+
			
 
				+  ABCDEFGHIJKLMNOPQRSTUVWXYZ /0123456789
			
 
				+  abcdefghijklmnopqrstuvwxyz £©µÀÆÖÞßéöÿ
			
 
				+  –—‘“”„†•…‰™œŠŸž€ ΑΒΓΔΩαβγδω АБВГДабвгд
			
 
				+  ∀∂∈ℝ∧∪≡∞ ↑↗↨↻⇣ ┐┼╔╘░►☺♀ ﬁ�⑀₂ἠḂӥẄɐː⍎אԱა
			
 
				+
			
 
				+Greetings in various languages:
			
 
				+
			
 
				+  Hello world, Καλημέρα κόσμε, コンニチハ
			
 
				+
			
 
				+Box drawing alignment tests:                                          █
			
 
				+                                                                      ▉
			
 
				+  ╔══╦══╗  ┌──┬──┐  ╭──┬──╮  ╭──┬──╮  ┏━━┳━━┓  ┎┒┏┑   ╷  ╻ ┏┯┓ ┌┰┐    ▊ ╱╲╱╲╳╳╳
			
 
				+  ║┌─╨─┐║  │╔═╧═╗│  │╒═╪═╕│  │╓─╁─╖│  ┃┌─╂─┐┃  ┗╃╄┙  ╶┼╴╺╋╸┠┼┨ ┝╋┥    ▋ ╲╱╲╱╳╳╳
			
 
				+  ║│╲ ╱│║  │║   ║│  ││ │ ││  │║ ┃ ║│  ┃│ ╿ │┃  ┍╅╆┓   ╵  ╹ ┗┷┛ └┸┘    ▌ ╱╲╱╲╳╳╳
			
 
				+  ╠╡ ╳ ╞╣  ├╢   ╟┤  ├┼─┼─┼┤  ├╫─╂─╫┤  ┣┿╾┼╼┿┫  ┕┛┖┚     ┌┄┄┐ ╎ ┏┅┅┓ ┋ ▍ ╲╱╲╱╳╳╳
			
 
				+  ║│╱ ╲│║  │║   ║│  ││ │ ││  │║ ┃ ║│  ┃│ ╽ │┃  ░░▒▒▓▓██ ┊  ┆ ╎ ╏  ┇ ┋ ▎
			
 
				+  ║└─╥─┘║  │╚═╤═╝│  │╘═╪═╛│  │╙─╀─╜│  ┃└─╂─┘┃  ░░▒▒▓▓██ ┊  ┆ ╎ ╏  ┇ ┋ ▏
			
 
				+  ╚══╩══╝  └──┴──┘  ╰──┴──╯  ╰──┴──╯  ┗━━┻━━┛  ▗▄▖▛▀▜   └╌╌┘ ╎ ┗╍╍┛ ┋  ▁▂▃▄▅▆▇█
			
 
				+                                               ▝▀▘▙▄▟
			
 
				+
			
 
				+Surrogates:
			
 
				+
			
 
				+𠜎 𠜱 𠝹 𠱓 𠱸 𠲖 𠳏 𠳕 𠴕 𠵼 𠵿 𠸎 𠸏 𠹷 𠺝 𠺢 𠻗 𠻹 𠻺 𠼭 𠼮 𠽌 𠾴 𠾼 𠿪 𡁜 𡁯 𡁵 𡁶 𡁻 𡃁
			
 
				+𡃉 𡇙 𢃇 𢞵 𢫕 𢭃 𢯊 𢱑 𢱕 𢳂 𢴈 𢵌 𢵧 𢺳 𣲷 𤓓 𤶸 𤷪 𥄫 𦉘 𦟌 𦧲 𦧺 𧨾 𨅝 𨈇 𨋢 𨳊 𨳍 𨳒 𩶘
			
--- a/Asistent/node_modules/@protobufjs/utf8/tests/index.js
+++ b/Asistent/node_modules/@protobufjs/utf8/tests/index.js
@@ -0,0 +1,57 @@
 
				+var tape = require("tape");
			
 
				+
			
 
				+var utf8 = require("..");
			
 
				+
			
 
				+var data = require("fs").readFileSync(require.resolve("./data/utf8.txt")),
			
 
				+    dataStr = data.toString("utf8");
			
 
				+
			
 
				+tape.test("utf8", function(test) {
			
 
				+
			
 
				+    test.test(test.name + " - length", function(test) {
			
 
				+        test.equal(utf8.length(""), 0, "should return a byte length of zero for an empty string");
			
 
				+
			
 
				+        test.equal(utf8.length(dataStr), Buffer.byteLength(dataStr), "should return the same byte length as node buffers");
			
 
				+
			
 
				+        test.end();
			
 
				+    });
			
 
				+
			
 
				+    test.test(test.name + " - read", function(test) {
			
 
				+        var comp = utf8.read([], 0, 0);
			
 
				+        test.equal(comp, "", "should decode an empty buffer to an empty string");
			
 
				+
			
 
				+        comp = utf8.read(data, 0, data.length);
			
 
				+        test.equal(comp, data.toString("utf8"), "should decode to the same byte data as node buffers");
			
 
				+
			
 
				+        var longData = Buffer.concat([data, data, data, data]);
			
 
				+        comp = utf8.read(longData, 0, longData.length);
			
 
				+        test.equal(comp, longData.toString("utf8"), "should decode to the same byte data as node buffers (long)");
			
 
				+
			
 
				+        var chunkData = new Buffer(data.toString("utf8").substring(0, 8192));
			
 
				+        comp = utf8.read(chunkData, 0, chunkData.length);
			
 
				+        test.equal(comp, chunkData.toString("utf8"), "should decode to the same byte data as node buffers (chunk size)");
			
 
				+
			
 
				+        test.end();
			
 
				+    });
			
 
				+
			
 
				+    test.test(test.name + " - write", function(test) {
			
 
				+        var buf = new Buffer(0);
			
 
				+        test.equal(utf8.write("", buf, 0), 0, "should encode an empty string to an empty buffer");
			
 
				+
			
 
				+        var len = utf8.length(dataStr);
			
 
				+        buf = new Buffer(len);
			
 
				+        test.equal(utf8.write(dataStr, buf, 0), len, "should encode to exactly " + len + " bytes");
			
 
				+
			
 
				+        test.equal(buf.length, data.length, "should encode to a buffer length equal to that of node buffers");
			
 
				+
			
 
				+        for (var i = 0; i < buf.length; ++i) {
			
 
				+            if (buf[i] !== data[i]) {
			
 
				+                test.fail("should encode to the same buffer data as node buffers (offset " + i + ")");
			
 
				+                return;
			
 
				+            }
			
 
				+        }
			
 
				+        test.pass("should encode to the same buffer data as node buffers");
			
 
				+
			
 
				+        test.end();
			
 
				+    });
			
 
				+
			
 
				+});
			
--- a/Asistent/node_modules/@types/node/LICENSE
+++ b/Asistent/node_modules/@types/node/LICENSE
@@ -0,0 +1,21 @@
 
				+    MIT License
			
 
				+
			
 
				+    Copyright (c) Microsoft Corporation.
			
 
				+
			
 
				+    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
			
--- a/Asistent/node_modules/@types/node/README.md
+++ b/Asistent/node_modules/@types/node/README.md
--- a/Asistent/node_modules/@types/node/assert.d.ts
+++ b/Asistent/node_modules/@types/node/assert.d.ts
@@ -0,0 +1,961 @@
 
				+/**
			
 
				+ * The `assert` module provides a set of assertion functions for verifying
			
 
				+ * invariants.
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/assert.js)
			
 
				+ */
			
 
				+declare module 'assert' {
			
 
				+    /**
			
 
				+     * An alias of {@link ok}.
			
 
				+     * @since v0.5.9
			
 
				+     * @param value The input that is checked for being truthy.
			
 
				+     */
			
 
				+    function assert(value: unknown, message?: string | Error): asserts value;
			
 
				+    namespace assert {
			
 
				+        /**
			
 
				+         * Indicates the failure of an assertion. All errors thrown by the `assert` module
			
 
				+         * will be instances of the `AssertionError` class.
			
 
				+         */
			
 
				+        class AssertionError extends Error {
			
 
				+            actual: unknown;
			
 
				+            expected: unknown;
			
 
				+            operator: string;
			
 
				+            generatedMessage: boolean;
			
 
				+            code: 'ERR_ASSERTION';
			
 
				+            constructor(options?: {
			
 
				+                /** If provided, the error message is set to this value. */
			
 
				+                message?: string | undefined;
			
 
				+                /** The `actual` property on the error instance. */
			
 
				+                actual?: unknown | undefined;
			
 
				+                /** The `expected` property on the error instance. */
			
 
				+                expected?: unknown | undefined;
			
 
				+                /** The `operator` property on the error instance. */
			
 
				+                operator?: string | undefined;
			
 
				+                /** If provided, the generated stack trace omits frames before this function. */
			
 
				+                // tslint:disable-next-line:ban-types
			
 
				+                stackStartFn?: Function | undefined;
			
 
				+            });
			
 
				+        }
			
 
				+        /**
			
 
				+         * This feature is currently experimental and behavior might still change.
			
 
				+         * @since v14.2.0, v12.19.0
			
 
				+         * @experimental
			
 
				+         */
			
 
				+        class CallTracker {
			
 
				+            /**
			
 
				+             * The wrapper function is expected to be called exactly `exact` times. If the
			
 
				+             * function has not been called exactly `exact` times when `tracker.verify()` is called, then `tracker.verify()` will throw an
			
 
				+             * error.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import assert from 'assert';
			
 
				+             *
			
 
				+             * // Creates call tracker.
			
 
				+             * const tracker = new assert.CallTracker();
			
 
				+             *
			
 
				+             * function func() {}
			
 
				+             *
			
 
				+             * // Returns a function that wraps func() that must be called exact times
			
 
				+             * // before tracker.verify().
			
 
				+             * const callsfunc = tracker.calls(func);
			
 
				+             * ```
			
 
				+             * @since v14.2.0, v12.19.0
			
 
				+             * @param [fn='A no-op function']
			
 
				+             * @param [exact=1]
			
 
				+             * @return that wraps `fn`.
			
 
				+             */
			
 
				+            calls(exact?: number): () => void;
			
 
				+            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
			
 
				+            /**
			
 
				+             * Example:
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import assert from 'node:assert';
			
 
				+             *
			
 
				+             * const tracker = new assert.CallTracker();
			
 
				+             *
			
 
				+             * function func() {}
			
 
				+             * const callsfunc = tracker.calls(func);
			
 
				+             * callsfunc(1, 2, 3);
			
 
				+             *
			
 
				+             * assert.deepStrictEqual(tracker.getCalls(callsfunc),
			
 
				+             *                        [{ thisArg: this, arguments: [1, 2, 3 ] }]);
			
 
				+             * ```
			
 
				+             *
			
 
				+             * @since v18.8.0, v16.18.0
			
 
				+             * @params fn
			
 
				+             * @returns An Array with the calls to a tracked function.
			
 
				+             */
			
 
				+            getCalls(fn: Function): CallTrackerCall[];
			
 
				+            /**
			
 
				+             * The arrays contains information about the expected and actual number of calls of
			
 
				+             * the functions that have not been called the expected number of times.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import assert from 'assert';
			
 
				+             *
			
 
				+             * // Creates call tracker.
			
 
				+             * const tracker = new assert.CallTracker();
			
 
				+             *
			
 
				+             * function func() {}
			
 
				+             *
			
 
				+             * function foo() {}
			
 
				+             *
			
 
				+             * // Returns a function that wraps func() that must be called exact times
			
 
				+             * // before tracker.verify().
			
 
				+             * const callsfunc = tracker.calls(func, 2);
			
 
				+             *
			
 
				+             * // Returns an array containing information on callsfunc()
			
 
				+             * tracker.report();
			
 
				+             * // [
			
 
				+             * //  {
			
 
				+             * //    message: 'Expected the func function to be executed 2 time(s) but was
			
 
				+             * //    executed 0 time(s).',
			
 
				+             * //    actual: 0,
			
 
				+             * //    expected: 2,
			
 
				+             * //    operator: 'func',
			
 
				+             * //    stack: stack trace
			
 
				+             * //  }
			
 
				+             * // ]
			
 
				+             * ```
			
 
				+             * @since v14.2.0, v12.19.0
			
 
				+             * @return of objects containing information about the wrapper functions returned by `calls`.
			
 
				+             */
			
 
				+            report(): CallTrackerReportInformation[];
			
 
				+            /**
			
 
				+             * Reset calls of the call tracker.
			
 
				+             * If a tracked function is passed as an argument, the calls will be reset for it.
			
 
				+             * If no arguments are passed, all tracked functions will be reset.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import assert from 'node:assert';
			
 
				+             *
			
 
				+             * const tracker = new assert.CallTracker();
			
 
				+             *
			
 
				+             * function func() {}
			
 
				+             * const callsfunc = tracker.calls(func);
			
 
				+             *
			
 
				+             * callsfunc();
			
 
				+             * // Tracker was called once
			
 
				+             * tracker.getCalls(callsfunc).length === 1;
			
 
				+             *
			
 
				+             * tracker.reset(callsfunc);
			
 
				+             * tracker.getCalls(callsfunc).length === 0;
			
 
				+             * ```
			
 
				+             *
			
 
				+             * @since v18.8.0, v16.18.0
			
 
				+             * @param fn a tracked function to reset.
			
 
				+             */
			
 
				+            reset(fn?: Function): void;
			
 
				+            /**
			
 
				+             * Iterates through the list of functions passed to `tracker.calls()` and will throw an error for functions that
			
 
				+             * have not been called the expected number of times.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import assert from 'assert';
			
 
				+             *
			
 
				+             * // Creates call tracker.
			
 
				+             * const tracker = new assert.CallTracker();
			
 
				+             *
			
 
				+             * function func() {}
			
 
				+             *
			
 
				+             * // Returns a function that wraps func() that must be called exact times
			
 
				+             * // before tracker.verify().
			
 
				+             * const callsfunc = tracker.calls(func, 2);
			
 
				+             *
			
 
				+             * callsfunc();
			
 
				+             *
			
 
				+             * // Will throw an error since callsfunc() was only called once.
			
 
				+             * tracker.verify();
			
 
				+             * ```
			
 
				+             * @since v14.2.0, v12.19.0
			
 
				+             */
			
 
				+            verify(): void;
			
 
				+        }
			
 
				+        interface CallTrackerCall {
			
 
				+            thisArg: object;
			
 
				+            arguments: unknown[];
			
 
				+        }
			
 
				+        interface CallTrackerReportInformation {
			
 
				+            message: string;
			
 
				+            /** The actual number of times the function was called. */
			
 
				+            actual: number;
			
 
				+            /** The number of times the function was expected to be called. */
			
 
				+            expected: number;
			
 
				+            /** The name of the function that is wrapped. */
			
 
				+            operator: string;
			
 
				+            /** A stack trace of the function. */
			
 
				+            stack: object;
			
 
				+        }
			
 
				+        type AssertPredicate = RegExp | (new () => object) | ((thrown: unknown) => boolean) | object | Error;
			
 
				+        /**
			
 
				+         * Throws an `AssertionError` with the provided error message or a default
			
 
				+         * error message. If the `message` parameter is an instance of an `Error` then
			
 
				+         * it will be thrown instead of the `AssertionError`.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.fail();
			
 
				+         * // AssertionError [ERR_ASSERTION]: Failed
			
 
				+         *
			
 
				+         * assert.fail('boom');
			
 
				+         * // AssertionError [ERR_ASSERTION]: boom
			
 
				+         *
			
 
				+         * assert.fail(new TypeError('need array'));
			
 
				+         * // TypeError: need array
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Using `assert.fail()` with more than two arguments is possible but deprecated.
			
 
				+         * See below for further details.
			
 
				+         * @since v0.1.21
			
 
				+         * @param [message='Failed']
			
 
				+         */
			
 
				+        function fail(message?: string | Error): never;
			
 
				+        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
			
 
				+        function fail(
			
 
				+            actual: unknown,
			
 
				+            expected: unknown,
			
 
				+            message?: string | Error,
			
 
				+            operator?: string,
			
 
				+            // tslint:disable-next-line:ban-types
			
 
				+            stackStartFn?: Function
			
 
				+        ): never;
			
 
				+        /**
			
 
				+         * Tests if `value` is truthy. It is equivalent to`assert.equal(!!value, true, message)`.
			
 
				+         *
			
 
				+         * If `value` is not truthy, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is `undefined`, a default
			
 
				+         * error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
			
 
				+         * If no arguments are passed in at all `message` will be set to the string:`` 'No value argument passed to `assert.ok()`' ``.
			
 
				+         *
			
 
				+         * Be aware that in the `repl` the error message will be different to the one
			
 
				+         * thrown in a file! See below for further details.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.ok(true);
			
 
				+         * // OK
			
 
				+         * assert.ok(1);
			
 
				+         * // OK
			
 
				+         *
			
 
				+         * assert.ok();
			
 
				+         * // AssertionError: No value argument passed to `assert.ok()`
			
 
				+         *
			
 
				+         * assert.ok(false, 'it\'s false');
			
 
				+         * // AssertionError: it's false
			
 
				+         *
			
 
				+         * // In the repl:
			
 
				+         * assert.ok(typeof 123 === 'string');
			
 
				+         * // AssertionError: false == true
			
 
				+         *
			
 
				+         * // In a file (e.g. test.js):
			
 
				+         * assert.ok(typeof 123 === 'string');
			
 
				+         * // AssertionError: The expression evaluated to a falsy value:
			
 
				+         * //
			
 
				+         * //   assert.ok(typeof 123 === 'string')
			
 
				+         *
			
 
				+         * assert.ok(false);
			
 
				+         * // AssertionError: The expression evaluated to a falsy value:
			
 
				+         * //
			
 
				+         * //   assert.ok(false)
			
 
				+         *
			
 
				+         * assert.ok(0);
			
 
				+         * // AssertionError: The expression evaluated to a falsy value:
			
 
				+         * //
			
 
				+         * //   assert.ok(0)
			
 
				+         * ```
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * // Using `assert()` works the same:
			
 
				+         * assert(0);
			
 
				+         * // AssertionError: The expression evaluated to a falsy value:
			
 
				+         * //
			
 
				+         * //   assert(0)
			
 
				+         * ```
			
 
				+         * @since v0.1.21
			
 
				+         */
			
 
				+        function ok(value: unknown, message?: string | Error): asserts value;
			
 
				+        /**
			
 
				+         * **Strict assertion mode**
			
 
				+         *
			
 
				+         * An alias of {@link strictEqual}.
			
 
				+         *
			
 
				+         * **Legacy assertion mode**
			
 
				+         *
			
 
				+         * > Stability: 3 - Legacy: Use {@link strictEqual} instead.
			
 
				+         *
			
 
				+         * Tests shallow, coercive equality between the `actual` and `expected` parameters
			
 
				+         * using the [`==` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality). `NaN` is specially handled
			
 
				+         * and treated as being identical if both sides are `NaN`.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert';
			
 
				+         *
			
 
				+         * assert.equal(1, 1);
			
 
				+         * // OK, 1 == 1
			
 
				+         * assert.equal(1, '1');
			
 
				+         * // OK, 1 == '1'
			
 
				+         * assert.equal(NaN, NaN);
			
 
				+         * // OK
			
 
				+         *
			
 
				+         * assert.equal(1, 2);
			
 
				+         * // AssertionError: 1 == 2
			
 
				+         * assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
			
 
				+         * // AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If the values are not equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default
			
 
				+         * error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
			
 
				+         * @since v0.1.21
			
 
				+         */
			
 
				+        function equal(actual: unknown, expected: unknown, message?: string | Error): void;
			
 
				+        /**
			
 
				+         * **Strict assertion mode**
			
 
				+         *
			
 
				+         * An alias of {@link notStrictEqual}.
			
 
				+         *
			
 
				+         * **Legacy assertion mode**
			
 
				+         *
			
 
				+         * > Stability: 3 - Legacy: Use {@link notStrictEqual} instead.
			
 
				+         *
			
 
				+         * Tests shallow, coercive inequality with the [`!=` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Inequality). `NaN` is
			
 
				+         * specially handled and treated as being identical if both sides are `NaN`.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert';
			
 
				+         *
			
 
				+         * assert.notEqual(1, 2);
			
 
				+         * // OK
			
 
				+         *
			
 
				+         * assert.notEqual(1, 1);
			
 
				+         * // AssertionError: 1 != 1
			
 
				+         *
			
 
				+         * assert.notEqual(1, '1');
			
 
				+         * // AssertionError: 1 != '1'
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If the values are equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default error
			
 
				+         * message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
			
 
				+         * @since v0.1.21
			
 
				+         */
			
 
				+        function notEqual(actual: unknown, expected: unknown, message?: string | Error): void;
			
 
				+        /**
			
 
				+         * **Strict assertion mode**
			
 
				+         *
			
 
				+         * An alias of {@link deepStrictEqual}.
			
 
				+         *
			
 
				+         * **Legacy assertion mode**
			
 
				+         *
			
 
				+         * > Stability: 3 - Legacy: Use {@link deepStrictEqual} instead.
			
 
				+         *
			
 
				+         * Tests for deep equality between the `actual` and `expected` parameters. Consider
			
 
				+         * using {@link deepStrictEqual} instead. {@link deepEqual} can have
			
 
				+         * surprising results.
			
 
				+         *
			
 
				+         * _Deep equality_ means that the enumerable "own" properties of child objects
			
 
				+         * are also recursively evaluated by the following rules.
			
 
				+         * @since v0.1.21
			
 
				+         */
			
 
				+        function deepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
			
 
				+        /**
			
 
				+         * **Strict assertion mode**
			
 
				+         *
			
 
				+         * An alias of {@link notDeepStrictEqual}.
			
 
				+         *
			
 
				+         * **Legacy assertion mode**
			
 
				+         *
			
 
				+         * > Stability: 3 - Legacy: Use {@link notDeepStrictEqual} instead.
			
 
				+         *
			
 
				+         * Tests for any deep inequality. Opposite of {@link deepEqual}.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert';
			
 
				+         *
			
 
				+         * const obj1 = {
			
 
				+         *   a: {
			
 
				+         *     b: 1
			
 
				+         *   }
			
 
				+         * };
			
 
				+         * const obj2 = {
			
 
				+         *   a: {
			
 
				+         *     b: 2
			
 
				+         *   }
			
 
				+         * };
			
 
				+         * const obj3 = {
			
 
				+         *   a: {
			
 
				+         *     b: 1
			
 
				+         *   }
			
 
				+         * };
			
 
				+         * const obj4 = Object.create(obj1);
			
 
				+         *
			
 
				+         * assert.notDeepEqual(obj1, obj1);
			
 
				+         * // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
			
 
				+         *
			
 
				+         * assert.notDeepEqual(obj1, obj2);
			
 
				+         * // OK
			
 
				+         *
			
 
				+         * assert.notDeepEqual(obj1, obj3);
			
 
				+         * // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
			
 
				+         *
			
 
				+         * assert.notDeepEqual(obj1, obj4);
			
 
				+         * // OK
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If the values are deeply equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a default
			
 
				+         * error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
			
 
				+         * instead of the `AssertionError`.
			
 
				+         * @since v0.1.21
			
 
				+         */
			
 
				+        function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
			
 
				+        /**
			
 
				+         * Tests strict equality between the `actual` and `expected` parameters as
			
 
				+         * determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.strictEqual(1, 2);
			
 
				+         * // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
			
 
				+         * //
			
 
				+         * // 1 !== 2
			
 
				+         *
			
 
				+         * assert.strictEqual(1, 1);
			
 
				+         * // OK
			
 
				+         *
			
 
				+         * assert.strictEqual('Hello foobar', 'Hello World!');
			
 
				+         * // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
			
 
				+         * // + actual - expected
			
 
				+         * //
			
 
				+         * // + 'Hello foobar'
			
 
				+         * // - 'Hello World!'
			
 
				+         * //          ^
			
 
				+         *
			
 
				+         * const apples = 1;
			
 
				+         * const oranges = 2;
			
 
				+         * assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);
			
 
				+         * // AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2
			
 
				+         *
			
 
				+         * assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
			
 
				+         * // TypeError: Inputs are not identical
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If the values are not strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a
			
 
				+         * default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
			
 
				+         * instead of the `AssertionError`.
			
 
				+         * @since v0.1.21
			
 
				+         */
			
 
				+        function strictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
			
 
				+        /**
			
 
				+         * Tests strict inequality between the `actual` and `expected` parameters as
			
 
				+         * determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.notStrictEqual(1, 2);
			
 
				+         * // OK
			
 
				+         *
			
 
				+         * assert.notStrictEqual(1, 1);
			
 
				+         * // AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
			
 
				+         * //
			
 
				+         * // 1
			
 
				+         *
			
 
				+         * assert.notStrictEqual(1, '1');
			
 
				+         * // OK
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If the values are strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a
			
 
				+         * default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
			
 
				+         * instead of the `AssertionError`.
			
 
				+         * @since v0.1.21
			
 
				+         */
			
 
				+        function notStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
			
 
				+        /**
			
 
				+         * Tests for deep equality between the `actual` and `expected` parameters.
			
 
				+         * "Deep" equality means that the enumerable "own" properties of child objects
			
 
				+         * are recursively evaluated also by the following rules.
			
 
				+         * @since v1.2.0
			
 
				+         */
			
 
				+        function deepStrictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
			
 
				+        /**
			
 
				+         * Tests for deep strict inequality. Opposite of {@link deepStrictEqual}.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
			
 
				+         * // OK
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If the values are deeply and strictly equal, an `AssertionError` is thrown
			
 
				+         * with a `message` property set equal to the value of the `message` parameter. If
			
 
				+         * the `message` parameter is undefined, a default error message is assigned. If
			
 
				+         * the `message` parameter is an instance of an `Error` then it will be thrown
			
 
				+         * instead of the `AssertionError`.
			
 
				+         * @since v1.2.0
			
 
				+         */
			
 
				+        function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
			
 
				+        /**
			
 
				+         * Expects the function `fn` to throw an error.
			
 
				+         *
			
 
				+         * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
			
 
				+         * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,
			
 
				+         * a validation object where each property will be tested for strict deep equality,
			
 
				+         * or an instance of error where each property will be tested for strict deep
			
 
				+         * equality including the non-enumerable `message` and `name` properties. When
			
 
				+         * using an object, it is also possible to use a regular expression, when
			
 
				+         * validating against a string property. See below for examples.
			
 
				+         *
			
 
				+         * If specified, `message` will be appended to the message provided by the`AssertionError` if the `fn` call fails to throw or in case the error validation
			
 
				+         * fails.
			
 
				+         *
			
 
				+         * Custom validation object/error instance:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * const err = new TypeError('Wrong value');
			
 
				+         * err.code = 404;
			
 
				+         * err.foo = 'bar';
			
 
				+         * err.info = {
			
 
				+         *   nested: true,
			
 
				+         *   baz: 'text'
			
 
				+         * };
			
 
				+         * err.reg = /abc/i;
			
 
				+         *
			
 
				+         * assert.throws(
			
 
				+         *   () => {
			
 
				+         *     throw err;
			
 
				+         *   },
			
 
				+         *   {
			
 
				+         *     name: 'TypeError',
			
 
				+         *     message: 'Wrong value',
			
 
				+         *     info: {
			
 
				+         *       nested: true,
			
 
				+         *       baz: 'text'
			
 
				+         *     }
			
 
				+         *     // Only properties on the validation object will be tested for.
			
 
				+         *     // Using nested objects requires all properties to be present. Otherwise
			
 
				+         *     // the validation is going to fail.
			
 
				+         *   }
			
 
				+         * );
			
 
				+         *
			
 
				+         * // Using regular expressions to validate error properties:
			
 
				+         * throws(
			
 
				+         *   () => {
			
 
				+         *     throw err;
			
 
				+         *   },
			
 
				+         *   {
			
 
				+         *     // The `name` and `message` properties are strings and using regular
			
 
				+         *     // expressions on those will match against the string. If they fail, an
			
 
				+         *     // error is thrown.
			
 
				+         *     name: /^TypeError$/,
			
 
				+         *     message: /Wrong/,
			
 
				+         *     foo: 'bar',
			
 
				+         *     info: {
			
 
				+         *       nested: true,
			
 
				+         *       // It is not possible to use regular expressions for nested properties!
			
 
				+         *       baz: 'text'
			
 
				+         *     },
			
 
				+         *     // The `reg` property contains a regular expression and only if the
			
 
				+         *     // validation object contains an identical regular expression, it is going
			
 
				+         *     // to pass.
			
 
				+         *     reg: /abc/i
			
 
				+         *   }
			
 
				+         * );
			
 
				+         *
			
 
				+         * // Fails due to the different `message` and `name` properties:
			
 
				+         * throws(
			
 
				+         *   () => {
			
 
				+         *     const otherErr = new Error('Not found');
			
 
				+         *     // Copy all enumerable properties from `err` to `otherErr`.
			
 
				+         *     for (const [key, value] of Object.entries(err)) {
			
 
				+         *       otherErr[key] = value;
			
 
				+         *     }
			
 
				+         *     throw otherErr;
			
 
				+         *   },
			
 
				+         *   // The error's `message` and `name` properties will also be checked when using
			
 
				+         *   // an error as validation object.
			
 
				+         *   err
			
 
				+         * );
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Validate instanceof using constructor:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.throws(
			
 
				+         *   () => {
			
 
				+         *     throw new Error('Wrong value');
			
 
				+         *   },
			
 
				+         *   Error
			
 
				+         * );
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Validate error message using [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions):
			
 
				+         *
			
 
				+         * Using a regular expression runs `.toString` on the error object, and will
			
 
				+         * therefore also include the error name.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.throws(
			
 
				+         *   () => {
			
 
				+         *     throw new Error('Wrong value');
			
 
				+         *   },
			
 
				+         *   /^Error: Wrong value$/
			
 
				+         * );
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Custom error validation:
			
 
				+         *
			
 
				+         * The function must return `true` to indicate all internal validations passed.
			
 
				+         * It will otherwise fail with an `AssertionError`.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.throws(
			
 
				+         *   () => {
			
 
				+         *     throw new Error('Wrong value');
			
 
				+         *   },
			
 
				+         *   (err) => {
			
 
				+         *     assert(err instanceof Error);
			
 
				+         *     assert(/value/.test(err));
			
 
				+         *     // Avoid returning anything from validation functions besides `true`.
			
 
				+         *     // Otherwise, it's not clear what part of the validation failed. Instead,
			
 
				+         *     // throw an error about the specific validation that failed (as done in this
			
 
				+         *     // example) and add as much helpful debugging information to that error as
			
 
				+         *     // possible.
			
 
				+         *     return true;
			
 
				+         *   },
			
 
				+         *   'unexpected error'
			
 
				+         * );
			
 
				+         * ```
			
 
				+         *
			
 
				+         * `error` cannot be a string. If a string is provided as the second
			
 
				+         * argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Using the same
			
 
				+         * message as the thrown error message is going to result in an`ERR_AMBIGUOUS_ARGUMENT` error. Please read the example below carefully if using
			
 
				+         * a string as the second argument gets considered:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * function throwingFirst() {
			
 
				+         *   throw new Error('First');
			
 
				+         * }
			
 
				+         *
			
 
				+         * function throwingSecond() {
			
 
				+         *   throw new Error('Second');
			
 
				+         * }
			
 
				+         *
			
 
				+         * function notThrowing() {}
			
 
				+         *
			
 
				+         * // The second argument is a string and the input function threw an Error.
			
 
				+         * // The first case will not throw as it does not match for the error message
			
 
				+         * // thrown by the input function!
			
 
				+         * assert.throws(throwingFirst, 'Second');
			
 
				+         * // In the next example the message has no benefit over the message from the
			
 
				+         * // error and since it is not clear if the user intended to actually match
			
 
				+         * // against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
			
 
				+         * assert.throws(throwingSecond, 'Second');
			
 
				+         * // TypeError [ERR_AMBIGUOUS_ARGUMENT]
			
 
				+         *
			
 
				+         * // The string is only used (as message) in case the function does not throw:
			
 
				+         * assert.throws(notThrowing, 'Second');
			
 
				+         * // AssertionError [ERR_ASSERTION]: Missing expected exception: Second
			
 
				+         *
			
 
				+         * // If it was intended to match for the error message do this instead:
			
 
				+         * // It does not throw because the error messages match.
			
 
				+         * assert.throws(throwingSecond, /Second$/);
			
 
				+         *
			
 
				+         * // If the error message does not match, an AssertionError is thrown.
			
 
				+         * assert.throws(throwingFirst, /Second$/);
			
 
				+         * // AssertionError [ERR_ASSERTION]
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Due to the confusing error-prone notation, avoid a string as the second
			
 
				+         * argument.
			
 
				+         * @since v0.1.21
			
 
				+         */
			
 
				+        function throws(block: () => unknown, message?: string | Error): void;
			
 
				+        function throws(block: () => unknown, error: AssertPredicate, message?: string | Error): void;
			
 
				+        /**
			
 
				+         * Asserts that the function `fn` does not throw an error.
			
 
				+         *
			
 
				+         * Using `assert.doesNotThrow()` is actually not useful because there
			
 
				+         * is no benefit in catching an error and then rethrowing it. Instead, consider
			
 
				+         * adding a comment next to the specific code path that should not throw and keep
			
 
				+         * error messages as expressive as possible.
			
 
				+         *
			
 
				+         * When `assert.doesNotThrow()` is called, it will immediately call the `fn`function.
			
 
				+         *
			
 
				+         * If an error is thrown and it is the same type as that specified by the `error`parameter, then an `AssertionError` is thrown. If the error is of a
			
 
				+         * different type, or if the `error` parameter is undefined, the error is
			
 
				+         * propagated back to the caller.
			
 
				+         *
			
 
				+         * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
			
 
				+         * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) or a validation
			
 
				+         * function. See {@link throws} for more details.
			
 
				+         *
			
 
				+         * The following, for instance, will throw the `TypeError` because there is no
			
 
				+         * matching error type in the assertion:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.doesNotThrow(
			
 
				+         *   () => {
			
 
				+         *     throw new TypeError('Wrong value');
			
 
				+         *   },
			
 
				+         *   SyntaxError
			
 
				+         * );
			
 
				+         * ```
			
 
				+         *
			
 
				+         * However, the following will result in an `AssertionError` with the message
			
 
				+         * 'Got unwanted exception...':
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.doesNotThrow(
			
 
				+         *   () => {
			
 
				+         *     throw new TypeError('Wrong value');
			
 
				+         *   },
			
 
				+         *   TypeError
			
 
				+         * );
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If an `AssertionError` is thrown and a value is provided for the `message`parameter, the value of `message` will be appended to the `AssertionError` message:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.doesNotThrow(
			
 
				+         *   () => {
			
 
				+         *     throw new TypeError('Wrong value');
			
 
				+         *   },
			
 
				+         *   /Wrong value/,
			
 
				+         *   'Whoops'
			
 
				+         * );
			
 
				+         * // Throws: AssertionError: Got unwanted exception: Whoops
			
 
				+         * ```
			
 
				+         * @since v0.1.21
			
 
				+         */
			
 
				+        function doesNotThrow(block: () => unknown, message?: string | Error): void;
			
 
				+        function doesNotThrow(block: () => unknown, error: AssertPredicate, message?: string | Error): void;
			
 
				+        /**
			
 
				+         * Throws `value` if `value` is not `undefined` or `null`. This is useful when
			
 
				+         * testing the `error` argument in callbacks. The stack trace contains all frames
			
 
				+         * from the error passed to `ifError()` including the potential new frames for`ifError()` itself.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.ifError(null);
			
 
				+         * // OK
			
 
				+         * assert.ifError(0);
			
 
				+         * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
			
 
				+         * assert.ifError('error');
			
 
				+         * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
			
 
				+         * assert.ifError(new Error());
			
 
				+         * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error
			
 
				+         *
			
 
				+         * // Create some random error frames.
			
 
				+         * let err;
			
 
				+         * (function errorFrame() {
			
 
				+         *   err = new Error('test error');
			
 
				+         * })();
			
 
				+         *
			
 
				+         * (function ifErrorFrame() {
			
 
				+         *   assert.ifError(err);
			
 
				+         * })();
			
 
				+         * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
			
 
				+         * //     at ifErrorFrame
			
 
				+         * //     at errorFrame
			
 
				+         * ```
			
 
				+         * @since v0.1.97
			
 
				+         */
			
 
				+        function ifError(value: unknown): asserts value is null | undefined;
			
 
				+        /**
			
 
				+         * Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately
			
 
				+         * calls the function and awaits the returned promise to complete. It will then
			
 
				+         * check that the promise is rejected.
			
 
				+         *
			
 
				+         * If `asyncFn` is a function and it throws an error synchronously,`assert.rejects()` will return a rejected `Promise` with that error. If the
			
 
				+         * function does not return a promise, `assert.rejects()` will return a rejected`Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases the error
			
 
				+         * handler is skipped.
			
 
				+         *
			
 
				+         * Besides the async nature to await the completion behaves identically to {@link throws}.
			
 
				+         *
			
 
				+         * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
			
 
				+         * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,
			
 
				+         * an object where each property will be tested for, or an instance of error where
			
 
				+         * each property will be tested for including the non-enumerable `message` and`name` properties.
			
 
				+         *
			
 
				+         * If specified, `message` will be the message provided by the `AssertionError` if the `asyncFn` fails to reject.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * await assert.rejects(
			
 
				+         *   async () => {
			
 
				+         *     throw new TypeError('Wrong value');
			
 
				+         *   },
			
 
				+         *   {
			
 
				+         *     name: 'TypeError',
			
 
				+         *     message: 'Wrong value'
			
 
				+         *   }
			
 
				+         * );
			
 
				+         * ```
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * await assert.rejects(
			
 
				+         *   async () => {
			
 
				+         *     throw new TypeError('Wrong value');
			
 
				+         *   },
			
 
				+         *   (err) => {
			
 
				+         *     assert.strictEqual(err.name, 'TypeError');
			
 
				+         *     assert.strictEqual(err.message, 'Wrong value');
			
 
				+         *     return true;
			
 
				+         *   }
			
 
				+         * );
			
 
				+         * ```
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.rejects(
			
 
				+         *   Promise.reject(new Error('Wrong value')),
			
 
				+         *   Error
			
 
				+         * ).then(() => {
			
 
				+         *   // ...
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * `error` cannot be a string. If a string is provided as the second
			
 
				+         * argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Please read the
			
 
				+         * example in {@link throws} carefully if using a string as the second
			
 
				+         * argument gets considered.
			
 
				+         * @since v10.0.0
			
 
				+         */
			
 
				+        function rejects(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
			
 
				+        function rejects(block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: string | Error): Promise<void>;
			
 
				+        /**
			
 
				+         * Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately
			
 
				+         * calls the function and awaits the returned promise to complete. It will then
			
 
				+         * check that the promise is not rejected.
			
 
				+         *
			
 
				+         * If `asyncFn` is a function and it throws an error synchronously,`assert.doesNotReject()` will return a rejected `Promise` with that error. If
			
 
				+         * the function does not return a promise, `assert.doesNotReject()` will return a
			
 
				+         * rejected `Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases
			
 
				+         * the error handler is skipped.
			
 
				+         *
			
 
				+         * Using `assert.doesNotReject()` is actually not useful because there is little
			
 
				+         * benefit in catching a rejection and then rejecting it again. Instead, consider
			
 
				+         * adding a comment next to the specific code path that should not reject and keep
			
 
				+         * error messages as expressive as possible.
			
 
				+         *
			
 
				+         * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
			
 
				+         * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) or a validation
			
 
				+         * function. See {@link throws} for more details.
			
 
				+         *
			
 
				+         * Besides the async nature to await the completion behaves identically to {@link doesNotThrow}.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * await assert.doesNotReject(
			
 
				+         *   async () => {
			
 
				+         *     throw new TypeError('Wrong value');
			
 
				+         *   },
			
 
				+         *   SyntaxError
			
 
				+         * );
			
 
				+         * ```
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
			
 
				+         *   .then(() => {
			
 
				+         *     // ...
			
 
				+         *   });
			
 
				+         * ```
			
 
				+         * @since v10.0.0
			
 
				+         */
			
 
				+        function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
			
 
				+        function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: string | Error): Promise<void>;
			
 
				+        /**
			
 
				+         * Expects the `string` input to match the regular expression.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.match('I will fail', /pass/);
			
 
				+         * // AssertionError [ERR_ASSERTION]: The input did not match the regular ...
			
 
				+         *
			
 
				+         * assert.match(123, /pass/);
			
 
				+         * // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
			
 
				+         *
			
 
				+         * assert.match('I will pass', /pass/);
			
 
				+         * // OK
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If the values do not match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal
			
 
				+         * to the value of the `message` parameter. If the `message` parameter is
			
 
				+         * undefined, a default error message is assigned. If the `message` parameter is an
			
 
				+         * instance of an `Error` then it will be thrown instead of the `AssertionError`.
			
 
				+         * @since v13.6.0, v12.16.0
			
 
				+         */
			
 
				+        function match(value: string, regExp: RegExp, message?: string | Error): void;
			
 
				+        /**
			
 
				+         * Expects the `string` input not to match the regular expression.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import assert from 'assert/strict';
			
 
				+         *
			
 
				+         * assert.doesNotMatch('I will fail', /fail/);
			
 
				+         * // AssertionError [ERR_ASSERTION]: The input was expected to not match the ...
			
 
				+         *
			
 
				+         * assert.doesNotMatch(123, /pass/);
			
 
				+         * // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
			
 
				+         *
			
 
				+         * assert.doesNotMatch('I will pass', /different/);
			
 
				+         * // OK
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If the values do match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal
			
 
				+         * to the value of the `message` parameter. If the `message` parameter is
			
 
				+         * undefined, a default error message is assigned. If the `message` parameter is an
			
 
				+         * instance of an `Error` then it will be thrown instead of the `AssertionError`.
			
 
				+         * @since v13.6.0, v12.16.0
			
 
				+         */
			
 
				+        function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
			
 
				+        const strict: Omit<typeof assert, 'equal' | 'notEqual' | 'deepEqual' | 'notDeepEqual' | 'ok' | 'strictEqual' | 'deepStrictEqual' | 'ifError' | 'strict'> & {
			
 
				+            (value: unknown, message?: string | Error): asserts value;
			
 
				+            equal: typeof strictEqual;
			
 
				+            notEqual: typeof notStrictEqual;
			
 
				+            deepEqual: typeof deepStrictEqual;
			
 
				+            notDeepEqual: typeof notDeepStrictEqual;
			
 
				+            // Mapped types and assertion functions are incompatible?
			
 
				+            // TS2775: Assertions require every name in the call target
			
 
				+            // to be declared with an explicit type annotation.
			
 
				+            ok: typeof ok;
			
 
				+            strictEqual: typeof strictEqual;
			
 
				+            deepStrictEqual: typeof deepStrictEqual;
			
 
				+            ifError: typeof ifError;
			
 
				+            strict: typeof strict;
			
 
				+        };
			
 
				+    }
			
 
				+    export = assert;
			
 
				+}
			
 
				+declare module 'node:assert' {
			
 
				+    import assert = require('assert');
			
 
				+    export = assert;
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/assert/strict.d.ts
+++ b/Asistent/node_modules/@types/node/assert/strict.d.ts
@@ -0,0 +1,8 @@
 
				+declare module 'assert/strict' {
			
 
				+    import { strict } from 'node:assert';
			
 
				+    export = strict;
			
 
				+}
			
 
				+declare module 'node:assert/strict' {
			
 
				+    import { strict } from 'node:assert';
			
 
				+    export = strict;
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/async_hooks.d.ts
+++ b/Asistent/node_modules/@types/node/async_hooks.d.ts
@@ -0,0 +1,513 @@
 
				+/**
			
 
				+ * The `async_hooks` module provides an API to track asynchronous resources. It
			
 
				+ * can be accessed using:
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * import async_hooks from 'async_hooks';
			
 
				+ * ```
			
 
				+ * @experimental
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/async_hooks.js)
			
 
				+ */
			
 
				+declare module 'async_hooks' {
			
 
				+    /**
			
 
				+     * ```js
			
 
				+     * import { executionAsyncId } from 'async_hooks';
			
 
				+     *
			
 
				+     * console.log(executionAsyncId());  // 1 - bootstrap
			
 
				+     * fs.open(path, 'r', (err, fd) => {
			
 
				+     *   console.log(executionAsyncId());  // 6 - open()
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The ID returned from `executionAsyncId()` is related to execution timing, not
			
 
				+     * causality (which is covered by `triggerAsyncId()`):
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const server = net.createServer((conn) => {
			
 
				+     *   // Returns the ID of the server, not of the new connection, because the
			
 
				+     *   // callback runs in the execution scope of the server's MakeCallback().
			
 
				+     *   async_hooks.executionAsyncId();
			
 
				+     *
			
 
				+     * }).listen(port, () => {
			
 
				+     *   // Returns the ID of a TickObject (process.nextTick()) because all
			
 
				+     *   // callbacks passed to .listen() are wrapped in a nextTick().
			
 
				+     *   async_hooks.executionAsyncId();
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Promise contexts may not get precise `executionAsyncIds` by default.
			
 
				+     * See the section on `promise execution tracking`.
			
 
				+     * @since v8.1.0
			
 
				+     * @return The `asyncId` of the current execution context. Useful to track when something calls.
			
 
				+     */
			
 
				+    function executionAsyncId(): number;
			
 
				+    /**
			
 
				+     * Resource objects returned by `executionAsyncResource()` are most often internal
			
 
				+     * Node.js handle objects with undocumented APIs. Using any functions or properties
			
 
				+     * on the object is likely to crash your application and should be avoided.
			
 
				+     *
			
 
				+     * Using `executionAsyncResource()` in the top-level execution context will
			
 
				+     * return an empty object as there is no handle or request object to use,
			
 
				+     * but having an object representing the top-level can be helpful.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { open } from 'fs';
			
 
				+     * import { executionAsyncId, executionAsyncResource } from 'async_hooks';
			
 
				+     *
			
 
				+     * console.log(executionAsyncId(), executionAsyncResource());  // 1 {}
			
 
				+     * open(new URL(import.meta.url), 'r', (err, fd) => {
			
 
				+     *   console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * This can be used to implement continuation local storage without the
			
 
				+     * use of a tracking `Map` to store the metadata:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { createServer } from 'http';
			
 
				+     * import {
			
 
				+     *   executionAsyncId,
			
 
				+     *   executionAsyncResource,
			
 
				+     *   createHook
			
 
				+     * } from 'async_hooks';
			
 
				+     * const sym = Symbol('state'); // Private symbol to avoid pollution
			
 
				+     *
			
 
				+     * createHook({
			
 
				+     *   init(asyncId, type, triggerAsyncId, resource) {
			
 
				+     *     const cr = executionAsyncResource();
			
 
				+     *     if (cr) {
			
 
				+     *       resource[sym] = cr[sym];
			
 
				+     *     }
			
 
				+     *   }
			
 
				+     * }).enable();
			
 
				+     *
			
 
				+     * const server = createServer((req, res) => {
			
 
				+     *   executionAsyncResource()[sym] = { state: req.url };
			
 
				+     *   setTimeout(function() {
			
 
				+     *     res.end(JSON.stringify(executionAsyncResource()[sym]));
			
 
				+     *   }, 100);
			
 
				+     * }).listen(3000);
			
 
				+     * ```
			
 
				+     * @since v13.9.0, v12.17.0
			
 
				+     * @return The resource representing the current execution. Useful to store data within the resource.
			
 
				+     */
			
 
				+    function executionAsyncResource(): object;
			
 
				+    /**
			
 
				+     * ```js
			
 
				+     * const server = net.createServer((conn) => {
			
 
				+     *   // The resource that caused (or triggered) this callback to be called
			
 
				+     *   // was that of the new connection. Thus the return value of triggerAsyncId()
			
 
				+     *   // is the asyncId of "conn".
			
 
				+     *   async_hooks.triggerAsyncId();
			
 
				+     *
			
 
				+     * }).listen(port, () => {
			
 
				+     *   // Even though all callbacks passed to .listen() are wrapped in a nextTick()
			
 
				+     *   // the callback itself exists because the call to the server's .listen()
			
 
				+     *   // was made. So the return value would be the ID of the server.
			
 
				+     *   async_hooks.triggerAsyncId();
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Promise contexts may not get valid `triggerAsyncId`s by default. See
			
 
				+     * the section on `promise execution tracking`.
			
 
				+     * @return The ID of the resource responsible for calling the callback that is currently being executed.
			
 
				+     */
			
 
				+    function triggerAsyncId(): number;
			
 
				+    interface HookCallbacks {
			
 
				+        /**
			
 
				+         * Called when a class is constructed that has the possibility to emit an asynchronous event.
			
 
				+         * @param asyncId a unique ID for the async resource
			
 
				+         * @param type the type of the async resource
			
 
				+         * @param triggerAsyncId the unique ID of the async resource in whose execution context this async resource was created
			
 
				+         * @param resource reference to the resource representing the async operation, needs to be released during destroy
			
 
				+         */
			
 
				+        init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
			
 
				+        /**
			
 
				+         * When an asynchronous operation is initiated or completes a callback is called to notify the user.
			
 
				+         * The before callback is called just before said callback is executed.
			
 
				+         * @param asyncId the unique identifier assigned to the resource about to execute the callback.
			
 
				+         */
			
 
				+        before?(asyncId: number): void;
			
 
				+        /**
			
 
				+         * Called immediately after the callback specified in before is completed.
			
 
				+         * @param asyncId the unique identifier assigned to the resource which has executed the callback.
			
 
				+         */
			
 
				+        after?(asyncId: number): void;
			
 
				+        /**
			
 
				+         * Called when a promise has resolve() called. This may not be in the same execution id
			
 
				+         * as the promise itself.
			
 
				+         * @param asyncId the unique id for the promise that was resolve()d.
			
 
				+         */
			
 
				+        promiseResolve?(asyncId: number): void;
			
 
				+        /**
			
 
				+         * Called after the resource corresponding to asyncId is destroyed
			
 
				+         * @param asyncId a unique ID for the async resource
			
 
				+         */
			
 
				+        destroy?(asyncId: number): void;
			
 
				+    }
			
 
				+    interface AsyncHook {
			
 
				+        /**
			
 
				+         * Enable the callbacks for a given AsyncHook instance. If no callbacks are provided enabling is a noop.
			
 
				+         */
			
 
				+        enable(): this;
			
 
				+        /**
			
 
				+         * Disable the callbacks for a given AsyncHook instance from the global pool of AsyncHook callbacks to be executed. Once a hook has been disabled it will not be called again until enabled.
			
 
				+         */
			
 
				+        disable(): this;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Registers functions to be called for different lifetime events of each async
			
 
				+     * operation.
			
 
				+     *
			
 
				+     * The callbacks `init()`/`before()`/`after()`/`destroy()` are called for the
			
 
				+     * respective asynchronous event during a resource's lifetime.
			
 
				+     *
			
 
				+     * All callbacks are optional. For example, if only resource cleanup needs to
			
 
				+     * be tracked, then only the `destroy` callback needs to be passed. The
			
 
				+     * specifics of all functions that can be passed to `callbacks` is in the `Hook Callbacks` section.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { createHook } from 'async_hooks';
			
 
				+     *
			
 
				+     * const asyncHook = createHook({
			
 
				+     *   init(asyncId, type, triggerAsyncId, resource) { },
			
 
				+     *   destroy(asyncId) { }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The callbacks will be inherited via the prototype chain:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * class MyAsyncCallbacks {
			
 
				+     *   init(asyncId, type, triggerAsyncId, resource) { }
			
 
				+     *   destroy(asyncId) {}
			
 
				+     * }
			
 
				+     *
			
 
				+     * class MyAddedCallbacks extends MyAsyncCallbacks {
			
 
				+     *   before(asyncId) { }
			
 
				+     *   after(asyncId) { }
			
 
				+     * }
			
 
				+     *
			
 
				+     * const asyncHook = async_hooks.createHook(new MyAddedCallbacks());
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Because promises are asynchronous resources whose lifecycle is tracked
			
 
				+     * via the async hooks mechanism, the `init()`, `before()`, `after()`, and`destroy()` callbacks _must not_ be async functions that return promises.
			
 
				+     * @since v8.1.0
			
 
				+     * @param callbacks The `Hook Callbacks` to register
			
 
				+     * @return Instance used for disabling and enabling hooks
			
 
				+     */
			
 
				+    function createHook(callbacks: HookCallbacks): AsyncHook;
			
 
				+    interface AsyncResourceOptions {
			
 
				+        /**
			
 
				+         * The ID of the execution context that created this async event.
			
 
				+         * @default executionAsyncId()
			
 
				+         */
			
 
				+        triggerAsyncId?: number | undefined;
			
 
				+        /**
			
 
				+         * Disables automatic `emitDestroy` when the object is garbage collected.
			
 
				+         * This usually does not need to be set (even if `emitDestroy` is called
			
 
				+         * manually), unless the resource's `asyncId` is retrieved and the
			
 
				+         * sensitive API's `emitDestroy` is called with it.
			
 
				+         * @default false
			
 
				+         */
			
 
				+        requireManualDestroy?: boolean | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * The class `AsyncResource` is designed to be extended by the embedder's async
			
 
				+     * resources. Using this, users can easily trigger the lifetime events of their
			
 
				+     * own resources.
			
 
				+     *
			
 
				+     * The `init` hook will trigger when an `AsyncResource` is instantiated.
			
 
				+     *
			
 
				+     * The following is an overview of the `AsyncResource` API.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { AsyncResource, executionAsyncId } from 'async_hooks';
			
 
				+     *
			
 
				+     * // AsyncResource() is meant to be extended. Instantiating a
			
 
				+     * // new AsyncResource() also triggers init. If triggerAsyncId is omitted then
			
 
				+     * // async_hook.executionAsyncId() is used.
			
 
				+     * const asyncResource = new AsyncResource(
			
 
				+     *   type, { triggerAsyncId: executionAsyncId(), requireManualDestroy: false }
			
 
				+     * );
			
 
				+     *
			
 
				+     * // Run a function in the execution context of the resource. This will
			
 
				+     * // * establish the context of the resource
			
 
				+     * // * trigger the AsyncHooks before callbacks
			
 
				+     * // * call the provided function `fn` with the supplied arguments
			
 
				+     * // * trigger the AsyncHooks after callbacks
			
 
				+     * // * restore the original execution context
			
 
				+     * asyncResource.runInAsyncScope(fn, thisArg, ...args);
			
 
				+     *
			
 
				+     * // Call AsyncHooks destroy callbacks.
			
 
				+     * asyncResource.emitDestroy();
			
 
				+     *
			
 
				+     * // Return the unique ID assigned to the AsyncResource instance.
			
 
				+     * asyncResource.asyncId();
			
 
				+     *
			
 
				+     * // Return the trigger ID for the AsyncResource instance.
			
 
				+     * asyncResource.triggerAsyncId();
			
 
				+     * ```
			
 
				+     */
			
 
				+    class AsyncResource {
			
 
				+        /**
			
 
				+         * AsyncResource() is meant to be extended. Instantiating a
			
 
				+         * new AsyncResource() also triggers init. If triggerAsyncId is omitted then
			
 
				+         * async_hook.executionAsyncId() is used.
			
 
				+         * @param type The type of async event.
			
 
				+         * @param triggerAsyncId The ID of the execution context that created
			
 
				+         *   this async event (default: `executionAsyncId()`), or an
			
 
				+         *   AsyncResourceOptions object (since v9.3.0)
			
 
				+         */
			
 
				+        constructor(type: string, triggerAsyncId?: number | AsyncResourceOptions);
			
 
				+        /**
			
 
				+         * Binds the given function to the current execution context.
			
 
				+         *
			
 
				+         * The returned function will have an `asyncResource` property referencing
			
 
				+         * the `AsyncResource` to which the function is bound.
			
 
				+         * @since v14.8.0, v12.19.0
			
 
				+         * @param fn The function to bind to the current execution context.
			
 
				+         * @param type An optional name to associate with the underlying `AsyncResource`.
			
 
				+         */
			
 
				+        static bind<Func extends (this: ThisArg, ...args: any[]) => any, ThisArg>(
			
 
				+            fn: Func,
			
 
				+            type?: string,
			
 
				+            thisArg?: ThisArg
			
 
				+        ): Func & {
			
 
				+            asyncResource: AsyncResource;
			
 
				+        };
			
 
				+        /**
			
 
				+         * Binds the given function to execute to this `AsyncResource`'s scope.
			
 
				+         *
			
 
				+         * The returned function will have an `asyncResource` property referencing
			
 
				+         * the `AsyncResource` to which the function is bound.
			
 
				+         * @since v14.8.0, v12.19.0
			
 
				+         * @param fn The function to bind to the current `AsyncResource`.
			
 
				+         */
			
 
				+        bind<Func extends (...args: any[]) => any>(
			
 
				+            fn: Func
			
 
				+        ): Func & {
			
 
				+            asyncResource: AsyncResource;
			
 
				+        };
			
 
				+        /**
			
 
				+         * Call the provided function with the provided arguments in the execution context
			
 
				+         * of the async resource. This will establish the context, trigger the AsyncHooks
			
 
				+         * before callbacks, call the function, trigger the AsyncHooks after callbacks, and
			
 
				+         * then restore the original execution context.
			
 
				+         * @since v9.6.0
			
 
				+         * @param fn The function to call in the execution context of this async resource.
			
 
				+         * @param thisArg The receiver to be used for the function call.
			
 
				+         * @param args Optional arguments to pass to the function.
			
 
				+         */
			
 
				+        runInAsyncScope<This, Result>(fn: (this: This, ...args: any[]) => Result, thisArg?: This, ...args: any[]): Result;
			
 
				+        /**
			
 
				+         * Call all `destroy` hooks. This should only ever be called once. An error will
			
 
				+         * be thrown if it is called more than once. This **must** be manually called. If
			
 
				+         * the resource is left to be collected by the GC then the `destroy` hooks will
			
 
				+         * never be called.
			
 
				+         * @return A reference to `asyncResource`.
			
 
				+         */
			
 
				+        emitDestroy(): this;
			
 
				+        /**
			
 
				+         * @return The unique `asyncId` assigned to the resource.
			
 
				+         */
			
 
				+        asyncId(): number;
			
 
				+        /**
			
 
				+         *
			
 
				+         * @return The same `triggerAsyncId` that is passed to the `AsyncResource` constructor.
			
 
				+         */
			
 
				+        triggerAsyncId(): number;
			
 
				+    }
			
 
				+    interface AsyncLocalStorageOptions<T> {
			
 
				+        /**
			
 
				+         * Optional callback invoked before a store is propagated to a new async resource.
			
 
				+         * Returning `true` allows propagation, returning `false` avoids it. Default is to propagate always.
			
 
				+         * @param type The type of async event.
			
 
				+         * @param store The current store.
			
 
				+         * @since v18.13.0
			
 
				+         */
			
 
				+        onPropagate?: ((type: string, store: T) => boolean) | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * This class creates stores that stay coherent through asynchronous operations.
			
 
				+     *
			
 
				+     * While you can create your own implementation on top of the `async_hooks` module,`AsyncLocalStorage` should be preferred as it is a performant and memory safe
			
 
				+     * implementation that involves significant optimizations that are non-obvious to
			
 
				+     * implement.
			
 
				+     *
			
 
				+     * The following example uses `AsyncLocalStorage` to build a simple logger
			
 
				+     * that assigns IDs to incoming HTTP requests and includes them in messages
			
 
				+     * logged within each request.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import http from 'http';
			
 
				+     * import { AsyncLocalStorage } from 'async_hooks';
			
 
				+     *
			
 
				+     * const asyncLocalStorage = new AsyncLocalStorage();
			
 
				+     *
			
 
				+     * function logWithId(msg) {
			
 
				+     *   const id = asyncLocalStorage.getStore();
			
 
				+     *   console.log(`${id !== undefined ? id : '-'}:`, msg);
			
 
				+     * }
			
 
				+     *
			
 
				+     * let idSeq = 0;
			
 
				+     * http.createServer((req, res) => {
			
 
				+     *   asyncLocalStorage.run(idSeq++, () => {
			
 
				+     *     logWithId('start');
			
 
				+     *     // Imagine any chain of async operations here
			
 
				+     *     setImmediate(() => {
			
 
				+     *       logWithId('finish');
			
 
				+     *       res.end();
			
 
				+     *     });
			
 
				+     *   });
			
 
				+     * }).listen(8080);
			
 
				+     *
			
 
				+     * http.get('http://localhost:8080');
			
 
				+     * http.get('http://localhost:8080');
			
 
				+     * // Prints:
			
 
				+     * //   0: start
			
 
				+     * //   1: start
			
 
				+     * //   0: finish
			
 
				+     * //   1: finish
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Each instance of `AsyncLocalStorage` maintains an independent storage context.
			
 
				+     * Multiple instances can safely exist simultaneously without risk of interfering
			
 
				+     * with each other's data.
			
 
				+     * @since v13.10.0, v12.17.0
			
 
				+     */
			
 
				+    class AsyncLocalStorage<T> {
			
 
				+        constructor(options?: AsyncLocalStorageOptions<T>);
			
 
				+
			
 
				+        /**
			
 
				+         * Disables the instance of `AsyncLocalStorage`. All subsequent calls
			
 
				+         * to `asyncLocalStorage.getStore()` will return `undefined` until`asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()` is called again.
			
 
				+         *
			
 
				+         * When calling `asyncLocalStorage.disable()`, all current contexts linked to the
			
 
				+         * instance will be exited.
			
 
				+         *
			
 
				+         * Calling `asyncLocalStorage.disable()` is required before the`asyncLocalStorage` can be garbage collected. This does not apply to stores
			
 
				+         * provided by the `asyncLocalStorage`, as those objects are garbage collected
			
 
				+         * along with the corresponding async resources.
			
 
				+         *
			
 
				+         * Use this method when the `asyncLocalStorage` is not in use anymore
			
 
				+         * in the current process.
			
 
				+         * @since v13.10.0, v12.17.0
			
 
				+         * @experimental
			
 
				+         */
			
 
				+        disable(): void;
			
 
				+        /**
			
 
				+         * Returns the current store.
			
 
				+         * If called outside of an asynchronous context initialized by
			
 
				+         * calling `asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()`, it
			
 
				+         * returns `undefined`.
			
 
				+         * @since v13.10.0, v12.17.0
			
 
				+         */
			
 
				+        getStore(): T | undefined;
			
 
				+        /**
			
 
				+         * Runs a function synchronously within a context and returns its
			
 
				+         * return value. The store is not accessible outside of the callback function.
			
 
				+         * The store is accessible to any asynchronous operations created within the
			
 
				+         * callback.
			
 
				+         *
			
 
				+         * The optional `args` are passed to the callback function.
			
 
				+         *
			
 
				+         * If the callback function throws an error, the error is thrown by `run()` too.
			
 
				+         * The stacktrace is not impacted by this call and the context is exited.
			
 
				+         *
			
 
				+         * Example:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const store = { id: 2 };
			
 
				+         * try {
			
 
				+         *   asyncLocalStorage.run(store, () => {
			
 
				+         *     asyncLocalStorage.getStore(); // Returns the store object
			
 
				+         *     setTimeout(() => {
			
 
				+         *       asyncLocalStorage.getStore(); // Returns the store object
			
 
				+         *     }, 200);
			
 
				+         *     throw new Error();
			
 
				+         *   });
			
 
				+         * } catch (e) {
			
 
				+         *   asyncLocalStorage.getStore(); // Returns undefined
			
 
				+         *   // The error will be caught here
			
 
				+         * }
			
 
				+         * ```
			
 
				+         * @since v13.10.0, v12.17.0
			
 
				+         */
			
 
				+        run<R, TArgs extends any[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
			
 
				+        /**
			
 
				+         * Runs a function synchronously outside of a context and returns its
			
 
				+         * return value. The store is not accessible within the callback function or
			
 
				+         * the asynchronous operations created within the callback. Any `getStore()`call done within the callback function will always return `undefined`.
			
 
				+         *
			
 
				+         * The optional `args` are passed to the callback function.
			
 
				+         *
			
 
				+         * If the callback function throws an error, the error is thrown by `exit()` too.
			
 
				+         * The stacktrace is not impacted by this call and the context is re-entered.
			
 
				+         *
			
 
				+         * Example:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * // Within a call to run
			
 
				+         * try {
			
 
				+         *   asyncLocalStorage.getStore(); // Returns the store object or value
			
 
				+         *   asyncLocalStorage.exit(() => {
			
 
				+         *     asyncLocalStorage.getStore(); // Returns undefined
			
 
				+         *     throw new Error();
			
 
				+         *   });
			
 
				+         * } catch (e) {
			
 
				+         *   asyncLocalStorage.getStore(); // Returns the same object or value
			
 
				+         *   // The error will be caught here
			
 
				+         * }
			
 
				+         * ```
			
 
				+         * @since v13.10.0, v12.17.0
			
 
				+         * @experimental
			
 
				+         */
			
 
				+        exit<R, TArgs extends any[]>(callback: (...args: TArgs) => R, ...args: TArgs): R;
			
 
				+        /**
			
 
				+         * Transitions into the context for the remainder of the current
			
 
				+         * synchronous execution and then persists the store through any following
			
 
				+         * asynchronous calls.
			
 
				+         *
			
 
				+         * Example:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const store = { id: 1 };
			
 
				+         * // Replaces previous store with the given store object
			
 
				+         * asyncLocalStorage.enterWith(store);
			
 
				+         * asyncLocalStorage.getStore(); // Returns the store object
			
 
				+         * someAsyncOperation(() => {
			
 
				+         *   asyncLocalStorage.getStore(); // Returns the same object
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * This transition will continue for the _entire_ synchronous execution.
			
 
				+         * This means that if, for example, the context is entered within an event
			
 
				+         * handler subsequent event handlers will also run within that context unless
			
 
				+         * specifically bound to another context with an `AsyncResource`. That is why`run()` should be preferred over `enterWith()` unless there are strong reasons
			
 
				+         * to use the latter method.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const store = { id: 1 };
			
 
				+         *
			
 
				+         * emitter.on('my-event', () => {
			
 
				+         *   asyncLocalStorage.enterWith(store);
			
 
				+         * });
			
 
				+         * emitter.on('my-event', () => {
			
 
				+         *   asyncLocalStorage.getStore(); // Returns the same object
			
 
				+         * });
			
 
				+         *
			
 
				+         * asyncLocalStorage.getStore(); // Returns undefined
			
 
				+         * emitter.emit('my-event');
			
 
				+         * asyncLocalStorage.getStore(); // Returns the same object
			
 
				+         * ```
			
 
				+         * @since v13.11.0, v12.17.0
			
 
				+         * @experimental
			
 
				+         */
			
 
				+        enterWith(store: T): void;
			
 
				+    }
			
 
				+}
			
 
				+declare module 'node:async_hooks' {
			
 
				+    export * from 'async_hooks';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/buffer.d.ts
+++ b/Asistent/node_modules/@types/node/buffer.d.ts
@@ -0,0 +1,2312 @@
 
				+/**
			
 
				+ * `Buffer` objects are used to represent a fixed-length sequence of bytes. Many
			
 
				+ * Node.js APIs support `Buffer`s.
			
 
				+ *
			
 
				+ * The `Buffer` class is a subclass of JavaScript's [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) class and
			
 
				+ * extends it with methods that cover additional use cases. Node.js APIs accept
			
 
				+ * plain [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) s wherever `Buffer`s are supported as well.
			
 
				+ *
			
 
				+ * While the `Buffer` class is available within the global scope, it is still
			
 
				+ * recommended to explicitly reference it via an import or require statement.
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * import { Buffer } from 'buffer';
			
 
				+ *
			
 
				+ * // Creates a zero-filled Buffer of length 10.
			
 
				+ * const buf1 = Buffer.alloc(10);
			
 
				+ *
			
 
				+ * // Creates a Buffer of length 10,
			
 
				+ * // filled with bytes which all have the value `1`.
			
 
				+ * const buf2 = Buffer.alloc(10, 1);
			
 
				+ *
			
 
				+ * // Creates an uninitialized buffer of length 10.
			
 
				+ * // This is faster than calling Buffer.alloc() but the returned
			
 
				+ * // Buffer instance might contain old data that needs to be
			
 
				+ * // overwritten using fill(), write(), or other functions that fill the Buffer's
			
 
				+ * // contents.
			
 
				+ * const buf3 = Buffer.allocUnsafe(10);
			
 
				+ *
			
 
				+ * // Creates a Buffer containing the bytes [1, 2, 3].
			
 
				+ * const buf4 = Buffer.from([1, 2, 3]);
			
 
				+ *
			
 
				+ * // Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries
			
 
				+ * // are all truncated using `(value &#x26; 255)` to fit into the range 0–255.
			
 
				+ * const buf5 = Buffer.from([257, 257.5, -255, '1']);
			
 
				+ *
			
 
				+ * // Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':
			
 
				+ * // [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)
			
 
				+ * // [116, 195, 169, 115, 116] (in decimal notation)
			
 
				+ * const buf6 = Buffer.from('tést');
			
 
				+ *
			
 
				+ * // Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
			
 
				+ * const buf7 = Buffer.from('tést', 'latin1');
			
 
				+ * ```
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/buffer.js)
			
 
				+ */
			
 
				+declare module 'buffer' {
			
 
				+    import { BinaryLike } from 'node:crypto';
			
 
				+    import { ReadableStream as WebReadableStream } from 'node:stream/web';
			
 
				+    export function isUtf8(input: Buffer | ArrayBuffer | NodeJS.TypedArray): boolean;
			
 
				+    export function isAscii(input: Buffer | ArrayBuffer | NodeJS.TypedArray): boolean;
			
 
				+    export const INSPECT_MAX_BYTES: number;
			
 
				+    export const kMaxLength: number;
			
 
				+    export const kStringMaxLength: number;
			
 
				+    export const constants: {
			
 
				+        MAX_LENGTH: number;
			
 
				+        MAX_STRING_LENGTH: number;
			
 
				+    };
			
 
				+    export type TranscodeEncoding = 'ascii' | 'utf8' | 'utf16le' | 'ucs2' | 'latin1' | 'binary';
			
 
				+    /**
			
 
				+     * Re-encodes the given `Buffer` or `Uint8Array` instance from one character
			
 
				+     * encoding to another. Returns a new `Buffer` instance.
			
 
				+     *
			
 
				+     * Throws if the `fromEnc` or `toEnc` specify invalid character encodings or if
			
 
				+     * conversion from `fromEnc` to `toEnc` is not permitted.
			
 
				+     *
			
 
				+     * Encodings supported by `buffer.transcode()` are: `'ascii'`, `'utf8'`,`'utf16le'`, `'ucs2'`, `'latin1'`, and `'binary'`.
			
 
				+     *
			
 
				+     * The transcoding process will use substitution characters if a given byte
			
 
				+     * sequence cannot be adequately represented in the target encoding. For instance:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { Buffer, transcode } from 'buffer';
			
 
				+     *
			
 
				+     * const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii');
			
 
				+     * console.log(newBuf.toString('ascii'));
			
 
				+     * // Prints: '?'
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Because the Euro (`€`) sign is not representable in US-ASCII, it is replaced
			
 
				+     * with `?` in the transcoded `Buffer`.
			
 
				+     * @since v7.1.0
			
 
				+     * @param source A `Buffer` or `Uint8Array` instance.
			
 
				+     * @param fromEnc The current encoding.
			
 
				+     * @param toEnc To target encoding.
			
 
				+     */
			
 
				+    export function transcode(source: Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
			
 
				+    export const SlowBuffer: {
			
 
				+        /** @deprecated since v6.0.0, use `Buffer.allocUnsafeSlow()` */
			
 
				+        new (size: number): Buffer;
			
 
				+        prototype: Buffer;
			
 
				+    };
			
 
				+    /**
			
 
				+     * Resolves a `'blob:nodedata:...'` an associated `Blob` object registered using
			
 
				+     * a prior call to `URL.createObjectURL()`.
			
 
				+     * @since v16.7.0
			
 
				+     * @experimental
			
 
				+     * @param id A `'blob:nodedata:...` URL string returned by a prior call to `URL.createObjectURL()`.
			
 
				+     */
			
 
				+    export function resolveObjectURL(id: string): Blob | undefined;
			
 
				+    export { Buffer };
			
 
				+    /**
			
 
				+     * @experimental
			
 
				+     */
			
 
				+    export interface BlobOptions {
			
 
				+        /**
			
 
				+         * @default 'utf8'
			
 
				+         */
			
 
				+        encoding?: BufferEncoding | undefined;
			
 
				+        /**
			
 
				+         * The Blob content-type. The intent is for `type` to convey
			
 
				+         * the MIME media type of the data, however no validation of the type format
			
 
				+         * is performed.
			
 
				+         */
			
 
				+        type?: string | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * A [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) encapsulates immutable, raw data that can be safely shared across
			
 
				+     * multiple worker threads.
			
 
				+     * @since v15.7.0, v14.18.0
			
 
				+     */
			
 
				+    export class Blob {
			
 
				+        /**
			
 
				+         * The total size of the `Blob` in bytes.
			
 
				+         * @since v15.7.0, v14.18.0
			
 
				+         */
			
 
				+        readonly size: number;
			
 
				+        /**
			
 
				+         * The content-type of the `Blob`.
			
 
				+         * @since v15.7.0, v14.18.0
			
 
				+         */
			
 
				+        readonly type: string;
			
 
				+        /**
			
 
				+         * Creates a new `Blob` object containing a concatenation of the given sources.
			
 
				+         *
			
 
				+         * {ArrayBuffer}, {TypedArray}, {DataView}, and {Buffer} sources are copied into
			
 
				+         * the 'Blob' and can therefore be safely modified after the 'Blob' is created.
			
 
				+         *
			
 
				+         * String sources are also copied into the `Blob`.
			
 
				+         */
			
 
				+        constructor(sources: Array<BinaryLike | Blob>, options?: BlobOptions);
			
 
				+        /**
			
 
				+         * Returns a promise that fulfills with an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) containing a copy of
			
 
				+         * the `Blob` data.
			
 
				+         * @since v15.7.0, v14.18.0
			
 
				+         */
			
 
				+        arrayBuffer(): Promise<ArrayBuffer>;
			
 
				+        /**
			
 
				+         * Creates and returns a new `Blob` containing a subset of this `Blob` objects
			
 
				+         * data. The original `Blob` is not altered.
			
 
				+         * @since v15.7.0, v14.18.0
			
 
				+         * @param start The starting index.
			
 
				+         * @param end The ending index.
			
 
				+         * @param type The content-type for the new `Blob`
			
 
				+         */
			
 
				+        slice(start?: number, end?: number, type?: string): Blob;
			
 
				+        /**
			
 
				+         * Returns a promise that fulfills with the contents of the `Blob` decoded as a
			
 
				+         * UTF-8 string.
			
 
				+         * @since v15.7.0, v14.18.0
			
 
				+         */
			
 
				+        text(): Promise<string>;
			
 
				+        /**
			
 
				+         * Returns a new (WHATWG) `ReadableStream` that allows the content of the `Blob` to be read.
			
 
				+         * @since v16.7.0
			
 
				+         */
			
 
				+        stream(): WebReadableStream;
			
 
				+    }
			
 
				+    export interface FileOptions {
			
 
				+        /**
			
 
				+         * One of either `'transparent'` or `'native'`. When set to `'native'`, line endings in string source parts will be
			
 
				+         * converted to the platform native line-ending as specified by `require('node:os').EOL`.
			
 
				+         */
			
 
				+        endings?: 'native' | 'transparent';
			
 
				+        /** The File content-type. */
			
 
				+        type?: string;
			
 
				+        /** The last modified date of the file. `Default`: Date.now(). */
			
 
				+        lastModified?: number;
			
 
				+    }
			
 
				+    /**
			
 
				+     * A [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) provides information about files.
			
 
				+     * @experimental
			
 
				+     * @since v18.13.0
			
 
				+     */
			
 
				+    export class File extends Blob {
			
 
				+        constructor(sources: Array<BinaryLike | Blob>, fileName: string, options?: FileOptions);
			
 
				+        /**
			
 
				+         * The name of the `File`.
			
 
				+         * @since v18.13.0
			
 
				+         */
			
 
				+        readonly name: string;
			
 
				+        /**
			
 
				+         * The last modified date of the `File`.
			
 
				+         * @since v18.13.0
			
 
				+         */
			
 
				+        readonly lastModified: number;
			
 
				+    }
			
 
				+    export import atob = globalThis.atob;
			
 
				+    export import btoa = globalThis.btoa;
			
 
				+
			
 
				+    import { Blob as NodeBlob } from 'buffer';
			
 
				+    // This conditional type will be the existing global Blob in a browser, or
			
 
				+    // the copy below in a Node environment.
			
 
				+    type __Blob = typeof globalThis extends { onmessage: any; Blob: infer T } ? T : NodeBlob;
			
 
				+    global {
			
 
				+        // Buffer class
			
 
				+        type BufferEncoding =
			
 
				+            | 'ascii'
			
 
				+            | 'utf8'
			
 
				+            | 'utf-8'
			
 
				+            | 'utf16le'
			
 
				+            | 'ucs2'
			
 
				+            | 'ucs-2'
			
 
				+            | 'base64'
			
 
				+            | 'base64url'
			
 
				+            | 'latin1'
			
 
				+            | 'binary'
			
 
				+            | 'hex';
			
 
				+        type WithImplicitCoercion<T> =
			
 
				+            | T
			
 
				+            | {
			
 
				+                  valueOf(): T;
			
 
				+              };
			
 
				+        /**
			
 
				+         * Raw data is stored in instances of the Buffer class.
			
 
				+         * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap.  A Buffer cannot be resized.
			
 
				+         * Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'base64url'|'binary'(deprecated)|'hex'
			
 
				+         */
			
 
				+        interface BufferConstructor {
			
 
				+            /**
			
 
				+             * Allocates a new buffer containing the given {str}.
			
 
				+             *
			
 
				+             * @param str String to store in buffer.
			
 
				+             * @param encoding encoding to use, optional.  Default is 'utf8'
			
 
				+             * @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead.
			
 
				+             */
			
 
				+            new (str: string, encoding?: BufferEncoding): Buffer;
			
 
				+            /**
			
 
				+             * Allocates a new buffer of {size} octets.
			
 
				+             *
			
 
				+             * @param size count of octets to allocate.
			
 
				+             * @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`).
			
 
				+             */
			
 
				+            new (size: number): Buffer;
			
 
				+            /**
			
 
				+             * Allocates a new buffer containing the given {array} of octets.
			
 
				+             *
			
 
				+             * @param array The octets to store.
			
 
				+             * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
			
 
				+             */
			
 
				+            new (array: Uint8Array): Buffer;
			
 
				+            /**
			
 
				+             * Produces a Buffer backed by the same allocated memory as
			
 
				+             * the given {ArrayBuffer}/{SharedArrayBuffer}.
			
 
				+             *
			
 
				+             *
			
 
				+             * @param arrayBuffer The ArrayBuffer with which to share memory.
			
 
				+             * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
			
 
				+             */
			
 
				+            new (arrayBuffer: ArrayBuffer | SharedArrayBuffer): Buffer;
			
 
				+            /**
			
 
				+             * Allocates a new buffer containing the given {array} of octets.
			
 
				+             *
			
 
				+             * @param array The octets to store.
			
 
				+             * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
			
 
				+             */
			
 
				+            new (array: ReadonlyArray<any>): Buffer;
			
 
				+            /**
			
 
				+             * Copies the passed {buffer} data onto a new {Buffer} instance.
			
 
				+             *
			
 
				+             * @param buffer The buffer to copy.
			
 
				+             * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.
			
 
				+             */
			
 
				+            new (buffer: Buffer): Buffer;
			
 
				+            /**
			
 
				+             * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`.
			
 
				+             * Array entries outside that range will be truncated to fit into it.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * // Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
			
 
				+             * const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
			
 
				+             * ```
			
 
				+             *
			
 
				+             * A `TypeError` will be thrown if `array` is not an `Array` or another type
			
 
				+             * appropriate for `Buffer.from()` variants.
			
 
				+             *
			
 
				+             * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal`Buffer` pool like `Buffer.allocUnsafe()` does.
			
 
				+             * @since v5.10.0
			
 
				+             */
			
 
				+            from(
			
 
				+                arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>,
			
 
				+                byteOffset?: number,
			
 
				+                length?: number,
			
 
				+            ): Buffer;
			
 
				+            /**
			
 
				+             * Creates a new Buffer using the passed {data}
			
 
				+             * @param data data to create a new Buffer
			
 
				+             */
			
 
				+            from(data: Uint8Array | ReadonlyArray<number>): Buffer;
			
 
				+            from(data: WithImplicitCoercion<Uint8Array | ReadonlyArray<number> | string>): Buffer;
			
 
				+            /**
			
 
				+             * Creates a new Buffer containing the given JavaScript string {str}.
			
 
				+             * If provided, the {encoding} parameter identifies the character encoding.
			
 
				+             * If not provided, {encoding} defaults to 'utf8'.
			
 
				+             */
			
 
				+            from(
			
 
				+                str:
			
 
				+                    | WithImplicitCoercion<string>
			
 
				+                    | {
			
 
				+                          [Symbol.toPrimitive](hint: 'string'): string;
			
 
				+                      },
			
 
				+                encoding?: BufferEncoding,
			
 
				+            ): Buffer;
			
 
				+            /**
			
 
				+             * Creates a new Buffer using the passed {data}
			
 
				+             * @param values to create a new Buffer
			
 
				+             */
			
 
				+            of(...items: number[]): Buffer;
			
 
				+            /**
			
 
				+             * Returns `true` if `obj` is a `Buffer`, `false` otherwise.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * Buffer.isBuffer(Buffer.alloc(10)); // true
			
 
				+             * Buffer.isBuffer(Buffer.from('foo')); // true
			
 
				+             * Buffer.isBuffer('a string'); // false
			
 
				+             * Buffer.isBuffer([]); // false
			
 
				+             * Buffer.isBuffer(new Uint8Array(1024)); // false
			
 
				+             * ```
			
 
				+             * @since v0.1.101
			
 
				+             */
			
 
				+            isBuffer(obj: any): obj is Buffer;
			
 
				+            /**
			
 
				+             * Returns `true` if `encoding` is the name of a supported character encoding,
			
 
				+             * or `false` otherwise.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * console.log(Buffer.isEncoding('utf8'));
			
 
				+             * // Prints: true
			
 
				+             *
			
 
				+             * console.log(Buffer.isEncoding('hex'));
			
 
				+             * // Prints: true
			
 
				+             *
			
 
				+             * console.log(Buffer.isEncoding('utf/8'));
			
 
				+             * // Prints: false
			
 
				+             *
			
 
				+             * console.log(Buffer.isEncoding(''));
			
 
				+             * // Prints: false
			
 
				+             * ```
			
 
				+             * @since v0.9.1
			
 
				+             * @param encoding A character encoding name to check.
			
 
				+             */
			
 
				+            isEncoding(encoding: string): encoding is BufferEncoding;
			
 
				+            /**
			
 
				+             * Returns the byte length of a string when encoded using `encoding`.
			
 
				+             * This is not the same as [`String.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length), which does not account
			
 
				+             * for the encoding that is used to convert the string into bytes.
			
 
				+             *
			
 
				+             * For `'base64'`, `'base64url'`, and `'hex'`, this function assumes valid input.
			
 
				+             * For strings that contain non-base64/hex-encoded data (e.g. whitespace), the
			
 
				+             * return value might be greater than the length of a `Buffer` created from the
			
 
				+             * string.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const str = '\u00bd + \u00bc = \u00be';
			
 
				+             *
			
 
				+             * console.log(`${str}: ${str.length} characters, ` +
			
 
				+             *             `${Buffer.byteLength(str, 'utf8')} bytes`);
			
 
				+             * // Prints: ½ + ¼ = ¾: 9 characters, 12 bytes
			
 
				+             * ```
			
 
				+             *
			
 
				+             * When `string` is a
			
 
				+             * `Buffer`/[`DataView`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView)/[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/-
			
 
				+             * Reference/Global_Objects/TypedArray)/[`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)/[`SharedArrayBuffer`](https://develop-
			
 
				+             * er.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer), the byte length as reported by `.byteLength`is returned.
			
 
				+             * @since v0.1.90
			
 
				+             * @param string A value to calculate the length of.
			
 
				+             * @param [encoding='utf8'] If `string` is a string, this is its encoding.
			
 
				+             * @return The number of bytes contained within `string`.
			
 
				+             */
			
 
				+            byteLength(
			
 
				+                string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
			
 
				+                encoding?: BufferEncoding,
			
 
				+            ): number;
			
 
				+            /**
			
 
				+             * Returns a new `Buffer` which is the result of concatenating all the `Buffer`instances in the `list` together.
			
 
				+             *
			
 
				+             * If the list has no items, or if the `totalLength` is 0, then a new zero-length`Buffer` is returned.
			
 
				+             *
			
 
				+             * If `totalLength` is not provided, it is calculated from the `Buffer` instances
			
 
				+             * in `list` by adding their lengths.
			
 
				+             *
			
 
				+             * If `totalLength` is provided, it is coerced to an unsigned integer. If the
			
 
				+             * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
			
 
				+             * truncated to `totalLength`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * // Create a single `Buffer` from a list of three `Buffer` instances.
			
 
				+             *
			
 
				+             * const buf1 = Buffer.alloc(10);
			
 
				+             * const buf2 = Buffer.alloc(14);
			
 
				+             * const buf3 = Buffer.alloc(18);
			
 
				+             * const totalLength = buf1.length + buf2.length + buf3.length;
			
 
				+             *
			
 
				+             * console.log(totalLength);
			
 
				+             * // Prints: 42
			
 
				+             *
			
 
				+             * const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
			
 
				+             *
			
 
				+             * console.log(bufA);
			
 
				+             * // Prints: <Buffer 00 00 00 00 ...>
			
 
				+             * console.log(bufA.length);
			
 
				+             * // Prints: 42
			
 
				+             * ```
			
 
				+             *
			
 
				+             * `Buffer.concat()` may also use the internal `Buffer` pool like `Buffer.allocUnsafe()` does.
			
 
				+             * @since v0.7.11
			
 
				+             * @param list List of `Buffer` or {@link Uint8Array} instances to concatenate.
			
 
				+             * @param totalLength Total length of the `Buffer` instances in `list` when concatenated.
			
 
				+             */
			
 
				+            concat(list: ReadonlyArray<Uint8Array>, totalLength?: number): Buffer;
			
 
				+            /**
			
 
				+             * Compares `buf1` to `buf2`, typically for the purpose of sorting arrays of`Buffer` instances. This is equivalent to calling `buf1.compare(buf2)`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf1 = Buffer.from('1234');
			
 
				+             * const buf2 = Buffer.from('0123');
			
 
				+             * const arr = [buf1, buf2];
			
 
				+             *
			
 
				+             * console.log(arr.sort(Buffer.compare));
			
 
				+             * // Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
			
 
				+             * // (This result is equal to: [buf2, buf1].)
			
 
				+             * ```
			
 
				+             * @since v0.11.13
			
 
				+             * @return Either `-1`, `0`, or `1`, depending on the result of the comparison. See `compare` for details.
			
 
				+             */
			
 
				+            compare(buf1: Uint8Array, buf2: Uint8Array): -1 | 0 | 1;
			
 
				+            /**
			
 
				+             * Allocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the`Buffer` will be zero-filled.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.alloc(5);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 00 00 00 00 00>
			
 
				+             * ```
			
 
				+             *
			
 
				+             * If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown.
			
 
				+             *
			
 
				+             * If `fill` is specified, the allocated `Buffer` will be initialized by calling `buf.fill(fill)`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.alloc(5, 'a');
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 61 61 61 61 61>
			
 
				+             * ```
			
 
				+             *
			
 
				+             * If both `fill` and `encoding` are specified, the allocated `Buffer` will be
			
 
				+             * initialized by calling `buf.fill(fill, encoding)`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
			
 
				+             * ```
			
 
				+             *
			
 
				+             * Calling `Buffer.alloc()` can be measurably slower than the alternative `Buffer.allocUnsafe()` but ensures that the newly created `Buffer` instance
			
 
				+             * contents will never contain sensitive data from previous allocations, including
			
 
				+             * data that might not have been allocated for `Buffer`s.
			
 
				+             *
			
 
				+             * A `TypeError` will be thrown if `size` is not a number.
			
 
				+             * @since v5.10.0
			
 
				+             * @param size The desired length of the new `Buffer`.
			
 
				+             * @param [fill=0] A value to pre-fill the new `Buffer` with.
			
 
				+             * @param [encoding='utf8'] If `fill` is a string, this is its encoding.
			
 
				+             */
			
 
				+            alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
			
 
				+            /**
			
 
				+             * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown.
			
 
				+             *
			
 
				+             * The underlying memory for `Buffer` instances created in this way is _not_
			
 
				+             * _initialized_. The contents of the newly created `Buffer` are unknown and _may contain sensitive data_. Use `Buffer.alloc()` instead to initialize`Buffer` instances with zeroes.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(10);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>
			
 
				+             *
			
 
				+             * buf.fill(0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>
			
 
				+             * ```
			
 
				+             *
			
 
				+             * A `TypeError` will be thrown if `size` is not a number.
			
 
				+             *
			
 
				+             * The `Buffer` module pre-allocates an internal `Buffer` instance of
			
 
				+             * size `Buffer.poolSize` that is used as a pool for the fast allocation of new`Buffer` instances created using `Buffer.allocUnsafe()`,`Buffer.from(array)`, `Buffer.concat()`, and the
			
 
				+             * deprecated`new Buffer(size)` constructor only when `size` is less than or equal
			
 
				+             * to `Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two).
			
 
				+             *
			
 
				+             * Use of this pre-allocated internal memory pool is a key difference between
			
 
				+             * calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.
			
 
				+             * Specifically, `Buffer.alloc(size, fill)` will _never_ use the internal `Buffer`pool, while `Buffer.allocUnsafe(size).fill(fill)`_will_ use the internal`Buffer` pool if `size` is less
			
 
				+             * than or equal to half `Buffer.poolSize`. The
			
 
				+             * difference is subtle but can be important when an application requires the
			
 
				+             * additional performance that `Buffer.allocUnsafe()` provides.
			
 
				+             * @since v5.10.0
			
 
				+             * @param size The desired length of the new `Buffer`.
			
 
				+             */
			
 
				+            allocUnsafe(size: number): Buffer;
			
 
				+            /**
			
 
				+             * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown. A zero-length `Buffer` is created
			
 
				+             * if `size` is 0.
			
 
				+             *
			
 
				+             * The underlying memory for `Buffer` instances created in this way is _not_
			
 
				+             * _initialized_. The contents of the newly created `Buffer` are unknown and _may contain sensitive data_. Use `buf.fill(0)` to initialize
			
 
				+             * such `Buffer` instances with zeroes.
			
 
				+             *
			
 
				+             * When using `Buffer.allocUnsafe()` to allocate new `Buffer` instances,
			
 
				+             * allocations under 4 KB are sliced from a single pre-allocated `Buffer`. This
			
 
				+             * allows applications to avoid the garbage collection overhead of creating many
			
 
				+             * individually allocated `Buffer` instances. This approach improves both
			
 
				+             * performance and memory usage by eliminating the need to track and clean up as
			
 
				+             * many individual `ArrayBuffer` objects.
			
 
				+             *
			
 
				+             * However, in the case where a developer may need to retain a small chunk of
			
 
				+             * memory from a pool for an indeterminate amount of time, it may be appropriate
			
 
				+             * to create an un-pooled `Buffer` instance using `Buffer.allocUnsafeSlow()` and
			
 
				+             * then copying out the relevant bits.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * // Need to keep around a few small chunks of memory.
			
 
				+             * const store = [];
			
 
				+             *
			
 
				+             * socket.on('readable', () => {
			
 
				+             *   let data;
			
 
				+             *   while (null !== (data = readable.read())) {
			
 
				+             *     // Allocate for retained data.
			
 
				+             *     const sb = Buffer.allocUnsafeSlow(10);
			
 
				+             *
			
 
				+             *     // Copy the data into the new allocation.
			
 
				+             *     data.copy(sb, 0, 0, 10);
			
 
				+             *
			
 
				+             *     store.push(sb);
			
 
				+             *   }
			
 
				+             * });
			
 
				+             * ```
			
 
				+             *
			
 
				+             * A `TypeError` will be thrown if `size` is not a number.
			
 
				+             * @since v5.12.0
			
 
				+             * @param size The desired length of the new `Buffer`.
			
 
				+             */
			
 
				+            allocUnsafeSlow(size: number): Buffer;
			
 
				+            /**
			
 
				+             * This is the size (in bytes) of pre-allocated internal `Buffer` instances used
			
 
				+             * for pooling. This value may be modified.
			
 
				+             * @since v0.11.3
			
 
				+             */
			
 
				+            poolSize: number;
			
 
				+        }
			
 
				+        interface Buffer extends Uint8Array {
			
 
				+            /**
			
 
				+             * Writes `string` to `buf` at `offset` according to the character encoding in`encoding`. The `length` parameter is the number of bytes to write. If `buf` did
			
 
				+             * not contain enough space to fit the entire string, only part of `string` will be
			
 
				+             * written. However, partially encoded characters will not be written.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.alloc(256);
			
 
				+             *
			
 
				+             * const len = buf.write('\u00bd + \u00bc = \u00be', 0);
			
 
				+             *
			
 
				+             * console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`);
			
 
				+             * // Prints: 12 bytes: ½ + ¼ = ¾
			
 
				+             *
			
 
				+             * const buffer = Buffer.alloc(10);
			
 
				+             *
			
 
				+             * const length = buffer.write('abcd', 8);
			
 
				+             *
			
 
				+             * console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`);
			
 
				+             * // Prints: 2 bytes : ab
			
 
				+             * ```
			
 
				+             * @since v0.1.90
			
 
				+             * @param string String to write to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write `string`.
			
 
				+             * @param [length=buf.length - offset] Maximum number of bytes to write (written bytes will not exceed `buf.length - offset`).
			
 
				+             * @param [encoding='utf8'] The character encoding of `string`.
			
 
				+             * @return Number of bytes written.
			
 
				+             */
			
 
				+            write(string: string, encoding?: BufferEncoding): number;
			
 
				+            write(string: string, offset: number, encoding?: BufferEncoding): number;
			
 
				+            write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
			
 
				+            /**
			
 
				+             * Decodes `buf` to a string according to the specified character encoding in`encoding`. `start` and `end` may be passed to decode only a subset of `buf`.
			
 
				+             *
			
 
				+             * If `encoding` is `'utf8'` and a byte sequence in the input is not valid UTF-8,
			
 
				+             * then each invalid byte is replaced with the replacement character `U+FFFD`.
			
 
				+             *
			
 
				+             * The maximum length of a string instance (in UTF-16 code units) is available
			
 
				+             * as {@link constants.MAX_STRING_LENGTH}.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf1 = Buffer.allocUnsafe(26);
			
 
				+             *
			
 
				+             * for (let i = 0; i < 26; i++) {
			
 
				+             *   // 97 is the decimal ASCII value for 'a'.
			
 
				+             *   buf1[i] = i + 97;
			
 
				+             * }
			
 
				+             *
			
 
				+             * console.log(buf1.toString('utf8'));
			
 
				+             * // Prints: abcdefghijklmnopqrstuvwxyz
			
 
				+             * console.log(buf1.toString('utf8', 0, 5));
			
 
				+             * // Prints: abcde
			
 
				+             *
			
 
				+             * const buf2 = Buffer.from('tést');
			
 
				+             *
			
 
				+             * console.log(buf2.toString('hex'));
			
 
				+             * // Prints: 74c3a97374
			
 
				+             * console.log(buf2.toString('utf8', 0, 3));
			
 
				+             * // Prints: té
			
 
				+             * console.log(buf2.toString(undefined, 0, 3));
			
 
				+             * // Prints: té
			
 
				+             * ```
			
 
				+             * @since v0.1.90
			
 
				+             * @param [encoding='utf8'] The character encoding to use.
			
 
				+             * @param [start=0] The byte offset to start decoding at.
			
 
				+             * @param [end=buf.length] The byte offset to stop decoding at (not inclusive).
			
 
				+             */
			
 
				+            toString(encoding?: BufferEncoding, start?: number, end?: number): string;
			
 
				+            /**
			
 
				+             * Returns a JSON representation of `buf`. [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) implicitly calls
			
 
				+             * this function when stringifying a `Buffer` instance.
			
 
				+             *
			
 
				+             * `Buffer.from()` accepts objects in the format returned from this method.
			
 
				+             * In particular, `Buffer.from(buf.toJSON())` works like `Buffer.from(buf)`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
			
 
				+             * const json = JSON.stringify(buf);
			
 
				+             *
			
 
				+             * console.log(json);
			
 
				+             * // Prints: {"type":"Buffer","data":[1,2,3,4,5]}
			
 
				+             *
			
 
				+             * const copy = JSON.parse(json, (key, value) => {
			
 
				+             *   return value &#x26;&#x26; value.type === 'Buffer' ?
			
 
				+             *     Buffer.from(value) :
			
 
				+             *     value;
			
 
				+             * });
			
 
				+             *
			
 
				+             * console.log(copy);
			
 
				+             * // Prints: <Buffer 01 02 03 04 05>
			
 
				+             * ```
			
 
				+             * @since v0.9.2
			
 
				+             */
			
 
				+            toJSON(): {
			
 
				+                type: 'Buffer';
			
 
				+                data: number[];
			
 
				+            };
			
 
				+            /**
			
 
				+             * Returns `true` if both `buf` and `otherBuffer` have exactly the same bytes,`false` otherwise. Equivalent to `buf.compare(otherBuffer) === 0`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf1 = Buffer.from('ABC');
			
 
				+             * const buf2 = Buffer.from('414243', 'hex');
			
 
				+             * const buf3 = Buffer.from('ABCD');
			
 
				+             *
			
 
				+             * console.log(buf1.equals(buf2));
			
 
				+             * // Prints: true
			
 
				+             * console.log(buf1.equals(buf3));
			
 
				+             * // Prints: false
			
 
				+             * ```
			
 
				+             * @since v0.11.13
			
 
				+             * @param otherBuffer A `Buffer` or {@link Uint8Array} with which to compare `buf`.
			
 
				+             */
			
 
				+            equals(otherBuffer: Uint8Array): boolean;
			
 
				+            /**
			
 
				+             * Compares `buf` with `target` and returns a number indicating whether `buf`comes before, after, or is the same as `target` in sort order.
			
 
				+             * Comparison is based on the actual sequence of bytes in each `Buffer`.
			
 
				+             *
			
 
				+             * * `0` is returned if `target` is the same as `buf`
			
 
				+             * * `1` is returned if `target` should come _before_`buf` when sorted.
			
 
				+             * * `-1` is returned if `target` should come _after_`buf` when sorted.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf1 = Buffer.from('ABC');
			
 
				+             * const buf2 = Buffer.from('BCD');
			
 
				+             * const buf3 = Buffer.from('ABCD');
			
 
				+             *
			
 
				+             * console.log(buf1.compare(buf1));
			
 
				+             * // Prints: 0
			
 
				+             * console.log(buf1.compare(buf2));
			
 
				+             * // Prints: -1
			
 
				+             * console.log(buf1.compare(buf3));
			
 
				+             * // Prints: -1
			
 
				+             * console.log(buf2.compare(buf1));
			
 
				+             * // Prints: 1
			
 
				+             * console.log(buf2.compare(buf3));
			
 
				+             * // Prints: 1
			
 
				+             * console.log([buf1, buf2, buf3].sort(Buffer.compare));
			
 
				+             * // Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
			
 
				+             * // (This result is equal to: [buf1, buf3, buf2].)
			
 
				+             * ```
			
 
				+             *
			
 
				+             * The optional `targetStart`, `targetEnd`, `sourceStart`, and `sourceEnd`arguments can be used to limit the comparison to specific ranges within `target`and `buf` respectively.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]);
			
 
				+             * const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]);
			
 
				+             *
			
 
				+             * console.log(buf1.compare(buf2, 5, 9, 0, 4));
			
 
				+             * // Prints: 0
			
 
				+             * console.log(buf1.compare(buf2, 0, 6, 4));
			
 
				+             * // Prints: -1
			
 
				+             * console.log(buf1.compare(buf2, 5, 6, 5));
			
 
				+             * // Prints: 1
			
 
				+             * ```
			
 
				+             *
			
 
				+             * `ERR_OUT_OF_RANGE` is thrown if `targetStart < 0`, `sourceStart < 0`,`targetEnd > target.byteLength`, or `sourceEnd > source.byteLength`.
			
 
				+             * @since v0.11.13
			
 
				+             * @param target A `Buffer` or {@link Uint8Array} with which to compare `buf`.
			
 
				+             * @param [targetStart=0] The offset within `target` at which to begin comparison.
			
 
				+             * @param [targetEnd=target.length] The offset within `target` at which to end comparison (not inclusive).
			
 
				+             * @param [sourceStart=0] The offset within `buf` at which to begin comparison.
			
 
				+             * @param [sourceEnd=buf.length] The offset within `buf` at which to end comparison (not inclusive).
			
 
				+             */
			
 
				+            compare(
			
 
				+                target: Uint8Array,
			
 
				+                targetStart?: number,
			
 
				+                targetEnd?: number,
			
 
				+                sourceStart?: number,
			
 
				+                sourceEnd?: number,
			
 
				+            ): -1 | 0 | 1;
			
 
				+            /**
			
 
				+             * Copies data from a region of `buf` to a region in `target`, even if the `target`memory region overlaps with `buf`.
			
 
				+             *
			
 
				+             * [`TypedArray.prototype.set()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) performs the same operation, and is available
			
 
				+             * for all TypedArrays, including Node.js `Buffer`s, although it takes
			
 
				+             * different function arguments.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * // Create two `Buffer` instances.
			
 
				+             * const buf1 = Buffer.allocUnsafe(26);
			
 
				+             * const buf2 = Buffer.allocUnsafe(26).fill('!');
			
 
				+             *
			
 
				+             * for (let i = 0; i < 26; i++) {
			
 
				+             *   // 97 is the decimal ASCII value for 'a'.
			
 
				+             *   buf1[i] = i + 97;
			
 
				+             * }
			
 
				+             *
			
 
				+             * // Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.
			
 
				+             * buf1.copy(buf2, 8, 16, 20);
			
 
				+             * // This is equivalent to:
			
 
				+             * // buf2.set(buf1.subarray(16, 20), 8);
			
 
				+             *
			
 
				+             * console.log(buf2.toString('ascii', 0, 25));
			
 
				+             * // Prints: !!!!!!!!qrst!!!!!!!!!!!!!
			
 
				+             * ```
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * // Create a `Buffer` and copy data from one region to an overlapping region
			
 
				+             * // within the same `Buffer`.
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(26);
			
 
				+             *
			
 
				+             * for (let i = 0; i < 26; i++) {
			
 
				+             *   // 97 is the decimal ASCII value for 'a'.
			
 
				+             *   buf[i] = i + 97;
			
 
				+             * }
			
 
				+             *
			
 
				+             * buf.copy(buf, 0, 4, 10);
			
 
				+             *
			
 
				+             * console.log(buf.toString());
			
 
				+             * // Prints: efghijghijklmnopqrstuvwxyz
			
 
				+             * ```
			
 
				+             * @since v0.1.90
			
 
				+             * @param target A `Buffer` or {@link Uint8Array} to copy into.
			
 
				+             * @param [targetStart=0] The offset within `target` at which to begin writing.
			
 
				+             * @param [sourceStart=0] The offset within `buf` from which to begin copying.
			
 
				+             * @param [sourceEnd=buf.length] The offset within `buf` at which to stop copying (not inclusive).
			
 
				+             * @return The number of bytes copied.
			
 
				+             */
			
 
				+            copy(target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
			
 
				+            /**
			
 
				+             * Returns a new `Buffer` that references the same memory as the original, but
			
 
				+             * offset and cropped by the `start` and `end` indices.
			
 
				+             *
			
 
				+             * This method is not compatible with the `Uint8Array.prototype.slice()`,
			
 
				+             * which is a superclass of `Buffer`. To copy the slice, use`Uint8Array.prototype.slice()`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from('buffer');
			
 
				+             *
			
 
				+             * const copiedBuf = Uint8Array.prototype.slice.call(buf);
			
 
				+             * copiedBuf[0]++;
			
 
				+             * console.log(copiedBuf.toString());
			
 
				+             * // Prints: cuffer
			
 
				+             *
			
 
				+             * console.log(buf.toString());
			
 
				+             * // Prints: buffer
			
 
				+             *
			
 
				+             * // With buf.slice(), the original buffer is modified.
			
 
				+             * const notReallyCopiedBuf = buf.slice();
			
 
				+             * notReallyCopiedBuf[0]++;
			
 
				+             * console.log(notReallyCopiedBuf.toString());
			
 
				+             * // Prints: cuffer
			
 
				+             * console.log(buf.toString());
			
 
				+             * // Also prints: cuffer (!)
			
 
				+             * ```
			
 
				+             * @since v0.3.0
			
 
				+             * @deprecated Use `subarray` instead.
			
 
				+             * @param [start=0] Where the new `Buffer` will start.
			
 
				+             * @param [end=buf.length] Where the new `Buffer` will end (not inclusive).
			
 
				+             */
			
 
				+            slice(start?: number, end?: number): Buffer;
			
 
				+            /**
			
 
				+             * Returns a new `Buffer` that references the same memory as the original, but
			
 
				+             * offset and cropped by the `start` and `end` indices.
			
 
				+             *
			
 
				+             * Specifying `end` greater than `buf.length` will return the same result as
			
 
				+             * that of `end` equal to `buf.length`.
			
 
				+             *
			
 
				+             * This method is inherited from [`TypedArray.prototype.subarray()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray).
			
 
				+             *
			
 
				+             * Modifying the new `Buffer` slice will modify the memory in the original `Buffer`because the allocated memory of the two objects overlap.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * // Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte
			
 
				+             * // from the original `Buffer`.
			
 
				+             *
			
 
				+             * const buf1 = Buffer.allocUnsafe(26);
			
 
				+             *
			
 
				+             * for (let i = 0; i < 26; i++) {
			
 
				+             *   // 97 is the decimal ASCII value for 'a'.
			
 
				+             *   buf1[i] = i + 97;
			
 
				+             * }
			
 
				+             *
			
 
				+             * const buf2 = buf1.subarray(0, 3);
			
 
				+             *
			
 
				+             * console.log(buf2.toString('ascii', 0, buf2.length));
			
 
				+             * // Prints: abc
			
 
				+             *
			
 
				+             * buf1[0] = 33;
			
 
				+             *
			
 
				+             * console.log(buf2.toString('ascii', 0, buf2.length));
			
 
				+             * // Prints: !bc
			
 
				+             * ```
			
 
				+             *
			
 
				+             * Specifying negative indexes causes the slice to be generated relative to the
			
 
				+             * end of `buf` rather than the beginning.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from('buffer');
			
 
				+             *
			
 
				+             * console.log(buf.subarray(-6, -1).toString());
			
 
				+             * // Prints: buffe
			
 
				+             * // (Equivalent to buf.subarray(0, 5).)
			
 
				+             *
			
 
				+             * console.log(buf.subarray(-6, -2).toString());
			
 
				+             * // Prints: buff
			
 
				+             * // (Equivalent to buf.subarray(0, 4).)
			
 
				+             *
			
 
				+             * console.log(buf.subarray(-5, -2).toString());
			
 
				+             * // Prints: uff
			
 
				+             * // (Equivalent to buf.subarray(1, 4).)
			
 
				+             * ```
			
 
				+             * @since v3.0.0
			
 
				+             * @param [start=0] Where the new `Buffer` will start.
			
 
				+             * @param [end=buf.length] Where the new `Buffer` will end (not inclusive).
			
 
				+             */
			
 
				+            subarray(start?: number, end?: number): Buffer;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as big-endian.
			
 
				+             *
			
 
				+             * `value` is interpreted and written as a two's complement signed integer.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(8);
			
 
				+             *
			
 
				+             * buf.writeBigInt64BE(0x0102030405060708n, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 01 02 03 04 05 06 07 08>
			
 
				+             * ```
			
 
				+             * @since v12.0.0, v10.20.0
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeBigInt64BE(value: bigint, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as little-endian.
			
 
				+             *
			
 
				+             * `value` is interpreted and written as a two's complement signed integer.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(8);
			
 
				+             *
			
 
				+             * buf.writeBigInt64LE(0x0102030405060708n, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 08 07 06 05 04 03 02 01>
			
 
				+             * ```
			
 
				+             * @since v12.0.0, v10.20.0
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeBigInt64LE(value: bigint, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as big-endian.
			
 
				+             *
			
 
				+             * This function is also available under the `writeBigUint64BE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(8);
			
 
				+             *
			
 
				+             * buf.writeBigUInt64BE(0xdecafafecacefaden, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer de ca fa fe ca ce fa de>
			
 
				+             * ```
			
 
				+             * @since v12.0.0, v10.20.0
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeBigUInt64BE(value: bigint, offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.writeBigUInt64BE
			
 
				+             * @since v14.10.0, v12.19.0
			
 
				+             */
			
 
				+            writeBigUint64BE(value: bigint, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as little-endian
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(8);
			
 
				+             *
			
 
				+             * buf.writeBigUInt64LE(0xdecafafecacefaden, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer de fa ce ca fe fa ca de>
			
 
				+             * ```
			
 
				+             *
			
 
				+             * This function is also available under the `writeBigUint64LE` alias.
			
 
				+             * @since v12.0.0, v10.20.0
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeBigUInt64LE(value: bigint, offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.writeBigUInt64LE
			
 
				+             * @since v14.10.0, v12.19.0
			
 
				+             */
			
 
				+            writeBigUint64LE(value: bigint, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
			
 
				+             * when `value` is anything other than an unsigned integer.
			
 
				+             *
			
 
				+             * This function is also available under the `writeUintLE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(6);
			
 
				+             *
			
 
				+             * buf.writeUIntLE(0x1234567890ab, 0, 6);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer ab 90 78 56 34 12>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`.
			
 
				+             * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeUIntLE(value: number, offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.writeUIntLE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            writeUintLE(value: number, offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined
			
 
				+             * when `value` is anything other than an unsigned integer.
			
 
				+             *
			
 
				+             * This function is also available under the `writeUintBE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(6);
			
 
				+             *
			
 
				+             * buf.writeUIntBE(0x1234567890ab, 0, 6);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 12 34 56 78 90 ab>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`.
			
 
				+             * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeUIntBE(value: number, offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.writeUIntBE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            writeUintBE(value: number, offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
			
 
				+             * when `value` is anything other than a signed integer.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(6);
			
 
				+             *
			
 
				+             * buf.writeIntLE(0x1234567890ab, 0, 6);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer ab 90 78 56 34 12>
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`.
			
 
				+             * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeIntLE(value: number, offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when`value` is anything other than a
			
 
				+             * signed integer.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(6);
			
 
				+             *
			
 
				+             * buf.writeIntBE(0x1234567890ab, 0, 6);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 12 34 56 78 90 ab>
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`.
			
 
				+             * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeIntBE(value: number, offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * Reads an unsigned, big-endian 64-bit integer from `buf` at the specified`offset`.
			
 
				+             *
			
 
				+             * This function is also available under the `readBigUint64BE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);
			
 
				+             *
			
 
				+             * console.log(buf.readBigUInt64BE(0));
			
 
				+             * // Prints: 4294967295n
			
 
				+             * ```
			
 
				+             * @since v12.0.0, v10.20.0
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`.
			
 
				+             */
			
 
				+            readBigUInt64BE(offset?: number): bigint;
			
 
				+            /**
			
 
				+             * @alias Buffer.readBigUInt64BE
			
 
				+             * @since v14.10.0, v12.19.0
			
 
				+             */
			
 
				+            readBigUint64BE(offset?: number): bigint;
			
 
				+            /**
			
 
				+             * Reads an unsigned, little-endian 64-bit integer from `buf` at the specified`offset`.
			
 
				+             *
			
 
				+             * This function is also available under the `readBigUint64LE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);
			
 
				+             *
			
 
				+             * console.log(buf.readBigUInt64LE(0));
			
 
				+             * // Prints: 18446744069414584320n
			
 
				+             * ```
			
 
				+             * @since v12.0.0, v10.20.0
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`.
			
 
				+             */
			
 
				+            readBigUInt64LE(offset?: number): bigint;
			
 
				+            /**
			
 
				+             * @alias Buffer.readBigUInt64LE
			
 
				+             * @since v14.10.0, v12.19.0
			
 
				+             */
			
 
				+            readBigUint64LE(offset?: number): bigint;
			
 
				+            /**
			
 
				+             * Reads a signed, big-endian 64-bit integer from `buf` at the specified `offset`.
			
 
				+             *
			
 
				+             * Integers read from a `Buffer` are interpreted as two's complement signed
			
 
				+             * values.
			
 
				+             * @since v12.0.0, v10.20.0
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`.
			
 
				+             */
			
 
				+            readBigInt64BE(offset?: number): bigint;
			
 
				+            /**
			
 
				+             * Reads a signed, little-endian 64-bit integer from `buf` at the specified`offset`.
			
 
				+             *
			
 
				+             * Integers read from a `Buffer` are interpreted as two's complement signed
			
 
				+             * values.
			
 
				+             * @since v12.0.0, v10.20.0
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`.
			
 
				+             */
			
 
				+            readBigInt64LE(offset?: number): bigint;
			
 
				+            /**
			
 
				+             * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as an unsigned, little-endian integer supporting
			
 
				+             * up to 48 bits of accuracy.
			
 
				+             *
			
 
				+             * This function is also available under the `readUintLE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
			
 
				+             *
			
 
				+             * console.log(buf.readUIntLE(0, 6).toString(16));
			
 
				+             * // Prints: ab9078563412
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`.
			
 
				+             * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`.
			
 
				+             */
			
 
				+            readUIntLE(offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.readUIntLE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            readUintLE(offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as an unsigned big-endian integer supporting
			
 
				+             * up to 48 bits of accuracy.
			
 
				+             *
			
 
				+             * This function is also available under the `readUintBE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
			
 
				+             *
			
 
				+             * console.log(buf.readUIntBE(0, 6).toString(16));
			
 
				+             * // Prints: 1234567890ab
			
 
				+             * console.log(buf.readUIntBE(1, 6).toString(16));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`.
			
 
				+             * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`.
			
 
				+             */
			
 
				+            readUIntBE(offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.readUIntBE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            readUintBE(offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as a little-endian, two's complement signed value
			
 
				+             * supporting up to 48 bits of accuracy.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
			
 
				+             *
			
 
				+             * console.log(buf.readIntLE(0, 6).toString(16));
			
 
				+             * // Prints: -546f87a9cbee
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`.
			
 
				+             * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`.
			
 
				+             */
			
 
				+            readIntLE(offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as a big-endian, two's complement signed value
			
 
				+             * supporting up to 48 bits of accuracy.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
			
 
				+             *
			
 
				+             * console.log(buf.readIntBE(0, 6).toString(16));
			
 
				+             * // Prints: 1234567890ab
			
 
				+             * console.log(buf.readIntBE(1, 6).toString(16));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * console.log(buf.readIntBE(1, 0).toString(16));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`.
			
 
				+             * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`.
			
 
				+             */
			
 
				+            readIntBE(offset: number, byteLength: number): number;
			
 
				+            /**
			
 
				+             * Reads an unsigned 8-bit integer from `buf` at the specified `offset`.
			
 
				+             *
			
 
				+             * This function is also available under the `readUint8` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([1, -2]);
			
 
				+             *
			
 
				+             * console.log(buf.readUInt8(0));
			
 
				+             * // Prints: 1
			
 
				+             * console.log(buf.readUInt8(1));
			
 
				+             * // Prints: 254
			
 
				+             * console.log(buf.readUInt8(2));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.5.0
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 1`.
			
 
				+             */
			
 
				+            readUInt8(offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.readUInt8
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            readUint8(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads an unsigned, little-endian 16-bit integer from `buf` at the specified`offset`.
			
 
				+             *
			
 
				+             * This function is also available under the `readUint16LE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x12, 0x34, 0x56]);
			
 
				+             *
			
 
				+             * console.log(buf.readUInt16LE(0).toString(16));
			
 
				+             * // Prints: 3412
			
 
				+             * console.log(buf.readUInt16LE(1).toString(16));
			
 
				+             * // Prints: 5634
			
 
				+             * console.log(buf.readUInt16LE(2).toString(16));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`.
			
 
				+             */
			
 
				+            readUInt16LE(offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.readUInt16LE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            readUint16LE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads an unsigned, big-endian 16-bit integer from `buf` at the specified`offset`.
			
 
				+             *
			
 
				+             * This function is also available under the `readUint16BE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x12, 0x34, 0x56]);
			
 
				+             *
			
 
				+             * console.log(buf.readUInt16BE(0).toString(16));
			
 
				+             * // Prints: 1234
			
 
				+             * console.log(buf.readUInt16BE(1).toString(16));
			
 
				+             * // Prints: 3456
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`.
			
 
				+             */
			
 
				+            readUInt16BE(offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.readUInt16BE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            readUint16BE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads an unsigned, little-endian 32-bit integer from `buf` at the specified`offset`.
			
 
				+             *
			
 
				+             * This function is also available under the `readUint32LE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);
			
 
				+             *
			
 
				+             * console.log(buf.readUInt32LE(0).toString(16));
			
 
				+             * // Prints: 78563412
			
 
				+             * console.log(buf.readUInt32LE(1).toString(16));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             */
			
 
				+            readUInt32LE(offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.readUInt32LE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            readUint32LE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads an unsigned, big-endian 32-bit integer from `buf` at the specified`offset`.
			
 
				+             *
			
 
				+             * This function is also available under the `readUint32BE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);
			
 
				+             *
			
 
				+             * console.log(buf.readUInt32BE(0).toString(16));
			
 
				+             * // Prints: 12345678
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             */
			
 
				+            readUInt32BE(offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.readUInt32BE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            readUint32BE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads a signed 8-bit integer from `buf` at the specified `offset`.
			
 
				+             *
			
 
				+             * Integers read from a `Buffer` are interpreted as two's complement signed values.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([-1, 5]);
			
 
				+             *
			
 
				+             * console.log(buf.readInt8(0));
			
 
				+             * // Prints: -1
			
 
				+             * console.log(buf.readInt8(1));
			
 
				+             * // Prints: 5
			
 
				+             * console.log(buf.readInt8(2));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.5.0
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 1`.
			
 
				+             */
			
 
				+            readInt8(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads a signed, little-endian 16-bit integer from `buf` at the specified`offset`.
			
 
				+             *
			
 
				+             * Integers read from a `Buffer` are interpreted as two's complement signed values.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0, 5]);
			
 
				+             *
			
 
				+             * console.log(buf.readInt16LE(0));
			
 
				+             * // Prints: 1280
			
 
				+             * console.log(buf.readInt16LE(1));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`.
			
 
				+             */
			
 
				+            readInt16LE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads a signed, big-endian 16-bit integer from `buf` at the specified `offset`.
			
 
				+             *
			
 
				+             * Integers read from a `Buffer` are interpreted as two's complement signed values.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0, 5]);
			
 
				+             *
			
 
				+             * console.log(buf.readInt16BE(0));
			
 
				+             * // Prints: 5
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`.
			
 
				+             */
			
 
				+            readInt16BE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads a signed, little-endian 32-bit integer from `buf` at the specified`offset`.
			
 
				+             *
			
 
				+             * Integers read from a `Buffer` are interpreted as two's complement signed values.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0, 0, 0, 5]);
			
 
				+             *
			
 
				+             * console.log(buf.readInt32LE(0));
			
 
				+             * // Prints: 83886080
			
 
				+             * console.log(buf.readInt32LE(1));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             */
			
 
				+            readInt32LE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads a signed, big-endian 32-bit integer from `buf` at the specified `offset`.
			
 
				+             *
			
 
				+             * Integers read from a `Buffer` are interpreted as two's complement signed values.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([0, 0, 0, 5]);
			
 
				+             *
			
 
				+             * console.log(buf.readInt32BE(0));
			
 
				+             * // Prints: 5
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             */
			
 
				+            readInt32BE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads a 32-bit, little-endian float from `buf` at the specified `offset`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([1, 2, 3, 4]);
			
 
				+             *
			
 
				+             * console.log(buf.readFloatLE(0));
			
 
				+             * // Prints: 1.539989614439558e-36
			
 
				+             * console.log(buf.readFloatLE(1));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             */
			
 
				+            readFloatLE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads a 32-bit, big-endian float from `buf` at the specified `offset`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([1, 2, 3, 4]);
			
 
				+             *
			
 
				+             * console.log(buf.readFloatBE(0));
			
 
				+             * // Prints: 2.387939260590663e-38
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             */
			
 
				+            readFloatBE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads a 64-bit, little-endian double from `buf` at the specified `offset`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
			
 
				+             *
			
 
				+             * console.log(buf.readDoubleLE(0));
			
 
				+             * // Prints: 5.447603722011605e-270
			
 
				+             * console.log(buf.readDoubleLE(1));
			
 
				+             * // Throws ERR_OUT_OF_RANGE.
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 8`.
			
 
				+             */
			
 
				+            readDoubleLE(offset?: number): number;
			
 
				+            /**
			
 
				+             * Reads a 64-bit, big-endian double from `buf` at the specified `offset`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
			
 
				+             *
			
 
				+             * console.log(buf.readDoubleBE(0));
			
 
				+             * // Prints: 8.20788039913184e-304
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 8`.
			
 
				+             */
			
 
				+            readDoubleBE(offset?: number): number;
			
 
				+            reverse(): this;
			
 
				+            /**
			
 
				+             * Interprets `buf` as an array of unsigned 16-bit integers and swaps the
			
 
				+             * byte order _in-place_. Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 2.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
			
 
				+             *
			
 
				+             * console.log(buf1);
			
 
				+             * // Prints: <Buffer 01 02 03 04 05 06 07 08>
			
 
				+             *
			
 
				+             * buf1.swap16();
			
 
				+             *
			
 
				+             * console.log(buf1);
			
 
				+             * // Prints: <Buffer 02 01 04 03 06 05 08 07>
			
 
				+             *
			
 
				+             * const buf2 = Buffer.from([0x1, 0x2, 0x3]);
			
 
				+             *
			
 
				+             * buf2.swap16();
			
 
				+             * // Throws ERR_INVALID_BUFFER_SIZE.
			
 
				+             * ```
			
 
				+             *
			
 
				+             * One convenient use of `buf.swap16()` is to perform a fast in-place conversion
			
 
				+             * between UTF-16 little-endian and UTF-16 big-endian:
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from('This is little-endian UTF-16', 'utf16le');
			
 
				+             * buf.swap16(); // Convert to big-endian UTF-16 text.
			
 
				+             * ```
			
 
				+             * @since v5.10.0
			
 
				+             * @return A reference to `buf`.
			
 
				+             */
			
 
				+            swap16(): Buffer;
			
 
				+            /**
			
 
				+             * Interprets `buf` as an array of unsigned 32-bit integers and swaps the
			
 
				+             * byte order _in-place_. Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 4.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
			
 
				+             *
			
 
				+             * console.log(buf1);
			
 
				+             * // Prints: <Buffer 01 02 03 04 05 06 07 08>
			
 
				+             *
			
 
				+             * buf1.swap32();
			
 
				+             *
			
 
				+             * console.log(buf1);
			
 
				+             * // Prints: <Buffer 04 03 02 01 08 07 06 05>
			
 
				+             *
			
 
				+             * const buf2 = Buffer.from([0x1, 0x2, 0x3]);
			
 
				+             *
			
 
				+             * buf2.swap32();
			
 
				+             * // Throws ERR_INVALID_BUFFER_SIZE.
			
 
				+             * ```
			
 
				+             * @since v5.10.0
			
 
				+             * @return A reference to `buf`.
			
 
				+             */
			
 
				+            swap32(): Buffer;
			
 
				+            /**
			
 
				+             * Interprets `buf` as an array of 64-bit numbers and swaps byte order _in-place_.
			
 
				+             * Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 8.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
			
 
				+             *
			
 
				+             * console.log(buf1);
			
 
				+             * // Prints: <Buffer 01 02 03 04 05 06 07 08>
			
 
				+             *
			
 
				+             * buf1.swap64();
			
 
				+             *
			
 
				+             * console.log(buf1);
			
 
				+             * // Prints: <Buffer 08 07 06 05 04 03 02 01>
			
 
				+             *
			
 
				+             * const buf2 = Buffer.from([0x1, 0x2, 0x3]);
			
 
				+             *
			
 
				+             * buf2.swap64();
			
 
				+             * // Throws ERR_INVALID_BUFFER_SIZE.
			
 
				+             * ```
			
 
				+             * @since v6.3.0
			
 
				+             * @return A reference to `buf`.
			
 
				+             */
			
 
				+            swap64(): Buffer;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset`. `value` must be a
			
 
				+             * valid unsigned 8-bit integer. Behavior is undefined when `value` is anything
			
 
				+             * other than an unsigned 8-bit integer.
			
 
				+             *
			
 
				+             * This function is also available under the `writeUint8` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(4);
			
 
				+             *
			
 
				+             * buf.writeUInt8(0x3, 0);
			
 
				+             * buf.writeUInt8(0x4, 1);
			
 
				+             * buf.writeUInt8(0x23, 2);
			
 
				+             * buf.writeUInt8(0x42, 3);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 03 04 23 42>
			
 
				+             * ```
			
 
				+             * @since v0.5.0
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 1`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeUInt8(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.writeUInt8
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            writeUint8(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid unsigned 16-bit integer. Behavior is undefined when `value` is
			
 
				+             * anything other than an unsigned 16-bit integer.
			
 
				+             *
			
 
				+             * This function is also available under the `writeUint16LE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(4);
			
 
				+             *
			
 
				+             * buf.writeUInt16LE(0xdead, 0);
			
 
				+             * buf.writeUInt16LE(0xbeef, 2);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer ad de ef be>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeUInt16LE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.writeUInt16LE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            writeUint16LE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid unsigned 16-bit integer. Behavior is undefined when `value`is anything other than an
			
 
				+             * unsigned 16-bit integer.
			
 
				+             *
			
 
				+             * This function is also available under the `writeUint16BE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(4);
			
 
				+             *
			
 
				+             * buf.writeUInt16BE(0xdead, 0);
			
 
				+             * buf.writeUInt16BE(0xbeef, 2);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer de ad be ef>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeUInt16BE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.writeUInt16BE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            writeUint16BE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid unsigned 32-bit integer. Behavior is undefined when `value` is
			
 
				+             * anything other than an unsigned 32-bit integer.
			
 
				+             *
			
 
				+             * This function is also available under the `writeUint32LE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(4);
			
 
				+             *
			
 
				+             * buf.writeUInt32LE(0xfeedface, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer ce fa ed fe>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeUInt32LE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.writeUInt32LE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            writeUint32LE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid unsigned 32-bit integer. Behavior is undefined when `value`is anything other than an
			
 
				+             * unsigned 32-bit integer.
			
 
				+             *
			
 
				+             * This function is also available under the `writeUint32BE` alias.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(4);
			
 
				+             *
			
 
				+             * buf.writeUInt32BE(0xfeedface, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer fe ed fa ce>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeUInt32BE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * @alias Buffer.writeUInt32BE
			
 
				+             * @since v14.9.0, v12.19.0
			
 
				+             */
			
 
				+            writeUint32BE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset`. `value` must be a valid
			
 
				+             * signed 8-bit integer. Behavior is undefined when `value` is anything other than
			
 
				+             * a signed 8-bit integer.
			
 
				+             *
			
 
				+             * `value` is interpreted and written as a two's complement signed integer.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(2);
			
 
				+             *
			
 
				+             * buf.writeInt8(2, 0);
			
 
				+             * buf.writeInt8(-2, 1);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 02 fe>
			
 
				+             * ```
			
 
				+             * @since v0.5.0
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 1`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeInt8(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as little-endian.  The `value`must be a valid signed 16-bit integer. Behavior is undefined when `value` is
			
 
				+             * anything other than a signed 16-bit integer.
			
 
				+             *
			
 
				+             * The `value` is interpreted and written as a two's complement signed integer.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(2);
			
 
				+             *
			
 
				+             * buf.writeInt16LE(0x0304, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 04 03>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeInt16LE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as big-endian.  The `value`must be a valid signed 16-bit integer. Behavior is undefined when `value` is
			
 
				+             * anything other than a signed 16-bit integer.
			
 
				+             *
			
 
				+             * The `value` is interpreted and written as a two's complement signed integer.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(2);
			
 
				+             *
			
 
				+             * buf.writeInt16BE(0x0102, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 01 02>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeInt16BE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid signed 32-bit integer. Behavior is undefined when `value` is
			
 
				+             * anything other than a signed 32-bit integer.
			
 
				+             *
			
 
				+             * The `value` is interpreted and written as a two's complement signed integer.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(4);
			
 
				+             *
			
 
				+             * buf.writeInt32LE(0x05060708, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 08 07 06 05>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeInt32LE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid signed 32-bit integer. Behavior is undefined when `value` is
			
 
				+             * anything other than a signed 32-bit integer.
			
 
				+             *
			
 
				+             * The `value` is interpreted and written as a two's complement signed integer.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(4);
			
 
				+             *
			
 
				+             * buf.writeInt32BE(0x01020304, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 01 02 03 04>
			
 
				+             * ```
			
 
				+             * @since v0.5.5
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeInt32BE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as little-endian. Behavior is
			
 
				+             * undefined when `value` is anything other than a JavaScript number.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(4);
			
 
				+             *
			
 
				+             * buf.writeFloatLE(0xcafebabe, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer bb fe 4a 4f>
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeFloatLE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as big-endian. Behavior is
			
 
				+             * undefined when `value` is anything other than a JavaScript number.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(4);
			
 
				+             *
			
 
				+             * buf.writeFloatBE(0xcafebabe, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 4f 4a fe bb>
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeFloatBE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a JavaScript number. Behavior is undefined when `value` is anything
			
 
				+             * other than a JavaScript number.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(8);
			
 
				+             *
			
 
				+             * buf.writeDoubleLE(123.456, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 77 be 9f 1a 2f dd 5e 40>
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 8`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeDoubleLE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a JavaScript number. Behavior is undefined when `value` is anything
			
 
				+             * other than a JavaScript number.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(8);
			
 
				+             *
			
 
				+             * buf.writeDoubleBE(123.456, 0);
			
 
				+             *
			
 
				+             * console.log(buf);
			
 
				+             * // Prints: <Buffer 40 5e dd 2f 1a 9f be 77>
			
 
				+             * ```
			
 
				+             * @since v0.11.15
			
 
				+             * @param value Number to be written to `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 8`.
			
 
				+             * @return `offset` plus the number of bytes written.
			
 
				+             */
			
 
				+            writeDoubleBE(value: number, offset?: number): number;
			
 
				+            /**
			
 
				+             * Fills `buf` with the specified `value`. If the `offset` and `end` are not given,
			
 
				+             * the entire `buf` will be filled:
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * // Fill a `Buffer` with the ASCII character 'h'.
			
 
				+             *
			
 
				+             * const b = Buffer.allocUnsafe(50).fill('h');
			
 
				+             *
			
 
				+             * console.log(b.toString());
			
 
				+             * // Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
			
 
				+             * ```
			
 
				+             *
			
 
				+             * `value` is coerced to a `uint32` value if it is not a string, `Buffer`, or
			
 
				+             * integer. If the resulting integer is greater than `255` (decimal), `buf` will be
			
 
				+             * filled with `value &#x26; 255`.
			
 
				+             *
			
 
				+             * If the final write of a `fill()` operation falls on a multi-byte character,
			
 
				+             * then only the bytes of that character that fit into `buf` are written:
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * // Fill a `Buffer` with character that takes up two bytes in UTF-8.
			
 
				+             *
			
 
				+             * console.log(Buffer.allocUnsafe(5).fill('\u0222'));
			
 
				+             * // Prints: <Buffer c8 a2 c8 a2 c8>
			
 
				+             * ```
			
 
				+             *
			
 
				+             * If `value` contains invalid characters, it is truncated; if no valid
			
 
				+             * fill data remains, an exception is thrown:
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.allocUnsafe(5);
			
 
				+             *
			
 
				+             * console.log(buf.fill('a'));
			
 
				+             * // Prints: <Buffer 61 61 61 61 61>
			
 
				+             * console.log(buf.fill('aazz', 'hex'));
			
 
				+             * // Prints: <Buffer aa aa aa aa aa>
			
 
				+             * console.log(buf.fill('zz', 'hex'));
			
 
				+             * // Throws an exception.
			
 
				+             * ```
			
 
				+             * @since v0.5.0
			
 
				+             * @param value The value with which to fill `buf`.
			
 
				+             * @param [offset=0] Number of bytes to skip before starting to fill `buf`.
			
 
				+             * @param [end=buf.length] Where to stop filling `buf` (not inclusive).
			
 
				+             * @param [encoding='utf8'] The encoding for `value` if `value` is a string.
			
 
				+             * @return A reference to `buf`.
			
 
				+             */
			
 
				+            fill(value: string | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): this;
			
 
				+            /**
			
 
				+             * If `value` is:
			
 
				+             *
			
 
				+             * * a string, `value` is interpreted according to the character encoding in`encoding`.
			
 
				+             * * a `Buffer` or [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), `value` will be used in its entirety.
			
 
				+             * To compare a partial `Buffer`, use `buf.subarray`.
			
 
				+             * * a number, `value` will be interpreted as an unsigned 8-bit integer
			
 
				+             * value between `0` and `255`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from('this is a buffer');
			
 
				+             *
			
 
				+             * console.log(buf.indexOf('this'));
			
 
				+             * // Prints: 0
			
 
				+             * console.log(buf.indexOf('is'));
			
 
				+             * // Prints: 2
			
 
				+             * console.log(buf.indexOf(Buffer.from('a buffer')));
			
 
				+             * // Prints: 8
			
 
				+             * console.log(buf.indexOf(97));
			
 
				+             * // Prints: 8 (97 is the decimal ASCII value for 'a')
			
 
				+             * console.log(buf.indexOf(Buffer.from('a buffer example')));
			
 
				+             * // Prints: -1
			
 
				+             * console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));
			
 
				+             * // Prints: 8
			
 
				+             *
			
 
				+             * const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le');
			
 
				+             *
			
 
				+             * console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'));
			
 
				+             * // Prints: 4
			
 
				+             * console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'));
			
 
				+             * // Prints: 6
			
 
				+             * ```
			
 
				+             *
			
 
				+             * If `value` is not a string, number, or `Buffer`, this method will throw a`TypeError`. If `value` is a number, it will be coerced to a valid byte value,
			
 
				+             * an integer between 0 and 255.
			
 
				+             *
			
 
				+             * If `byteOffset` is not a number, it will be coerced to a number. If the result
			
 
				+             * of coercion is `NaN` or `0`, then the entire buffer will be searched. This
			
 
				+             * behavior matches [`String.prototype.indexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf).
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const b = Buffer.from('abcdef');
			
 
				+             *
			
 
				+             * // Passing a value that's a number, but not a valid byte.
			
 
				+             * // Prints: 2, equivalent to searching for 99 or 'c'.
			
 
				+             * console.log(b.indexOf(99.9));
			
 
				+             * console.log(b.indexOf(256 + 99));
			
 
				+             *
			
 
				+             * // Passing a byteOffset that coerces to NaN or 0.
			
 
				+             * // Prints: 1, searching the whole buffer.
			
 
				+             * console.log(b.indexOf('b', undefined));
			
 
				+             * console.log(b.indexOf('b', {}));
			
 
				+             * console.log(b.indexOf('b', null));
			
 
				+             * console.log(b.indexOf('b', []));
			
 
				+             * ```
			
 
				+             *
			
 
				+             * If `value` is an empty string or empty `Buffer` and `byteOffset` is less
			
 
				+             * than `buf.length`, `byteOffset` will be returned. If `value` is empty and`byteOffset` is at least `buf.length`, `buf.length` will be returned.
			
 
				+             * @since v1.5.0
			
 
				+             * @param value What to search for.
			
 
				+             * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`.
			
 
				+             * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`.
			
 
				+             * @return The index of the first occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`.
			
 
				+             */
			
 
				+            indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
			
 
				+            /**
			
 
				+             * Identical to `buf.indexOf()`, except the last occurrence of `value` is found
			
 
				+             * rather than the first occurrence.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from('this buffer is a buffer');
			
 
				+             *
			
 
				+             * console.log(buf.lastIndexOf('this'));
			
 
				+             * // Prints: 0
			
 
				+             * console.log(buf.lastIndexOf('buffer'));
			
 
				+             * // Prints: 17
			
 
				+             * console.log(buf.lastIndexOf(Buffer.from('buffer')));
			
 
				+             * // Prints: 17
			
 
				+             * console.log(buf.lastIndexOf(97));
			
 
				+             * // Prints: 15 (97 is the decimal ASCII value for 'a')
			
 
				+             * console.log(buf.lastIndexOf(Buffer.from('yolo')));
			
 
				+             * // Prints: -1
			
 
				+             * console.log(buf.lastIndexOf('buffer', 5));
			
 
				+             * // Prints: 5
			
 
				+             * console.log(buf.lastIndexOf('buffer', 4));
			
 
				+             * // Prints: -1
			
 
				+             *
			
 
				+             * const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le');
			
 
				+             *
			
 
				+             * console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'));
			
 
				+             * // Prints: 6
			
 
				+             * console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'));
			
 
				+             * // Prints: 4
			
 
				+             * ```
			
 
				+             *
			
 
				+             * If `value` is not a string, number, or `Buffer`, this method will throw a`TypeError`. If `value` is a number, it will be coerced to a valid byte value,
			
 
				+             * an integer between 0 and 255.
			
 
				+             *
			
 
				+             * If `byteOffset` is not a number, it will be coerced to a number. Any arguments
			
 
				+             * that coerce to `NaN`, like `{}` or `undefined`, will search the whole buffer.
			
 
				+             * This behavior matches [`String.prototype.lastIndexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf).
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const b = Buffer.from('abcdef');
			
 
				+             *
			
 
				+             * // Passing a value that's a number, but not a valid byte.
			
 
				+             * // Prints: 2, equivalent to searching for 99 or 'c'.
			
 
				+             * console.log(b.lastIndexOf(99.9));
			
 
				+             * console.log(b.lastIndexOf(256 + 99));
			
 
				+             *
			
 
				+             * // Passing a byteOffset that coerces to NaN.
			
 
				+             * // Prints: 1, searching the whole buffer.
			
 
				+             * console.log(b.lastIndexOf('b', undefined));
			
 
				+             * console.log(b.lastIndexOf('b', {}));
			
 
				+             *
			
 
				+             * // Passing a byteOffset that coerces to 0.
			
 
				+             * // Prints: -1, equivalent to passing 0.
			
 
				+             * console.log(b.lastIndexOf('b', null));
			
 
				+             * console.log(b.lastIndexOf('b', []));
			
 
				+             * ```
			
 
				+             *
			
 
				+             * If `value` is an empty string or empty `Buffer`, `byteOffset` will be returned.
			
 
				+             * @since v6.0.0
			
 
				+             * @param value What to search for.
			
 
				+             * @param [byteOffset=buf.length - 1] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`.
			
 
				+             * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`.
			
 
				+             * @return The index of the last occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`.
			
 
				+             */
			
 
				+            lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
			
 
				+            /**
			
 
				+             * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) of `[index, byte]` pairs from the contents
			
 
				+             * of `buf`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * // Log the entire contents of a `Buffer`.
			
 
				+             *
			
 
				+             * const buf = Buffer.from('buffer');
			
 
				+             *
			
 
				+             * for (const pair of buf.entries()) {
			
 
				+             *   console.log(pair);
			
 
				+             * }
			
 
				+             * // Prints:
			
 
				+             * //   [0, 98]
			
 
				+             * //   [1, 117]
			
 
				+             * //   [2, 102]
			
 
				+             * //   [3, 102]
			
 
				+             * //   [4, 101]
			
 
				+             * //   [5, 114]
			
 
				+             * ```
			
 
				+             * @since v1.1.0
			
 
				+             */
			
 
				+            entries(): IterableIterator<[number, number]>;
			
 
				+            /**
			
 
				+             * Equivalent to `buf.indexOf() !== -1`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from('this is a buffer');
			
 
				+             *
			
 
				+             * console.log(buf.includes('this'));
			
 
				+             * // Prints: true
			
 
				+             * console.log(buf.includes('is'));
			
 
				+             * // Prints: true
			
 
				+             * console.log(buf.includes(Buffer.from('a buffer')));
			
 
				+             * // Prints: true
			
 
				+             * console.log(buf.includes(97));
			
 
				+             * // Prints: true (97 is the decimal ASCII value for 'a')
			
 
				+             * console.log(buf.includes(Buffer.from('a buffer example')));
			
 
				+             * // Prints: false
			
 
				+             * console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
			
 
				+             * // Prints: true
			
 
				+             * console.log(buf.includes('this', 4));
			
 
				+             * // Prints: false
			
 
				+             * ```
			
 
				+             * @since v5.3.0
			
 
				+             * @param value What to search for.
			
 
				+             * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`.
			
 
				+             * @param [encoding='utf8'] If `value` is a string, this is its encoding.
			
 
				+             * @return `true` if `value` was found in `buf`, `false` otherwise.
			
 
				+             */
			
 
				+            includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
			
 
				+            /**
			
 
				+             * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) of `buf` keys (indices).
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from('buffer');
			
 
				+             *
			
 
				+             * for (const key of buf.keys()) {
			
 
				+             *   console.log(key);
			
 
				+             * }
			
 
				+             * // Prints:
			
 
				+             * //   0
			
 
				+             * //   1
			
 
				+             * //   2
			
 
				+             * //   3
			
 
				+             * //   4
			
 
				+             * //   5
			
 
				+             * ```
			
 
				+             * @since v1.1.0
			
 
				+             */
			
 
				+            keys(): IterableIterator<number>;
			
 
				+            /**
			
 
				+             * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) for `buf` values (bytes). This function is
			
 
				+             * called automatically when a `Buffer` is used in a `for..of` statement.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * import { Buffer } from 'buffer';
			
 
				+             *
			
 
				+             * const buf = Buffer.from('buffer');
			
 
				+             *
			
 
				+             * for (const value of buf.values()) {
			
 
				+             *   console.log(value);
			
 
				+             * }
			
 
				+             * // Prints:
			
 
				+             * //   98
			
 
				+             * //   117
			
 
				+             * //   102
			
 
				+             * //   102
			
 
				+             * //   101
			
 
				+             * //   114
			
 
				+             *
			
 
				+             * for (const value of buf) {
			
 
				+             *   console.log(value);
			
 
				+             * }
			
 
				+             * // Prints:
			
 
				+             * //   98
			
 
				+             * //   117
			
 
				+             * //   102
			
 
				+             * //   102
			
 
				+             * //   101
			
 
				+             * //   114
			
 
				+             * ```
			
 
				+             * @since v1.1.0
			
 
				+             */
			
 
				+            values(): IterableIterator<number>;
			
 
				+        }
			
 
				+        var Buffer: BufferConstructor;
			
 
				+        /**
			
 
				+         * Decodes a string of Base64-encoded data into bytes, and encodes those bytes
			
 
				+         * into a string using Latin-1 (ISO-8859-1).
			
 
				+         *
			
 
				+         * The `data` may be any JavaScript-value that can be coerced into a string.
			
 
				+         *
			
 
				+         * **This function is only provided for compatibility with legacy web platform APIs**
			
 
				+         * **and should never be used in new code, because they use strings to represent**
			
 
				+         * **binary data and predate the introduction of typed arrays in JavaScript.**
			
 
				+         * **For code running using Node.js APIs, converting between base64-encoded strings**
			
 
				+         * **and binary data should be performed using `Buffer.from(str, 'base64')` and`buf.toString('base64')`.**
			
 
				+         * @since v15.13.0, v14.17.0
			
 
				+         * @deprecated Use `Buffer.from(data, 'base64')` instead.
			
 
				+         * @param data The Base64-encoded input string.
			
 
				+         */
			
 
				+        function atob(data: string): string;
			
 
				+        /**
			
 
				+         * Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes
			
 
				+         * into a string using Base64.
			
 
				+         *
			
 
				+         * The `data` may be any JavaScript-value that can be coerced into a string.
			
 
				+         *
			
 
				+         * **This function is only provided for compatibility with legacy web platform APIs**
			
 
				+         * **and should never be used in new code, because they use strings to represent**
			
 
				+         * **binary data and predate the introduction of typed arrays in JavaScript.**
			
 
				+         * **For code running using Node.js APIs, converting between base64-encoded strings**
			
 
				+         * **and binary data should be performed using `Buffer.from(str, 'base64')` and`buf.toString('base64')`.**
			
 
				+         * @since v15.13.0, v14.17.0
			
 
				+         * @deprecated Use `buf.toString('base64')` instead.
			
 
				+         * @param data An ASCII (Latin1) string.
			
 
				+         */
			
 
				+        function btoa(data: string): string;
			
 
				+
			
 
				+        interface Blob extends __Blob {}
			
 
				+        /**
			
 
				+         * `Blob` class is a global reference for `require('node:buffer').Blob`
			
 
				+         * https://nodejs.org/api/buffer.html#class-blob
			
 
				+         * @since v18.0.0
			
 
				+         */
			
 
				+        var Blob: typeof globalThis extends {
			
 
				+            onmessage: any;
			
 
				+            Blob: infer T;
			
 
				+        }
			
 
				+            ? T
			
 
				+            : typeof NodeBlob;
			
 
				+    }
			
 
				+}
			
 
				+declare module 'node:buffer' {
			
 
				+    export * from 'buffer';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/child_process.d.ts
+++ b/Asistent/node_modules/@types/node/child_process.d.ts
@@ -0,0 +1,1369 @@
 
				+/**
			
 
				+ * The `child_process` module provides the ability to spawn subprocesses in
			
 
				+ * a manner that is similar, but not identical, to [`popen(3)`](http://man7.org/linux/man-pages/man3/popen.3.html). This capability
			
 
				+ * is primarily provided by the {@link spawn} function:
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * const { spawn } = require('child_process');
			
 
				+ * const ls = spawn('ls', ['-lh', '/usr']);
			
 
				+ *
			
 
				+ * ls.stdout.on('data', (data) => {
			
 
				+ *   console.log(`stdout: ${data}`);
			
 
				+ * });
			
 
				+ *
			
 
				+ * ls.stderr.on('data', (data) => {
			
 
				+ *   console.error(`stderr: ${data}`);
			
 
				+ * });
			
 
				+ *
			
 
				+ * ls.on('close', (code) => {
			
 
				+ *   console.log(`child process exited with code ${code}`);
			
 
				+ * });
			
 
				+ * ```
			
 
				+ *
			
 
				+ * By default, pipes for `stdin`, `stdout`, and `stderr` are established between
			
 
				+ * the parent Node.js process and the spawned subprocess. These pipes have
			
 
				+ * limited (and platform-specific) capacity. If the subprocess writes to
			
 
				+ * stdout in excess of that limit without the output being captured, the
			
 
				+ * subprocess blocks waiting for the pipe buffer to accept more data. This is
			
 
				+ * identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }`option if the output will not be consumed.
			
 
				+ *
			
 
				+ * The command lookup is performed using the `options.env.PATH` environment
			
 
				+ * variable if `env` is in the `options` object. Otherwise, `process.env.PATH` is
			
 
				+ * used. If `options.env` is set without `PATH`, lookup on Unix is performed
			
 
				+ * on a default search path search of `/usr/bin:/bin` (see your operating system's
			
 
				+ * manual for execvpe/execvp), on Windows the current processes environment
			
 
				+ * variable `PATH` is used.
			
 
				+ *
			
 
				+ * On Windows, environment variables are case-insensitive. Node.js
			
 
				+ * lexicographically sorts the `env` keys and uses the first one that
			
 
				+ * case-insensitively matches. Only first (in lexicographic order) entry will be
			
 
				+ * passed to the subprocess. This might lead to issues on Windows when passing
			
 
				+ * objects to the `env` option that have multiple variants of the same key, such as`PATH` and `Path`.
			
 
				+ *
			
 
				+ * The {@link spawn} method spawns the child process asynchronously,
			
 
				+ * without blocking the Node.js event loop. The {@link spawnSync} function provides equivalent functionality in a synchronous manner that blocks
			
 
				+ * the event loop until the spawned process either exits or is terminated.
			
 
				+ *
			
 
				+ * For convenience, the `child_process` module provides a handful of synchronous
			
 
				+ * and asynchronous alternatives to {@link spawn} and {@link spawnSync}. Each of these alternatives are implemented on
			
 
				+ * top of {@link spawn} or {@link spawnSync}.
			
 
				+ *
			
 
				+ * * {@link exec}: spawns a shell and runs a command within that
			
 
				+ * shell, passing the `stdout` and `stderr` to a callback function when
			
 
				+ * complete.
			
 
				+ * * {@link execFile}: similar to {@link exec} except
			
 
				+ * that it spawns the command directly without first spawning a shell by
			
 
				+ * default.
			
 
				+ * * {@link fork}: spawns a new Node.js process and invokes a
			
 
				+ * specified module with an IPC communication channel established that allows
			
 
				+ * sending messages between parent and child.
			
 
				+ * * {@link execSync}: a synchronous version of {@link exec} that will block the Node.js event loop.
			
 
				+ * * {@link execFileSync}: a synchronous version of {@link execFile} that will block the Node.js event loop.
			
 
				+ *
			
 
				+ * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however,
			
 
				+ * the synchronous methods can have significant impact on performance due to
			
 
				+ * stalling the event loop while spawned processes complete.
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/child_process.js)
			
 
				+ */
			
 
				+declare module 'child_process' {
			
 
				+    import { ObjectEncodingOptions } from 'node:fs';
			
 
				+    import { EventEmitter, Abortable } from 'node:events';
			
 
				+    import * as net from 'node:net';
			
 
				+    import { Writable, Readable, Stream, Pipe } from 'node:stream';
			
 
				+    import { URL } from 'node:url';
			
 
				+    type Serializable = string | object | number | boolean | bigint;
			
 
				+    type SendHandle = net.Socket | net.Server;
			
 
				+    /**
			
 
				+     * Instances of the `ChildProcess` represent spawned child processes.
			
 
				+     *
			
 
				+     * Instances of `ChildProcess` are not intended to be created directly. Rather,
			
 
				+     * use the {@link spawn}, {@link exec},{@link execFile}, or {@link fork} methods to create
			
 
				+     * instances of `ChildProcess`.
			
 
				+     * @since v2.2.0
			
 
				+     */
			
 
				+    class ChildProcess extends EventEmitter {
			
 
				+        /**
			
 
				+         * A `Writable Stream` that represents the child process's `stdin`.
			
 
				+         *
			
 
				+         * If a child process waits to read all of its input, the child will not continue
			
 
				+         * until this stream has been closed via `end()`.
			
 
				+         *
			
 
				+         * If the child was spawned with `stdio[0]` set to anything other than `'pipe'`,
			
 
				+         * then this will be `null`.
			
 
				+         *
			
 
				+         * `subprocess.stdin` is an alias for `subprocess.stdio[0]`. Both properties will
			
 
				+         * refer to the same value.
			
 
				+         *
			
 
				+         * The `subprocess.stdin` property can be `undefined` if the child process could
			
 
				+         * not be successfully spawned.
			
 
				+         * @since v0.1.90
			
 
				+         */
			
 
				+        stdin: Writable | null;
			
 
				+        /**
			
 
				+         * A `Readable Stream` that represents the child process's `stdout`.
			
 
				+         *
			
 
				+         * If the child was spawned with `stdio[1]` set to anything other than `'pipe'`,
			
 
				+         * then this will be `null`.
			
 
				+         *
			
 
				+         * `subprocess.stdout` is an alias for `subprocess.stdio[1]`. Both properties will
			
 
				+         * refer to the same value.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { spawn } = require('child_process');
			
 
				+         *
			
 
				+         * const subprocess = spawn('ls');
			
 
				+         *
			
 
				+         * subprocess.stdout.on('data', (data) => {
			
 
				+         *   console.log(`Received chunk ${data}`);
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * The `subprocess.stdout` property can be `null` if the child process could
			
 
				+         * not be successfully spawned.
			
 
				+         * @since v0.1.90
			
 
				+         */
			
 
				+        stdout: Readable | null;
			
 
				+        /**
			
 
				+         * A `Readable Stream` that represents the child process's `stderr`.
			
 
				+         *
			
 
				+         * If the child was spawned with `stdio[2]` set to anything other than `'pipe'`,
			
 
				+         * then this will be `null`.
			
 
				+         *
			
 
				+         * `subprocess.stderr` is an alias for `subprocess.stdio[2]`. Both properties will
			
 
				+         * refer to the same value.
			
 
				+         *
			
 
				+         * The `subprocess.stderr` property can be `null` if the child process could
			
 
				+         * not be successfully spawned.
			
 
				+         * @since v0.1.90
			
 
				+         */
			
 
				+        stderr: Readable | null;
			
 
				+        /**
			
 
				+         * The `subprocess.channel` property is a reference to the child's IPC channel. If
			
 
				+         * no IPC channel currently exists, this property is `undefined`.
			
 
				+         * @since v7.1.0
			
 
				+         */
			
 
				+        readonly channel?: Pipe | null | undefined;
			
 
				+        /**
			
 
				+         * A sparse array of pipes to the child process, corresponding with positions in
			
 
				+         * the `stdio` option passed to {@link spawn} that have been set
			
 
				+         * to the value `'pipe'`. `subprocess.stdio[0]`, `subprocess.stdio[1]`, and`subprocess.stdio[2]` are also available as `subprocess.stdin`,`subprocess.stdout`, and `subprocess.stderr`,
			
 
				+         * respectively.
			
 
				+         *
			
 
				+         * In the following example, only the child's fd `1` (stdout) is configured as a
			
 
				+         * pipe, so only the parent's `subprocess.stdio[1]` is a stream, all other values
			
 
				+         * in the array are `null`.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const assert = require('assert');
			
 
				+         * const fs = require('fs');
			
 
				+         * const child_process = require('child_process');
			
 
				+         *
			
 
				+         * const subprocess = child_process.spawn('ls', {
			
 
				+         *   stdio: [
			
 
				+         *     0, // Use parent's stdin for child.
			
 
				+         *     'pipe', // Pipe child's stdout to parent.
			
 
				+         *     fs.openSync('err.out', 'w'), // Direct child's stderr to a file.
			
 
				+         *   ]
			
 
				+         * });
			
 
				+         *
			
 
				+         * assert.strictEqual(subprocess.stdio[0], null);
			
 
				+         * assert.strictEqual(subprocess.stdio[0], subprocess.stdin);
			
 
				+         *
			
 
				+         * assert(subprocess.stdout);
			
 
				+         * assert.strictEqual(subprocess.stdio[1], subprocess.stdout);
			
 
				+         *
			
 
				+         * assert.strictEqual(subprocess.stdio[2], null);
			
 
				+         * assert.strictEqual(subprocess.stdio[2], subprocess.stderr);
			
 
				+         * ```
			
 
				+         *
			
 
				+         * The `subprocess.stdio` property can be `undefined` if the child process could
			
 
				+         * not be successfully spawned.
			
 
				+         * @since v0.7.10
			
 
				+         */
			
 
				+        readonly stdio: [
			
 
				+            Writable | null,
			
 
				+            // stdin
			
 
				+            Readable | null,
			
 
				+            // stdout
			
 
				+            Readable | null,
			
 
				+            // stderr
			
 
				+            Readable | Writable | null | undefined,
			
 
				+            // extra
			
 
				+            Readable | Writable | null | undefined // extra
			
 
				+        ];
			
 
				+        /**
			
 
				+         * The `subprocess.killed` property indicates whether the child process
			
 
				+         * successfully received a signal from `subprocess.kill()`. The `killed` property
			
 
				+         * does not indicate that the child process has been terminated.
			
 
				+         * @since v0.5.10
			
 
				+         */
			
 
				+        readonly killed: boolean;
			
 
				+        /**
			
 
				+         * Returns the process identifier (PID) of the child process. If the child process
			
 
				+         * fails to spawn due to errors, then the value is `undefined` and `error` is
			
 
				+         * emitted.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { spawn } = require('child_process');
			
 
				+         * const grep = spawn('grep', ['ssh']);
			
 
				+         *
			
 
				+         * console.log(`Spawned child pid: ${grep.pid}`);
			
 
				+         * grep.stdin.end();
			
 
				+         * ```
			
 
				+         * @since v0.1.90
			
 
				+         */
			
 
				+        readonly pid?: number | undefined;
			
 
				+        /**
			
 
				+         * The `subprocess.connected` property indicates whether it is still possible to
			
 
				+         * send and receive messages from a child process. When `subprocess.connected` is`false`, it is no longer possible to send or receive messages.
			
 
				+         * @since v0.7.2
			
 
				+         */
			
 
				+        readonly connected: boolean;
			
 
				+        /**
			
 
				+         * The `subprocess.exitCode` property indicates the exit code of the child process.
			
 
				+         * If the child process is still running, the field will be `null`.
			
 
				+         */
			
 
				+        readonly exitCode: number | null;
			
 
				+        /**
			
 
				+         * The `subprocess.signalCode` property indicates the signal received by
			
 
				+         * the child process if any, else `null`.
			
 
				+         */
			
 
				+        readonly signalCode: NodeJS.Signals | null;
			
 
				+        /**
			
 
				+         * The `subprocess.spawnargs` property represents the full list of command-line
			
 
				+         * arguments the child process was launched with.
			
 
				+         */
			
 
				+        readonly spawnargs: string[];
			
 
				+        /**
			
 
				+         * The `subprocess.spawnfile` property indicates the executable file name of
			
 
				+         * the child process that is launched.
			
 
				+         *
			
 
				+         * For {@link fork}, its value will be equal to `process.execPath`.
			
 
				+         * For {@link spawn}, its value will be the name of
			
 
				+         * the executable file.
			
 
				+         * For {@link exec},  its value will be the name of the shell
			
 
				+         * in which the child process is launched.
			
 
				+         */
			
 
				+        readonly spawnfile: string;
			
 
				+        /**
			
 
				+         * The `subprocess.kill()` method sends a signal to the child process. If no
			
 
				+         * argument is given, the process will be sent the `'SIGTERM'` signal. See [`signal(7)`](http://man7.org/linux/man-pages/man7/signal.7.html) for a list of available signals. This function
			
 
				+         * returns `true` if [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) succeeds, and `false` otherwise.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { spawn } = require('child_process');
			
 
				+         * const grep = spawn('grep', ['ssh']);
			
 
				+         *
			
 
				+         * grep.on('close', (code, signal) => {
			
 
				+         *   console.log(
			
 
				+         *     `child process terminated due to receipt of signal ${signal}`);
			
 
				+         * });
			
 
				+         *
			
 
				+         * // Send SIGHUP to process.
			
 
				+         * grep.kill('SIGHUP');
			
 
				+         * ```
			
 
				+         *
			
 
				+         * The `ChildProcess` object may emit an `'error'` event if the signal
			
 
				+         * cannot be delivered. Sending a signal to a child process that has already exited
			
 
				+         * is not an error but may have unforeseen consequences. Specifically, if the
			
 
				+         * process identifier (PID) has been reassigned to another process, the signal will
			
 
				+         * be delivered to that process instead which can have unexpected results.
			
 
				+         *
			
 
				+         * While the function is called `kill`, the signal delivered to the child process
			
 
				+         * may not actually terminate the process.
			
 
				+         *
			
 
				+         * See [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) for reference.
			
 
				+         *
			
 
				+         * On Windows, where POSIX signals do not exist, the `signal` argument will be
			
 
				+         * ignored, and the process will be killed forcefully and abruptly (similar to`'SIGKILL'`).
			
 
				+         * See `Signal Events` for more details.
			
 
				+         *
			
 
				+         * On Linux, child processes of child processes will not be terminated
			
 
				+         * when attempting to kill their parent. This is likely to happen when running a
			
 
				+         * new process in a shell or with the use of the `shell` option of `ChildProcess`:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * 'use strict';
			
 
				+         * const { spawn } = require('child_process');
			
 
				+         *
			
 
				+         * const subprocess = spawn(
			
 
				+         *   'sh',
			
 
				+         *   [
			
 
				+         *     '-c',
			
 
				+         *     `node -e "setInterval(() => {
			
 
				+         *       console.log(process.pid, 'is alive')
			
 
				+         *     }, 500);"`,
			
 
				+         *   ], {
			
 
				+         *     stdio: ['inherit', 'inherit', 'inherit']
			
 
				+         *   }
			
 
				+         * );
			
 
				+         *
			
 
				+         * setTimeout(() => {
			
 
				+         *   subprocess.kill(); // Does not terminate the Node.js process in the shell.
			
 
				+         * }, 2000);
			
 
				+         * ```
			
 
				+         * @since v0.1.90
			
 
				+         */
			
 
				+        kill(signal?: NodeJS.Signals | number): boolean;
			
 
				+        /**
			
 
				+         * When an IPC channel has been established between the parent and child (
			
 
				+         * i.e. when using {@link fork}), the `subprocess.send()` method can
			
 
				+         * be used to send messages to the child process. When the child process is a
			
 
				+         * Node.js instance, these messages can be received via the `'message'` event.
			
 
				+         *
			
 
				+         * The message goes through serialization and parsing. The resulting
			
 
				+         * message might not be the same as what is originally sent.
			
 
				+         *
			
 
				+         * For example, in the parent script:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const cp = require('child_process');
			
 
				+         * const n = cp.fork(`${__dirname}/sub.js`);
			
 
				+         *
			
 
				+         * n.on('message', (m) => {
			
 
				+         *   console.log('PARENT got message:', m);
			
 
				+         * });
			
 
				+         *
			
 
				+         * // Causes the child to print: CHILD got message: { hello: 'world' }
			
 
				+         * n.send({ hello: 'world' });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * And then the child script, `'sub.js'` might look like this:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * process.on('message', (m) => {
			
 
				+         *   console.log('CHILD got message:', m);
			
 
				+         * });
			
 
				+         *
			
 
				+         * // Causes the parent to print: PARENT got message: { foo: 'bar', baz: null }
			
 
				+         * process.send({ foo: 'bar', baz: NaN });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Child Node.js processes will have a `process.send()` method of their own
			
 
				+         * that allows the child to send messages back to the parent.
			
 
				+         *
			
 
				+         * There is a special case when sending a `{cmd: 'NODE_foo'}` message. Messages
			
 
				+         * containing a `NODE_` prefix in the `cmd` property are reserved for use within
			
 
				+         * Node.js core and will not be emitted in the child's `'message'` event. Rather, such messages are emitted using the`'internalMessage'` event and are consumed internally by Node.js.
			
 
				+         * Applications should avoid using such messages or listening for`'internalMessage'` events as it is subject to change without notice.
			
 
				+         *
			
 
				+         * The optional `sendHandle` argument that may be passed to `subprocess.send()` is
			
 
				+         * for passing a TCP server or socket object to the child process. The child will
			
 
				+         * receive the object as the second argument passed to the callback function
			
 
				+         * registered on the `'message'` event. Any data that is received
			
 
				+         * and buffered in the socket will not be sent to the child.
			
 
				+         *
			
 
				+         * The optional `callback` is a function that is invoked after the message is
			
 
				+         * sent but before the child may have received it. The function is called with a
			
 
				+         * single argument: `null` on success, or an `Error` object on failure.
			
 
				+         *
			
 
				+         * If no `callback` function is provided and the message cannot be sent, an`'error'` event will be emitted by the `ChildProcess` object. This can
			
 
				+         * happen, for instance, when the child process has already exited.
			
 
				+         *
			
 
				+         * `subprocess.send()` will return `false` if the channel has closed or when the
			
 
				+         * backlog of unsent messages exceeds a threshold that makes it unwise to send
			
 
				+         * more. Otherwise, the method returns `true`. The `callback` function can be
			
 
				+         * used to implement flow control.
			
 
				+         *
			
 
				+         * #### Example: sending a server object
			
 
				+         *
			
 
				+         * The `sendHandle` argument can be used, for instance, to pass the handle of
			
 
				+         * a TCP server object to the child process as illustrated in the example below:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const subprocess = require('child_process').fork('subprocess.js');
			
 
				+         *
			
 
				+         * // Open up the server object and send the handle.
			
 
				+         * const server = require('net').createServer();
			
 
				+         * server.on('connection', (socket) => {
			
 
				+         *   socket.end('handled by parent');
			
 
				+         * });
			
 
				+         * server.listen(1337, () => {
			
 
				+         *   subprocess.send('server', server);
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * The child would then receive the server object as:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * process.on('message', (m, server) => {
			
 
				+         *   if (m === 'server') {
			
 
				+         *     server.on('connection', (socket) => {
			
 
				+         *       socket.end('handled by child');
			
 
				+         *     });
			
 
				+         *   }
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Once the server is now shared between the parent and child, some connections
			
 
				+         * can be handled by the parent and some by the child.
			
 
				+         *
			
 
				+         * While the example above uses a server created using the `net` module, `dgram`module servers use exactly the same workflow with the exceptions of listening on
			
 
				+         * a `'message'` event instead of `'connection'` and using `server.bind()` instead
			
 
				+         * of `server.listen()`. This is, however, currently only supported on Unix
			
 
				+         * platforms.
			
 
				+         *
			
 
				+         * #### Example: sending a socket object
			
 
				+         *
			
 
				+         * Similarly, the `sendHandler` argument can be used to pass the handle of a
			
 
				+         * socket to the child process. The example below spawns two children that each
			
 
				+         * handle connections with "normal" or "special" priority:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { fork } = require('child_process');
			
 
				+         * const normal = fork('subprocess.js', ['normal']);
			
 
				+         * const special = fork('subprocess.js', ['special']);
			
 
				+         *
			
 
				+         * // Open up the server and send sockets to child. Use pauseOnConnect to prevent
			
 
				+         * // the sockets from being read before they are sent to the child process.
			
 
				+         * const server = require('net').createServer({ pauseOnConnect: true });
			
 
				+         * server.on('connection', (socket) => {
			
 
				+         *
			
 
				+         *   // If this is special priority...
			
 
				+         *   if (socket.remoteAddress === '74.125.127.100') {
			
 
				+         *     special.send('socket', socket);
			
 
				+         *     return;
			
 
				+         *   }
			
 
				+         *   // This is normal priority.
			
 
				+         *   normal.send('socket', socket);
			
 
				+         * });
			
 
				+         * server.listen(1337);
			
 
				+         * ```
			
 
				+         *
			
 
				+         * The `subprocess.js` would receive the socket handle as the second argument
			
 
				+         * passed to the event callback function:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * process.on('message', (m, socket) => {
			
 
				+         *   if (m === 'socket') {
			
 
				+         *     if (socket) {
			
 
				+         *       // Check that the client socket exists.
			
 
				+         *       // It is possible for the socket to be closed between the time it is
			
 
				+         *       // sent and the time it is received in the child process.
			
 
				+         *       socket.end(`Request handled with ${process.argv[2]} priority`);
			
 
				+         *     }
			
 
				+         *   }
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Do not use `.maxConnections` on a socket that has been passed to a subprocess.
			
 
				+         * The parent cannot track when the socket is destroyed.
			
 
				+         *
			
 
				+         * Any `'message'` handlers in the subprocess should verify that `socket` exists,
			
 
				+         * as the connection may have been closed during the time it takes to send the
			
 
				+         * connection to the child.
			
 
				+         * @since v0.5.9
			
 
				+         * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles. `options` supports the following properties:
			
 
				+         */
			
 
				+        send(message: Serializable, callback?: (error: Error | null) => void): boolean;
			
 
				+        send(message: Serializable, sendHandle?: SendHandle, callback?: (error: Error | null) => void): boolean;
			
 
				+        send(message: Serializable, sendHandle?: SendHandle, options?: MessageOptions, callback?: (error: Error | null) => void): boolean;
			
 
				+        /**
			
 
				+         * Closes the IPC channel between parent and child, allowing the child to exit
			
 
				+         * gracefully once there are no other connections keeping it alive. After calling
			
 
				+         * this method the `subprocess.connected` and `process.connected` properties in
			
 
				+         * both the parent and child (respectively) will be set to `false`, and it will be
			
 
				+         * no longer possible to pass messages between the processes.
			
 
				+         *
			
 
				+         * The `'disconnect'` event will be emitted when there are no messages in the
			
 
				+         * process of being received. This will most often be triggered immediately after
			
 
				+         * calling `subprocess.disconnect()`.
			
 
				+         *
			
 
				+         * When the child process is a Node.js instance (e.g. spawned using {@link fork}), the `process.disconnect()` method can be invoked
			
 
				+         * within the child process to close the IPC channel as well.
			
 
				+         * @since v0.7.2
			
 
				+         */
			
 
				+        disconnect(): void;
			
 
				+        /**
			
 
				+         * By default, the parent will wait for the detached child to exit. To prevent the
			
 
				+         * parent from waiting for a given `subprocess` to exit, use the`subprocess.unref()` method. Doing so will cause the parent's event loop to not
			
 
				+         * include the child in its reference count, allowing the parent to exit
			
 
				+         * independently of the child, unless there is an established IPC channel between
			
 
				+         * the child and the parent.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { spawn } = require('child_process');
			
 
				+         *
			
 
				+         * const subprocess = spawn(process.argv[0], ['child_program.js'], {
			
 
				+         *   detached: true,
			
 
				+         *   stdio: 'ignore'
			
 
				+         * });
			
 
				+         *
			
 
				+         * subprocess.unref();
			
 
				+         * ```
			
 
				+         * @since v0.7.10
			
 
				+         */
			
 
				+        unref(): void;
			
 
				+        /**
			
 
				+         * Calling `subprocess.ref()` after making a call to `subprocess.unref()` will
			
 
				+         * restore the removed reference count for the child process, forcing the parent
			
 
				+         * to wait for the child to exit before exiting itself.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { spawn } = require('child_process');
			
 
				+         *
			
 
				+         * const subprocess = spawn(process.argv[0], ['child_program.js'], {
			
 
				+         *   detached: true,
			
 
				+         *   stdio: 'ignore'
			
 
				+         * });
			
 
				+         *
			
 
				+         * subprocess.unref();
			
 
				+         * subprocess.ref();
			
 
				+         * ```
			
 
				+         * @since v0.7.10
			
 
				+         */
			
 
				+        ref(): void;
			
 
				+        /**
			
 
				+         * events.EventEmitter
			
 
				+         * 1. close
			
 
				+         * 2. disconnect
			
 
				+         * 3. error
			
 
				+         * 4. exit
			
 
				+         * 5. message
			
 
				+         * 6. spawn
			
 
				+         */
			
 
				+        addListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        addListener(event: 'close', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        addListener(event: 'disconnect', listener: () => void): this;
			
 
				+        addListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        addListener(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        addListener(event: 'message', listener: (message: Serializable, sendHandle: SendHandle) => void): this;
			
 
				+        addListener(event: 'spawn', listener: () => void): this;
			
 
				+        emit(event: string | symbol, ...args: any[]): boolean;
			
 
				+        emit(event: 'close', code: number | null, signal: NodeJS.Signals | null): boolean;
			
 
				+        emit(event: 'disconnect'): boolean;
			
 
				+        emit(event: 'error', err: Error): boolean;
			
 
				+        emit(event: 'exit', code: number | null, signal: NodeJS.Signals | null): boolean;
			
 
				+        emit(event: 'message', message: Serializable, sendHandle: SendHandle): boolean;
			
 
				+        emit(event: 'spawn', listener: () => void): boolean;
			
 
				+        on(event: string, listener: (...args: any[]) => void): this;
			
 
				+        on(event: 'close', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        on(event: 'disconnect', listener: () => void): this;
			
 
				+        on(event: 'error', listener: (err: Error) => void): this;
			
 
				+        on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        on(event: 'message', listener: (message: Serializable, sendHandle: SendHandle) => void): this;
			
 
				+        on(event: 'spawn', listener: () => void): this;
			
 
				+        once(event: string, listener: (...args: any[]) => void): this;
			
 
				+        once(event: 'close', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        once(event: 'disconnect', listener: () => void): this;
			
 
				+        once(event: 'error', listener: (err: Error) => void): this;
			
 
				+        once(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        once(event: 'message', listener: (message: Serializable, sendHandle: SendHandle) => void): this;
			
 
				+        once(event: 'spawn', listener: () => void): this;
			
 
				+        prependListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependListener(event: 'close', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        prependListener(event: 'disconnect', listener: () => void): this;
			
 
				+        prependListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        prependListener(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        prependListener(event: 'message', listener: (message: Serializable, sendHandle: SendHandle) => void): this;
			
 
				+        prependListener(event: 'spawn', listener: () => void): this;
			
 
				+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependOnceListener(event: 'close', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        prependOnceListener(event: 'disconnect', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        prependOnceListener(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
			
 
				+        prependOnceListener(event: 'message', listener: (message: Serializable, sendHandle: SendHandle) => void): this;
			
 
				+        prependOnceListener(event: 'spawn', listener: () => void): this;
			
 
				+    }
			
 
				+    // return this object when stdio option is undefined or not specified
			
 
				+    interface ChildProcessWithoutNullStreams extends ChildProcess {
			
 
				+        stdin: Writable;
			
 
				+        stdout: Readable;
			
 
				+        stderr: Readable;
			
 
				+        readonly stdio: [
			
 
				+            Writable,
			
 
				+            Readable,
			
 
				+            Readable,
			
 
				+            // stderr
			
 
				+            Readable | Writable | null | undefined,
			
 
				+            // extra, no modification
			
 
				+            Readable | Writable | null | undefined // extra, no modification
			
 
				+        ];
			
 
				+    }
			
 
				+    // return this object when stdio option is a tuple of 3
			
 
				+    interface ChildProcessByStdio<I extends null | Writable, O extends null | Readable, E extends null | Readable> extends ChildProcess {
			
 
				+        stdin: I;
			
 
				+        stdout: O;
			
 
				+        stderr: E;
			
 
				+        readonly stdio: [
			
 
				+            I,
			
 
				+            O,
			
 
				+            E,
			
 
				+            Readable | Writable | null | undefined,
			
 
				+            // extra, no modification
			
 
				+            Readable | Writable | null | undefined // extra, no modification
			
 
				+        ];
			
 
				+    }
			
 
				+    interface MessageOptions {
			
 
				+        keepOpen?: boolean | undefined;
			
 
				+    }
			
 
				+    type IOType = 'overlapped' | 'pipe' | 'ignore' | 'inherit';
			
 
				+    type StdioOptions = IOType | Array<IOType | 'ipc' | Stream | number | null | undefined>;
			
 
				+    type SerializationType = 'json' | 'advanced';
			
 
				+    interface MessagingOptions extends Abortable {
			
 
				+        /**
			
 
				+         * Specify the kind of serialization used for sending messages between processes.
			
 
				+         * @default 'json'
			
 
				+         */
			
 
				+        serialization?: SerializationType | undefined;
			
 
				+        /**
			
 
				+         * The signal value to be used when the spawned process will be killed by the abort signal.
			
 
				+         * @default 'SIGTERM'
			
 
				+         */
			
 
				+        killSignal?: NodeJS.Signals | number | undefined;
			
 
				+        /**
			
 
				+         * In milliseconds the maximum amount of time the process is allowed to run.
			
 
				+         */
			
 
				+        timeout?: number | undefined;
			
 
				+    }
			
 
				+    interface ProcessEnvOptions {
			
 
				+        uid?: number | undefined;
			
 
				+        gid?: number | undefined;
			
 
				+        cwd?: string | URL | undefined;
			
 
				+        env?: NodeJS.ProcessEnv | undefined;
			
 
				+    }
			
 
				+    interface CommonOptions extends ProcessEnvOptions {
			
 
				+        /**
			
 
				+         * @default false
			
 
				+         */
			
 
				+        windowsHide?: boolean | undefined;
			
 
				+        /**
			
 
				+         * @default 0
			
 
				+         */
			
 
				+        timeout?: number | undefined;
			
 
				+    }
			
 
				+    interface CommonSpawnOptions extends CommonOptions, MessagingOptions, Abortable {
			
 
				+        argv0?: string | undefined;
			
 
				+        stdio?: StdioOptions | undefined;
			
 
				+        shell?: boolean | string | undefined;
			
 
				+        windowsVerbatimArguments?: boolean | undefined;
			
 
				+    }
			
 
				+    interface SpawnOptions extends CommonSpawnOptions {
			
 
				+        detached?: boolean | undefined;
			
 
				+    }
			
 
				+    interface SpawnOptionsWithoutStdio extends SpawnOptions {
			
 
				+        stdio?: StdioPipeNamed | StdioPipe[] | undefined;
			
 
				+    }
			
 
				+    type StdioNull = 'inherit' | 'ignore' | Stream;
			
 
				+    type StdioPipeNamed = 'pipe' | 'overlapped';
			
 
				+    type StdioPipe = undefined | null | StdioPipeNamed;
			
 
				+    interface SpawnOptionsWithStdioTuple<Stdin extends StdioNull | StdioPipe, Stdout extends StdioNull | StdioPipe, Stderr extends StdioNull | StdioPipe> extends SpawnOptions {
			
 
				+        stdio: [Stdin, Stdout, Stderr];
			
 
				+    }
			
 
				+    /**
			
 
				+     * The `child_process.spawn()` method spawns a new process using the given`command`, with command-line arguments in `args`. If omitted, `args` defaults
			
 
				+     * to an empty array.
			
 
				+     *
			
 
				+     * **If the `shell` option is enabled, do not pass unsanitized user input to this**
			
 
				+     * **function. Any input containing shell metacharacters may be used to trigger**
			
 
				+     * **arbitrary command execution.**
			
 
				+     *
			
 
				+     * A third argument may be used to specify additional options, with these defaults:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const defaults = {
			
 
				+     *   cwd: undefined,
			
 
				+     *   env: process.env
			
 
				+     * };
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Use `cwd` to specify the working directory from which the process is spawned.
			
 
				+     * If not given, the default is to inherit the current working directory. If given,
			
 
				+     * but the path does not exist, the child process emits an `ENOENT` error
			
 
				+     * and exits immediately. `ENOENT` is also emitted when the command
			
 
				+     * does not exist.
			
 
				+     *
			
 
				+     * Use `env` to specify environment variables that will be visible to the new
			
 
				+     * process, the default is `process.env`.
			
 
				+     *
			
 
				+     * `undefined` values in `env` will be ignored.
			
 
				+     *
			
 
				+     * Example of running `ls -lh /usr`, capturing `stdout`, `stderr`, and the
			
 
				+     * exit code:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { spawn } = require('child_process');
			
 
				+     * const ls = spawn('ls', ['-lh', '/usr']);
			
 
				+     *
			
 
				+     * ls.stdout.on('data', (data) => {
			
 
				+     *   console.log(`stdout: ${data}`);
			
 
				+     * });
			
 
				+     *
			
 
				+     * ls.stderr.on('data', (data) => {
			
 
				+     *   console.error(`stderr: ${data}`);
			
 
				+     * });
			
 
				+     *
			
 
				+     * ls.on('close', (code) => {
			
 
				+     *   console.log(`child process exited with code ${code}`);
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: A very elaborate way to run `ps ax | grep ssh`
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { spawn } = require('child_process');
			
 
				+     * const ps = spawn('ps', ['ax']);
			
 
				+     * const grep = spawn('grep', ['ssh']);
			
 
				+     *
			
 
				+     * ps.stdout.on('data', (data) => {
			
 
				+     *   grep.stdin.write(data);
			
 
				+     * });
			
 
				+     *
			
 
				+     * ps.stderr.on('data', (data) => {
			
 
				+     *   console.error(`ps stderr: ${data}`);
			
 
				+     * });
			
 
				+     *
			
 
				+     * ps.on('close', (code) => {
			
 
				+     *   if (code !== 0) {
			
 
				+     *     console.log(`ps process exited with code ${code}`);
			
 
				+     *   }
			
 
				+     *   grep.stdin.end();
			
 
				+     * });
			
 
				+     *
			
 
				+     * grep.stdout.on('data', (data) => {
			
 
				+     *   console.log(data.toString());
			
 
				+     * });
			
 
				+     *
			
 
				+     * grep.stderr.on('data', (data) => {
			
 
				+     *   console.error(`grep stderr: ${data}`);
			
 
				+     * });
			
 
				+     *
			
 
				+     * grep.on('close', (code) => {
			
 
				+     *   if (code !== 0) {
			
 
				+     *     console.log(`grep process exited with code ${code}`);
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example of checking for failed `spawn`:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { spawn } = require('child_process');
			
 
				+     * const subprocess = spawn('bad_command');
			
 
				+     *
			
 
				+     * subprocess.on('error', (err) => {
			
 
				+     *   console.error('Failed to start subprocess.');
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Certain platforms (macOS, Linux) will use the value of `argv[0]` for the process
			
 
				+     * title while others (Windows, SunOS) will use `command`.
			
 
				+     *
			
 
				+     * Node.js currently overwrites `argv[0]` with `process.execPath` on startup, so`process.argv[0]` in a Node.js child process will not match the `argv0`parameter passed to `spawn` from the parent,
			
 
				+     * retrieve it with the`process.argv0` property instead.
			
 
				+     *
			
 
				+     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except
			
 
				+     * the error passed to the callback will be an `AbortError`:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { spawn } = require('child_process');
			
 
				+     * const controller = new AbortController();
			
 
				+     * const { signal } = controller;
			
 
				+     * const grep = spawn('grep', ['ssh'], { signal });
			
 
				+     * grep.on('error', (err) => {
			
 
				+     *   // This will be called with err being an AbortError if the controller aborts
			
 
				+     * });
			
 
				+     * controller.abort(); // Stops the child process
			
 
				+     * ```
			
 
				+     * @since v0.1.90
			
 
				+     * @param command The command to run.
			
 
				+     * @param args List of string arguments.
			
 
				+     */
			
 
				+    function spawn(command: string, options?: SpawnOptionsWithoutStdio): ChildProcessWithoutNullStreams;
			
 
				+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): ChildProcessByStdio<Writable, Readable, Readable>;
			
 
				+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): ChildProcessByStdio<Writable, Readable, null>;
			
 
				+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): ChildProcessByStdio<Writable, null, Readable>;
			
 
				+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): ChildProcessByStdio<null, Readable, Readable>;
			
 
				+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): ChildProcessByStdio<Writable, null, null>;
			
 
				+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): ChildProcessByStdio<null, Readable, null>;
			
 
				+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): ChildProcessByStdio<null, null, Readable>;
			
 
				+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): ChildProcessByStdio<null, null, null>;
			
 
				+    function spawn(command: string, options: SpawnOptions): ChildProcess;
			
 
				+    // overloads of spawn with 'args'
			
 
				+    function spawn(command: string, args?: ReadonlyArray<string>, options?: SpawnOptionsWithoutStdio): ChildProcessWithoutNullStreams;
			
 
				+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): ChildProcessByStdio<Writable, Readable, Readable>;
			
 
				+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): ChildProcessByStdio<Writable, Readable, null>;
			
 
				+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): ChildProcessByStdio<Writable, null, Readable>;
			
 
				+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): ChildProcessByStdio<null, Readable, Readable>;
			
 
				+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): ChildProcessByStdio<Writable, null, null>;
			
 
				+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): ChildProcessByStdio<null, Readable, null>;
			
 
				+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): ChildProcessByStdio<null, null, Readable>;
			
 
				+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): ChildProcessByStdio<null, null, null>;
			
 
				+    function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptions): ChildProcess;
			
 
				+    interface ExecOptions extends CommonOptions {
			
 
				+        shell?: string | undefined;
			
 
				+        signal?: AbortSignal | undefined;
			
 
				+        maxBuffer?: number | undefined;
			
 
				+        killSignal?: NodeJS.Signals | number | undefined;
			
 
				+    }
			
 
				+    interface ExecOptionsWithStringEncoding extends ExecOptions {
			
 
				+        encoding: BufferEncoding;
			
 
				+    }
			
 
				+    interface ExecOptionsWithBufferEncoding extends ExecOptions {
			
 
				+        encoding: BufferEncoding | null; // specify `null`.
			
 
				+    }
			
 
				+    interface ExecException extends Error {
			
 
				+        cmd?: string | undefined;
			
 
				+        killed?: boolean | undefined;
			
 
				+        code?: number | undefined;
			
 
				+        signal?: NodeJS.Signals | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Spawns a shell then executes the `command` within that shell, buffering any
			
 
				+     * generated output. The `command` string passed to the exec function is processed
			
 
				+     * directly by the shell and special characters (vary based on [shell](https://en.wikipedia.org/wiki/List_of_command-line_interpreters))
			
 
				+     * need to be dealt with accordingly:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { exec } = require('child_process');
			
 
				+     *
			
 
				+     * exec('"/path/to/test file/test.sh" arg1 arg2');
			
 
				+     * // Double quotes are used so that the space in the path is not interpreted as
			
 
				+     * // a delimiter of multiple arguments.
			
 
				+     *
			
 
				+     * exec('echo "The \\$HOME variable is $HOME"');
			
 
				+     * // The $HOME variable is escaped in the first instance, but not in the second.
			
 
				+     * ```
			
 
				+     *
			
 
				+     * **Never pass unsanitized user input to this function. Any input containing shell**
			
 
				+     * **metacharacters may be used to trigger arbitrary command execution.**
			
 
				+     *
			
 
				+     * If a `callback` function is provided, it is called with the arguments`(error, stdout, stderr)`. On success, `error` will be `null`. On error,`error` will be an instance of `Error`. The
			
 
				+     * `error.code` property will be
			
 
				+     * the exit code of the process. By convention, any exit code other than `0`indicates an error. `error.signal` will be the signal that terminated the
			
 
				+     * process.
			
 
				+     *
			
 
				+     * The `stdout` and `stderr` arguments passed to the callback will contain the
			
 
				+     * stdout and stderr output of the child process. By default, Node.js will decode
			
 
				+     * the output as UTF-8 and pass strings to the callback. The `encoding` option
			
 
				+     * can be used to specify the character encoding used to decode the stdout and
			
 
				+     * stderr output. If `encoding` is `'buffer'`, or an unrecognized character
			
 
				+     * encoding, `Buffer` objects will be passed to the callback instead.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { exec } = require('child_process');
			
 
				+     * exec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {
			
 
				+     *   if (error) {
			
 
				+     *     console.error(`exec error: ${error}`);
			
 
				+     *     return;
			
 
				+     *   }
			
 
				+     *   console.log(`stdout: ${stdout}`);
			
 
				+     *   console.error(`stderr: ${stderr}`);
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If `timeout` is greater than `0`, the parent will send the signal
			
 
				+     * identified by the `killSignal` property (the default is `'SIGTERM'`) if the
			
 
				+     * child runs longer than `timeout` milliseconds.
			
 
				+     *
			
 
				+     * Unlike the [`exec(3)`](http://man7.org/linux/man-pages/man3/exec.3.html) POSIX system call, `child_process.exec()` does not replace
			
 
				+     * the existing process and uses a shell to execute the command.
			
 
				+     *
			
 
				+     * If this method is invoked as its `util.promisify()` ed version, it returns
			
 
				+     * a `Promise` for an `Object` with `stdout` and `stderr` properties. The returned`ChildProcess` instance is attached to the `Promise` as a `child` property. In
			
 
				+     * case of an error (including any error resulting in an exit code other than 0), a
			
 
				+     * rejected promise is returned, with the same `error` object given in the
			
 
				+     * callback, but with two additional properties `stdout` and `stderr`.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const util = require('util');
			
 
				+     * const exec = util.promisify(require('child_process').exec);
			
 
				+     *
			
 
				+     * async function lsExample() {
			
 
				+     *   const { stdout, stderr } = await exec('ls');
			
 
				+     *   console.log('stdout:', stdout);
			
 
				+     *   console.error('stderr:', stderr);
			
 
				+     * }
			
 
				+     * lsExample();
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except
			
 
				+     * the error passed to the callback will be an `AbortError`:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { exec } = require('child_process');
			
 
				+     * const controller = new AbortController();
			
 
				+     * const { signal } = controller;
			
 
				+     * const child = exec('grep ssh', { signal }, (error) => {
			
 
				+     *   console.log(error); // an AbortError
			
 
				+     * });
			
 
				+     * controller.abort();
			
 
				+     * ```
			
 
				+     * @since v0.1.90
			
 
				+     * @param command The command to run, with space-separated arguments.
			
 
				+     * @param callback called with the output when process terminates.
			
 
				+     */
			
 
				+    function exec(command: string, callback?: (error: ExecException | null, stdout: string, stderr: string) => void): ChildProcess;
			
 
				+    // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.
			
 
				+    function exec(
			
 
				+        command: string,
			
 
				+        options: {
			
 
				+            encoding: 'buffer' | null;
			
 
				+        } & ExecOptions,
			
 
				+        callback?: (error: ExecException | null, stdout: Buffer, stderr: Buffer) => void
			
 
				+    ): ChildProcess;
			
 
				+    // `options` with well known `encoding` means stdout/stderr are definitely `string`.
			
 
				+    function exec(
			
 
				+        command: string,
			
 
				+        options: {
			
 
				+            encoding: BufferEncoding;
			
 
				+        } & ExecOptions,
			
 
				+        callback?: (error: ExecException | null, stdout: string, stderr: string) => void
			
 
				+    ): ChildProcess;
			
 
				+    // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
			
 
				+    // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.
			
 
				+    function exec(
			
 
				+        command: string,
			
 
				+        options: {
			
 
				+            encoding: BufferEncoding;
			
 
				+        } & ExecOptions,
			
 
				+        callback?: (error: ExecException | null, stdout: string | Buffer, stderr: string | Buffer) => void
			
 
				+    ): ChildProcess;
			
 
				+    // `options` without an `encoding` means stdout/stderr are definitely `string`.
			
 
				+    function exec(command: string, options: ExecOptions, callback?: (error: ExecException | null, stdout: string, stderr: string) => void): ChildProcess;
			
 
				+    // fallback if nothing else matches. Worst case is always `string | Buffer`.
			
 
				+    function exec(
			
 
				+        command: string,
			
 
				+        options: (ObjectEncodingOptions & ExecOptions) | undefined | null,
			
 
				+        callback?: (error: ExecException | null, stdout: string | Buffer, stderr: string | Buffer) => void
			
 
				+    ): ChildProcess;
			
 
				+    interface PromiseWithChild<T> extends Promise<T> {
			
 
				+        child: ChildProcess;
			
 
				+    }
			
 
				+    namespace exec {
			
 
				+        function __promisify__(command: string): PromiseWithChild<{
			
 
				+            stdout: string;
			
 
				+            stderr: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            command: string,
			
 
				+            options: {
			
 
				+                encoding: 'buffer' | null;
			
 
				+            } & ExecOptions
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: Buffer;
			
 
				+            stderr: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            command: string,
			
 
				+            options: {
			
 
				+                encoding: BufferEncoding;
			
 
				+            } & ExecOptions
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string;
			
 
				+            stderr: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            command: string,
			
 
				+            options: ExecOptions
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string;
			
 
				+            stderr: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            command: string,
			
 
				+            options?: (ObjectEncodingOptions & ExecOptions) | null
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string | Buffer;
			
 
				+            stderr: string | Buffer;
			
 
				+        }>;
			
 
				+    }
			
 
				+    interface ExecFileOptions extends CommonOptions, Abortable {
			
 
				+        maxBuffer?: number | undefined;
			
 
				+        killSignal?: NodeJS.Signals | number | undefined;
			
 
				+        windowsVerbatimArguments?: boolean | undefined;
			
 
				+        shell?: boolean | string | undefined;
			
 
				+        signal?: AbortSignal | undefined;
			
 
				+    }
			
 
				+    interface ExecFileOptionsWithStringEncoding extends ExecFileOptions {
			
 
				+        encoding: BufferEncoding;
			
 
				+    }
			
 
				+    interface ExecFileOptionsWithBufferEncoding extends ExecFileOptions {
			
 
				+        encoding: 'buffer' | null;
			
 
				+    }
			
 
				+    interface ExecFileOptionsWithOtherEncoding extends ExecFileOptions {
			
 
				+        encoding: BufferEncoding;
			
 
				+    }
			
 
				+    type ExecFileException = ExecException & NodeJS.ErrnoException;
			
 
				+    /**
			
 
				+     * The `child_process.execFile()` function is similar to {@link exec} except that it does not spawn a shell by default. Rather, the specified
			
 
				+     * executable `file` is spawned directly as a new process making it slightly more
			
 
				+     * efficient than {@link exec}.
			
 
				+     *
			
 
				+     * The same options as {@link exec} are supported. Since a shell is
			
 
				+     * not spawned, behaviors such as I/O redirection and file globbing are not
			
 
				+     * supported.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { execFile } = require('child_process');
			
 
				+     * const child = execFile('node', ['--version'], (error, stdout, stderr) => {
			
 
				+     *   if (error) {
			
 
				+     *     throw error;
			
 
				+     *   }
			
 
				+     *   console.log(stdout);
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The `stdout` and `stderr` arguments passed to the callback will contain the
			
 
				+     * stdout and stderr output of the child process. By default, Node.js will decode
			
 
				+     * the output as UTF-8 and pass strings to the callback. The `encoding` option
			
 
				+     * can be used to specify the character encoding used to decode the stdout and
			
 
				+     * stderr output. If `encoding` is `'buffer'`, or an unrecognized character
			
 
				+     * encoding, `Buffer` objects will be passed to the callback instead.
			
 
				+     *
			
 
				+     * If this method is invoked as its `util.promisify()` ed version, it returns
			
 
				+     * a `Promise` for an `Object` with `stdout` and `stderr` properties. The returned`ChildProcess` instance is attached to the `Promise` as a `child` property. In
			
 
				+     * case of an error (including any error resulting in an exit code other than 0), a
			
 
				+     * rejected promise is returned, with the same `error` object given in the
			
 
				+     * callback, but with two additional properties `stdout` and `stderr`.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const util = require('util');
			
 
				+     * const execFile = util.promisify(require('child_process').execFile);
			
 
				+     * async function getVersion() {
			
 
				+     *   const { stdout } = await execFile('node', ['--version']);
			
 
				+     *   console.log(stdout);
			
 
				+     * }
			
 
				+     * getVersion();
			
 
				+     * ```
			
 
				+     *
			
 
				+     * **If the `shell` option is enabled, do not pass unsanitized user input to this**
			
 
				+     * **function. Any input containing shell metacharacters may be used to trigger**
			
 
				+     * **arbitrary command execution.**
			
 
				+     *
			
 
				+     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except
			
 
				+     * the error passed to the callback will be an `AbortError`:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { execFile } = require('child_process');
			
 
				+     * const controller = new AbortController();
			
 
				+     * const { signal } = controller;
			
 
				+     * const child = execFile('node', ['--version'], { signal }, (error) => {
			
 
				+     *   console.log(error); // an AbortError
			
 
				+     * });
			
 
				+     * controller.abort();
			
 
				+     * ```
			
 
				+     * @since v0.1.91
			
 
				+     * @param file The name or path of the executable file to run.
			
 
				+     * @param args List of string arguments.
			
 
				+     * @param callback Called with the output when process terminates.
			
 
				+     */
			
 
				+    function execFile(file: string): ChildProcess;
			
 
				+    function execFile(file: string, options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null): ChildProcess;
			
 
				+    function execFile(file: string, args?: ReadonlyArray<string> | null): ChildProcess;
			
 
				+    function execFile(file: string, args: ReadonlyArray<string> | undefined | null, options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null): ChildProcess;
			
 
				+    // no `options` definitely means stdout/stderr are `string`.
			
 
				+    function execFile(file: string, callback: (error: ExecFileException | null, stdout: string, stderr: string) => void): ChildProcess;
			
 
				+    function execFile(file: string, args: ReadonlyArray<string> | undefined | null, callback: (error: ExecFileException | null, stdout: string, stderr: string) => void): ChildProcess;
			
 
				+    // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.
			
 
				+    function execFile(file: string, options: ExecFileOptionsWithBufferEncoding, callback: (error: ExecFileException | null, stdout: Buffer, stderr: Buffer) => void): ChildProcess;
			
 
				+    function execFile(
			
 
				+        file: string,
			
 
				+        args: ReadonlyArray<string> | undefined | null,
			
 
				+        options: ExecFileOptionsWithBufferEncoding,
			
 
				+        callback: (error: ExecFileException | null, stdout: Buffer, stderr: Buffer) => void
			
 
				+    ): ChildProcess;
			
 
				+    // `options` with well known `encoding` means stdout/stderr are definitely `string`.
			
 
				+    function execFile(file: string, options: ExecFileOptionsWithStringEncoding, callback: (error: ExecFileException | null, stdout: string, stderr: string) => void): ChildProcess;
			
 
				+    function execFile(
			
 
				+        file: string,
			
 
				+        args: ReadonlyArray<string> | undefined | null,
			
 
				+        options: ExecFileOptionsWithStringEncoding,
			
 
				+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void
			
 
				+    ): ChildProcess;
			
 
				+    // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
			
 
				+    // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.
			
 
				+    function execFile(file: string, options: ExecFileOptionsWithOtherEncoding, callback: (error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void): ChildProcess;
			
 
				+    function execFile(
			
 
				+        file: string,
			
 
				+        args: ReadonlyArray<string> | undefined | null,
			
 
				+        options: ExecFileOptionsWithOtherEncoding,
			
 
				+        callback: (error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void
			
 
				+    ): ChildProcess;
			
 
				+    // `options` without an `encoding` means stdout/stderr are definitely `string`.
			
 
				+    function execFile(file: string, options: ExecFileOptions, callback: (error: ExecFileException | null, stdout: string, stderr: string) => void): ChildProcess;
			
 
				+    function execFile(
			
 
				+        file: string,
			
 
				+        args: ReadonlyArray<string> | undefined | null,
			
 
				+        options: ExecFileOptions,
			
 
				+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void
			
 
				+    ): ChildProcess;
			
 
				+    // fallback if nothing else matches. Worst case is always `string | Buffer`.
			
 
				+    function execFile(
			
 
				+        file: string,
			
 
				+        options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
			
 
				+        callback: ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void) | undefined | null
			
 
				+    ): ChildProcess;
			
 
				+    function execFile(
			
 
				+        file: string,
			
 
				+        args: ReadonlyArray<string> | undefined | null,
			
 
				+        options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
			
 
				+        callback: ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void) | undefined | null
			
 
				+    ): ChildProcess;
			
 
				+    namespace execFile {
			
 
				+        function __promisify__(file: string): PromiseWithChild<{
			
 
				+            stdout: string;
			
 
				+            stderr: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            args: ReadonlyArray<string> | undefined | null
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string;
			
 
				+            stderr: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            options: ExecFileOptionsWithBufferEncoding
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: Buffer;
			
 
				+            stderr: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            args: ReadonlyArray<string> | undefined | null,
			
 
				+            options: ExecFileOptionsWithBufferEncoding
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: Buffer;
			
 
				+            stderr: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            options: ExecFileOptionsWithStringEncoding
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string;
			
 
				+            stderr: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            args: ReadonlyArray<string> | undefined | null,
			
 
				+            options: ExecFileOptionsWithStringEncoding
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string;
			
 
				+            stderr: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            options: ExecFileOptionsWithOtherEncoding
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string | Buffer;
			
 
				+            stderr: string | Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            args: ReadonlyArray<string> | undefined | null,
			
 
				+            options: ExecFileOptionsWithOtherEncoding
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string | Buffer;
			
 
				+            stderr: string | Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            options: ExecFileOptions
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string;
			
 
				+            stderr: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            args: ReadonlyArray<string> | undefined | null,
			
 
				+            options: ExecFileOptions
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string;
			
 
				+            stderr: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string | Buffer;
			
 
				+            stderr: string | Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            file: string,
			
 
				+            args: ReadonlyArray<string> | undefined | null,
			
 
				+            options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null
			
 
				+        ): PromiseWithChild<{
			
 
				+            stdout: string | Buffer;
			
 
				+            stderr: string | Buffer;
			
 
				+        }>;
			
 
				+    }
			
 
				+    interface ForkOptions extends ProcessEnvOptions, MessagingOptions, Abortable {
			
 
				+        execPath?: string | undefined;
			
 
				+        execArgv?: string[] | undefined;
			
 
				+        silent?: boolean | undefined;
			
 
				+        stdio?: StdioOptions | undefined;
			
 
				+        detached?: boolean | undefined;
			
 
				+        windowsVerbatimArguments?: boolean | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * The `child_process.fork()` method is a special case of {@link spawn} used specifically to spawn new Node.js processes.
			
 
				+     * Like {@link spawn}, a `ChildProcess` object is returned. The
			
 
				+     * returned `ChildProcess` will have an additional communication channel
			
 
				+     * built-in that allows messages to be passed back and forth between the parent and
			
 
				+     * child. See `subprocess.send()` for details.
			
 
				+     *
			
 
				+     * Keep in mind that spawned Node.js child processes are
			
 
				+     * independent of the parent with exception of the IPC communication channel
			
 
				+     * that is established between the two. Each process has its own memory, with
			
 
				+     * their own V8 instances. Because of the additional resource allocations
			
 
				+     * required, spawning a large number of child Node.js processes is not
			
 
				+     * recommended.
			
 
				+     *
			
 
				+     * By default, `child_process.fork()` will spawn new Node.js instances using the `process.execPath` of the parent process. The `execPath` property in the`options` object allows for an alternative
			
 
				+     * execution path to be used.
			
 
				+     *
			
 
				+     * Node.js processes launched with a custom `execPath` will communicate with the
			
 
				+     * parent process using the file descriptor (fd) identified using the
			
 
				+     * environment variable `NODE_CHANNEL_FD` on the child process.
			
 
				+     *
			
 
				+     * Unlike the [`fork(2)`](http://man7.org/linux/man-pages/man2/fork.2.html) POSIX system call, `child_process.fork()` does not clone the
			
 
				+     * current process.
			
 
				+     *
			
 
				+     * The `shell` option available in {@link spawn} is not supported by`child_process.fork()` and will be ignored if set.
			
 
				+     *
			
 
				+     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except
			
 
				+     * the error passed to the callback will be an `AbortError`:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * if (process.argv[2] === 'child') {
			
 
				+     *   setTimeout(() => {
			
 
				+     *     console.log(`Hello from ${process.argv[2]}!`);
			
 
				+     *   }, 1_000);
			
 
				+     * } else {
			
 
				+     *   const { fork } = require('child_process');
			
 
				+     *   const controller = new AbortController();
			
 
				+     *   const { signal } = controller;
			
 
				+     *   const child = fork(__filename, ['child'], { signal });
			
 
				+     *   child.on('error', (err) => {
			
 
				+     *     // This will be called with err being an AbortError if the controller aborts
			
 
				+     *   });
			
 
				+     *   controller.abort(); // Stops the child process
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v0.5.0
			
 
				+     * @param modulePath The module to run in the child.
			
 
				+     * @param args List of string arguments.
			
 
				+     */
			
 
				+    function fork(modulePath: string, options?: ForkOptions): ChildProcess;
			
 
				+    function fork(modulePath: string, args?: ReadonlyArray<string>, options?: ForkOptions): ChildProcess;
			
 
				+    interface SpawnSyncOptions extends CommonSpawnOptions {
			
 
				+        input?: string | NodeJS.ArrayBufferView | undefined;
			
 
				+        maxBuffer?: number | undefined;
			
 
				+        encoding?: BufferEncoding | 'buffer' | null | undefined;
			
 
				+    }
			
 
				+    interface SpawnSyncOptionsWithStringEncoding extends SpawnSyncOptions {
			
 
				+        encoding: BufferEncoding;
			
 
				+    }
			
 
				+    interface SpawnSyncOptionsWithBufferEncoding extends SpawnSyncOptions {
			
 
				+        encoding?: 'buffer' | null | undefined;
			
 
				+    }
			
 
				+    interface SpawnSyncReturns<T> {
			
 
				+        pid: number;
			
 
				+        output: Array<T | null>;
			
 
				+        stdout: T;
			
 
				+        stderr: T;
			
 
				+        status: number | null;
			
 
				+        signal: NodeJS.Signals | null;
			
 
				+        error?: Error | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * The `child_process.spawnSync()` method is generally identical to {@link spawn} with the exception that the function will not return
			
 
				+     * until the child process has fully closed. When a timeout has been encountered
			
 
				+     * and `killSignal` is sent, the method won't return until the process has
			
 
				+     * completely exited. If the process intercepts and handles the `SIGTERM` signal
			
 
				+     * and doesn't exit, the parent process will wait until the child process has
			
 
				+     * exited.
			
 
				+     *
			
 
				+     * **If the `shell` option is enabled, do not pass unsanitized user input to this**
			
 
				+     * **function. Any input containing shell metacharacters may be used to trigger**
			
 
				+     * **arbitrary command execution.**
			
 
				+     * @since v0.11.12
			
 
				+     * @param command The command to run.
			
 
				+     * @param args List of string arguments.
			
 
				+     */
			
 
				+    function spawnSync(command: string): SpawnSyncReturns<Buffer>;
			
 
				+    function spawnSync(command: string, options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
			
 
				+    function spawnSync(command: string, options: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
			
 
				+    function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
			
 
				+    function spawnSync(command: string, args: ReadonlyArray<string>): SpawnSyncReturns<Buffer>;
			
 
				+    function spawnSync(command: string, args: ReadonlyArray<string>, options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
			
 
				+    function spawnSync(command: string, args: ReadonlyArray<string>, options: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
			
 
				+    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
			
 
				+    interface CommonExecOptions extends CommonOptions {
			
 
				+        input?: string | NodeJS.ArrayBufferView | undefined;
			
 
				+        stdio?: StdioOptions | undefined;
			
 
				+        killSignal?: NodeJS.Signals | number | undefined;
			
 
				+        maxBuffer?: number | undefined;
			
 
				+        encoding?: BufferEncoding | 'buffer' | null | undefined;
			
 
				+    }
			
 
				+    interface ExecSyncOptions extends CommonExecOptions {
			
 
				+        shell?: string | undefined;
			
 
				+    }
			
 
				+    interface ExecSyncOptionsWithStringEncoding extends ExecSyncOptions {
			
 
				+        encoding: BufferEncoding;
			
 
				+    }
			
 
				+    interface ExecSyncOptionsWithBufferEncoding extends ExecSyncOptions {
			
 
				+        encoding?: 'buffer' | null | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * The `child_process.execSync()` method is generally identical to {@link exec} with the exception that the method will not return
			
 
				+     * until the child process has fully closed. When a timeout has been encountered
			
 
				+     * and `killSignal` is sent, the method won't return until the process has
			
 
				+     * completely exited. If the child process intercepts and handles the `SIGTERM`signal and doesn't exit, the parent process will wait until the child process
			
 
				+     * has exited.
			
 
				+     *
			
 
				+     * If the process times out or has a non-zero exit code, this method will throw.
			
 
				+     * The `Error` object will contain the entire result from {@link spawnSync}.
			
 
				+     *
			
 
				+     * **Never pass unsanitized user input to this function. Any input containing shell**
			
 
				+     * **metacharacters may be used to trigger arbitrary command execution.**
			
 
				+     * @since v0.11.12
			
 
				+     * @param command The command to run.
			
 
				+     * @return The stdout from the command.
			
 
				+     */
			
 
				+    function execSync(command: string): Buffer;
			
 
				+    function execSync(command: string, options: ExecSyncOptionsWithStringEncoding): string;
			
 
				+    function execSync(command: string, options: ExecSyncOptionsWithBufferEncoding): Buffer;
			
 
				+    function execSync(command: string, options?: ExecSyncOptions): string | Buffer;
			
 
				+    interface ExecFileSyncOptions extends CommonExecOptions {
			
 
				+        shell?: boolean | string | undefined;
			
 
				+    }
			
 
				+    interface ExecFileSyncOptionsWithStringEncoding extends ExecFileSyncOptions {
			
 
				+        encoding: BufferEncoding;
			
 
				+    }
			
 
				+    interface ExecFileSyncOptionsWithBufferEncoding extends ExecFileSyncOptions {
			
 
				+        encoding?: 'buffer' | null; // specify `null`.
			
 
				+    }
			
 
				+    /**
			
 
				+     * The `child_process.execFileSync()` method is generally identical to {@link execFile} with the exception that the method will not
			
 
				+     * return until the child process has fully closed. When a timeout has been
			
 
				+     * encountered and `killSignal` is sent, the method won't return until the process
			
 
				+     * has completely exited.
			
 
				+     *
			
 
				+     * If the child process intercepts and handles the `SIGTERM` signal and
			
 
				+     * does not exit, the parent process will still wait until the child process has
			
 
				+     * exited.
			
 
				+     *
			
 
				+     * If the process times out or has a non-zero exit code, this method will throw an `Error` that will include the full result of the underlying {@link spawnSync}.
			
 
				+     *
			
 
				+     * **If the `shell` option is enabled, do not pass unsanitized user input to this**
			
 
				+     * **function. Any input containing shell metacharacters may be used to trigger**
			
 
				+     * **arbitrary command execution.**
			
 
				+     * @since v0.11.12
			
 
				+     * @param file The name or path of the executable file to run.
			
 
				+     * @param args List of string arguments.
			
 
				+     * @return The stdout from the command.
			
 
				+     */
			
 
				+    function execFileSync(file: string): Buffer;
			
 
				+    function execFileSync(file: string, options: ExecFileSyncOptionsWithStringEncoding): string;
			
 
				+    function execFileSync(file: string, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
			
 
				+    function execFileSync(file: string, options?: ExecFileSyncOptions): string | Buffer;
			
 
				+    function execFileSync(file: string, args: ReadonlyArray<string>): Buffer;
			
 
				+    function execFileSync(file: string, args: ReadonlyArray<string>, options: ExecFileSyncOptionsWithStringEncoding): string;
			
 
				+    function execFileSync(file: string, args: ReadonlyArray<string>, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
			
 
				+    function execFileSync(file: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptions): string | Buffer;
			
 
				+}
			
 
				+declare module 'node:child_process' {
			
 
				+    export * from 'child_process';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/cluster.d.ts
+++ b/Asistent/node_modules/@types/node/cluster.d.ts
@@ -0,0 +1,410 @@
 
				+/**
			
 
				+ * Clusters of Node.js processes can be used to run multiple instances of Node.js
			
 
				+ * that can distribute workloads among their application threads. When process
			
 
				+ * isolation is not needed, use the `worker_threads` module instead, which
			
 
				+ * allows running multiple application threads within a single Node.js instance.
			
 
				+ *
			
 
				+ * The cluster module allows easy creation of child processes that all share
			
 
				+ * server ports.
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * import cluster from 'cluster';
			
 
				+ * import http from 'http';
			
 
				+ * import { cpus } from 'os';
			
 
				+ * import process from 'process';
			
 
				+ *
			
 
				+ * const numCPUs = cpus().length;
			
 
				+ *
			
 
				+ * if (cluster.isPrimary) {
			
 
				+ *   console.log(`Primary ${process.pid} is running`);
			
 
				+ *
			
 
				+ *   // Fork workers.
			
 
				+ *   for (let i = 0; i < numCPUs; i++) {
			
 
				+ *     cluster.fork();
			
 
				+ *   }
			
 
				+ *
			
 
				+ *   cluster.on('exit', (worker, code, signal) => {
			
 
				+ *     console.log(`worker ${worker.process.pid} died`);
			
 
				+ *   });
			
 
				+ * } else {
			
 
				+ *   // Workers can share any TCP connection
			
 
				+ *   // In this case it is an HTTP server
			
 
				+ *   http.createServer((req, res) => {
			
 
				+ *     res.writeHead(200);
			
 
				+ *     res.end('hello world\n');
			
 
				+ *   }).listen(8000);
			
 
				+ *
			
 
				+ *   console.log(`Worker ${process.pid} started`);
			
 
				+ * }
			
 
				+ * ```
			
 
				+ *
			
 
				+ * Running Node.js will now share port 8000 between the workers:
			
 
				+ *
			
 
				+ * ```console
			
 
				+ * $ node server.js
			
 
				+ * Primary 3596 is running
			
 
				+ * Worker 4324 started
			
 
				+ * Worker 4520 started
			
 
				+ * Worker 6056 started
			
 
				+ * Worker 5644 started
			
 
				+ * ```
			
 
				+ *
			
 
				+ * On Windows, it is not yet possible to set up a named pipe server in a worker.
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/cluster.js)
			
 
				+ */
			
 
				+declare module 'cluster' {
			
 
				+    import * as child from 'node:child_process';
			
 
				+    import EventEmitter = require('node:events');
			
 
				+    import * as net from 'node:net';
			
 
				+    export interface ClusterSettings {
			
 
				+        execArgv?: string[] | undefined; // default: process.execArgv
			
 
				+        exec?: string | undefined;
			
 
				+        args?: string[] | undefined;
			
 
				+        silent?: boolean | undefined;
			
 
				+        stdio?: any[] | undefined;
			
 
				+        uid?: number | undefined;
			
 
				+        gid?: number | undefined;
			
 
				+        inspectPort?: number | (() => number) | undefined;
			
 
				+    }
			
 
				+    export interface Address {
			
 
				+        address: string;
			
 
				+        port: number;
			
 
				+        addressType: number | 'udp4' | 'udp6'; // 4, 6, -1, "udp4", "udp6"
			
 
				+    }
			
 
				+    /**
			
 
				+     * A `Worker` object contains all public information and method about a worker.
			
 
				+     * In the primary it can be obtained using `cluster.workers`. In a worker
			
 
				+     * it can be obtained using `cluster.worker`.
			
 
				+     * @since v0.7.0
			
 
				+     */
			
 
				+    export class Worker extends EventEmitter {
			
 
				+        /**
			
 
				+         * Each new worker is given its own unique id, this id is stored in the`id`.
			
 
				+         *
			
 
				+         * While a worker is alive, this is the key that indexes it in`cluster.workers`.
			
 
				+         * @since v0.8.0
			
 
				+         */
			
 
				+        id: number;
			
 
				+        /**
			
 
				+         * All workers are created using `child_process.fork()`, the returned object
			
 
				+         * from this function is stored as `.process`. In a worker, the global `process`is stored.
			
 
				+         *
			
 
				+         * See: `Child Process module`.
			
 
				+         *
			
 
				+         * Workers will call `process.exit(0)` if the `'disconnect'` event occurs
			
 
				+         * on `process` and `.exitedAfterDisconnect` is not `true`. This protects against
			
 
				+         * accidental disconnection.
			
 
				+         * @since v0.7.0
			
 
				+         */
			
 
				+        process: child.ChildProcess;
			
 
				+        /**
			
 
				+         * Send a message to a worker or primary, optionally with a handle.
			
 
				+         *
			
 
				+         * In the primary, this sends a message to a specific worker. It is identical to `ChildProcess.send()`.
			
 
				+         *
			
 
				+         * In a worker, this sends a message to the primary. It is identical to`process.send()`.
			
 
				+         *
			
 
				+         * This example will echo back all messages from the primary:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * if (cluster.isPrimary) {
			
 
				+         *   const worker = cluster.fork();
			
 
				+         *   worker.send('hi there');
			
 
				+         *
			
 
				+         * } else if (cluster.isWorker) {
			
 
				+         *   process.on('message', (msg) => {
			
 
				+         *     process.send(msg);
			
 
				+         *   });
			
 
				+         * }
			
 
				+         * ```
			
 
				+         * @since v0.7.0
			
 
				+         * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles. `options` supports the following properties:
			
 
				+         */
			
 
				+        send(message: child.Serializable, callback?: (error: Error | null) => void): boolean;
			
 
				+        send(message: child.Serializable, sendHandle: child.SendHandle, callback?: (error: Error | null) => void): boolean;
			
 
				+        send(message: child.Serializable, sendHandle: child.SendHandle, options?: child.MessageOptions, callback?: (error: Error | null) => void): boolean;
			
 
				+        /**
			
 
				+         * This function will kill the worker. In the primary worker, it does this by
			
 
				+         * disconnecting the `worker.process`, and once disconnected, killing with`signal`. In the worker, it does it by killing the process with `signal`.
			
 
				+         *
			
 
				+         * The `kill()` function kills the worker process without waiting for a graceful
			
 
				+         * disconnect, it has the same behavior as `worker.process.kill()`.
			
 
				+         *
			
 
				+         * This method is aliased as `worker.destroy()` for backwards compatibility.
			
 
				+         *
			
 
				+         * In a worker, `process.kill()` exists, but it is not this function;
			
 
				+         * it is `kill()`.
			
 
				+         * @since v0.9.12
			
 
				+         * @param [signal='SIGTERM'] Name of the kill signal to send to the worker process.
			
 
				+         */
			
 
				+        kill(signal?: string): void;
			
 
				+        destroy(signal?: string): void;
			
 
				+        /**
			
 
				+         * In a worker, this function will close all servers, wait for the `'close'` event
			
 
				+         * on those servers, and then disconnect the IPC channel.
			
 
				+         *
			
 
				+         * In the primary, an internal message is sent to the worker causing it to call`.disconnect()` on itself.
			
 
				+         *
			
 
				+         * Causes `.exitedAfterDisconnect` to be set.
			
 
				+         *
			
 
				+         * After a server is closed, it will no longer accept new connections,
			
 
				+         * but connections may be accepted by any other listening worker. Existing
			
 
				+         * connections will be allowed to close as usual. When no more connections exist,
			
 
				+         * see `server.close()`, the IPC channel to the worker will close allowing it
			
 
				+         * to die gracefully.
			
 
				+         *
			
 
				+         * The above applies _only_ to server connections, client connections are not
			
 
				+         * automatically closed by workers, and disconnect does not wait for them to close
			
 
				+         * before exiting.
			
 
				+         *
			
 
				+         * In a worker, `process.disconnect` exists, but it is not this function;
			
 
				+         * it is `disconnect()`.
			
 
				+         *
			
 
				+         * Because long living server connections may block workers from disconnecting, it
			
 
				+         * may be useful to send a message, so application specific actions may be taken to
			
 
				+         * close them. It also may be useful to implement a timeout, killing a worker if
			
 
				+         * the `'disconnect'` event has not been emitted after some time.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * if (cluster.isPrimary) {
			
 
				+         *   const worker = cluster.fork();
			
 
				+         *   let timeout;
			
 
				+         *
			
 
				+         *   worker.on('listening', (address) => {
			
 
				+         *     worker.send('shutdown');
			
 
				+         *     worker.disconnect();
			
 
				+         *     timeout = setTimeout(() => {
			
 
				+         *       worker.kill();
			
 
				+         *     }, 2000);
			
 
				+         *   });
			
 
				+         *
			
 
				+         *   worker.on('disconnect', () => {
			
 
				+         *     clearTimeout(timeout);
			
 
				+         *   });
			
 
				+         *
			
 
				+         * } else if (cluster.isWorker) {
			
 
				+         *   const net = require('net');
			
 
				+         *   const server = net.createServer((socket) => {
			
 
				+         *     // Connections never end
			
 
				+         *   });
			
 
				+         *
			
 
				+         *   server.listen(8000);
			
 
				+         *
			
 
				+         *   process.on('message', (msg) => {
			
 
				+         *     if (msg === 'shutdown') {
			
 
				+         *       // Initiate graceful close of any connections to server
			
 
				+         *     }
			
 
				+         *   });
			
 
				+         * }
			
 
				+         * ```
			
 
				+         * @since v0.7.7
			
 
				+         * @return A reference to `worker`.
			
 
				+         */
			
 
				+        disconnect(): void;
			
 
				+        /**
			
 
				+         * This function returns `true` if the worker is connected to its primary via its
			
 
				+         * IPC channel, `false` otherwise. A worker is connected to its primary after it
			
 
				+         * has been created. It is disconnected after the `'disconnect'` event is emitted.
			
 
				+         * @since v0.11.14
			
 
				+         */
			
 
				+        isConnected(): boolean;
			
 
				+        /**
			
 
				+         * This function returns `true` if the worker's process has terminated (either
			
 
				+         * because of exiting or being signaled). Otherwise, it returns `false`.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import cluster from 'cluster';
			
 
				+         * import http from 'http';
			
 
				+         * import { cpus } from 'os';
			
 
				+         * import process from 'process';
			
 
				+         *
			
 
				+         * const numCPUs = cpus().length;
			
 
				+         *
			
 
				+         * if (cluster.isPrimary) {
			
 
				+         *   console.log(`Primary ${process.pid} is running`);
			
 
				+         *
			
 
				+         *   // Fork workers.
			
 
				+         *   for (let i = 0; i < numCPUs; i++) {
			
 
				+         *     cluster.fork();
			
 
				+         *   }
			
 
				+         *
			
 
				+         *   cluster.on('fork', (worker) => {
			
 
				+         *     console.log('worker is dead:', worker.isDead());
			
 
				+         *   });
			
 
				+         *
			
 
				+         *   cluster.on('exit', (worker, code, signal) => {
			
 
				+         *     console.log('worker is dead:', worker.isDead());
			
 
				+         *   });
			
 
				+         * } else {
			
 
				+         *   // Workers can share any TCP connection. In this case, it is an HTTP server.
			
 
				+         *   http.createServer((req, res) => {
			
 
				+         *     res.writeHead(200);
			
 
				+         *     res.end(`Current process\n ${process.pid}`);
			
 
				+         *     process.kill(process.pid);
			
 
				+         *   }).listen(8000);
			
 
				+         * }
			
 
				+         * ```
			
 
				+         * @since v0.11.14
			
 
				+         */
			
 
				+        isDead(): boolean;
			
 
				+        /**
			
 
				+         * This property is `true` if the worker exited due to `.disconnect()`.
			
 
				+         * If the worker exited any other way, it is `false`. If the
			
 
				+         * worker has not exited, it is `undefined`.
			
 
				+         *
			
 
				+         * The boolean `worker.exitedAfterDisconnect` allows distinguishing between
			
 
				+         * voluntary and accidental exit, the primary may choose not to respawn a worker
			
 
				+         * based on this value.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * cluster.on('exit', (worker, code, signal) => {
			
 
				+         *   if (worker.exitedAfterDisconnect === true) {
			
 
				+         *     console.log('Oh, it was just voluntary – no need to worry');
			
 
				+         *   }
			
 
				+         * });
			
 
				+         *
			
 
				+         * // kill worker
			
 
				+         * worker.kill();
			
 
				+         * ```
			
 
				+         * @since v6.0.0
			
 
				+         */
			
 
				+        exitedAfterDisconnect: boolean;
			
 
				+        /**
			
 
				+         * events.EventEmitter
			
 
				+         *   1. disconnect
			
 
				+         *   2. error
			
 
				+         *   3. exit
			
 
				+         *   4. listening
			
 
				+         *   5. message
			
 
				+         *   6. online
			
 
				+         */
			
 
				+        addListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        addListener(event: 'disconnect', listener: () => void): this;
			
 
				+        addListener(event: 'error', listener: (error: Error) => void): this;
			
 
				+        addListener(event: 'exit', listener: (code: number, signal: string) => void): this;
			
 
				+        addListener(event: 'listening', listener: (address: Address) => void): this;
			
 
				+        addListener(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        addListener(event: 'online', listener: () => void): this;
			
 
				+        emit(event: string | symbol, ...args: any[]): boolean;
			
 
				+        emit(event: 'disconnect'): boolean;
			
 
				+        emit(event: 'error', error: Error): boolean;
			
 
				+        emit(event: 'exit', code: number, signal: string): boolean;
			
 
				+        emit(event: 'listening', address: Address): boolean;
			
 
				+        emit(event: 'message', message: any, handle: net.Socket | net.Server): boolean;
			
 
				+        emit(event: 'online'): boolean;
			
 
				+        on(event: string, listener: (...args: any[]) => void): this;
			
 
				+        on(event: 'disconnect', listener: () => void): this;
			
 
				+        on(event: 'error', listener: (error: Error) => void): this;
			
 
				+        on(event: 'exit', listener: (code: number, signal: string) => void): this;
			
 
				+        on(event: 'listening', listener: (address: Address) => void): this;
			
 
				+        on(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        on(event: 'online', listener: () => void): this;
			
 
				+        once(event: string, listener: (...args: any[]) => void): this;
			
 
				+        once(event: 'disconnect', listener: () => void): this;
			
 
				+        once(event: 'error', listener: (error: Error) => void): this;
			
 
				+        once(event: 'exit', listener: (code: number, signal: string) => void): this;
			
 
				+        once(event: 'listening', listener: (address: Address) => void): this;
			
 
				+        once(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        once(event: 'online', listener: () => void): this;
			
 
				+        prependListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependListener(event: 'disconnect', listener: () => void): this;
			
 
				+        prependListener(event: 'error', listener: (error: Error) => void): this;
			
 
				+        prependListener(event: 'exit', listener: (code: number, signal: string) => void): this;
			
 
				+        prependListener(event: 'listening', listener: (address: Address) => void): this;
			
 
				+        prependListener(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        prependListener(event: 'online', listener: () => void): this;
			
 
				+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependOnceListener(event: 'disconnect', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'error', listener: (error: Error) => void): this;
			
 
				+        prependOnceListener(event: 'exit', listener: (code: number, signal: string) => void): this;
			
 
				+        prependOnceListener(event: 'listening', listener: (address: Address) => void): this;
			
 
				+        prependOnceListener(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        prependOnceListener(event: 'online', listener: () => void): this;
			
 
				+    }
			
 
				+    export interface Cluster extends EventEmitter {
			
 
				+        disconnect(callback?: () => void): void;
			
 
				+        fork(env?: any): Worker;
			
 
				+        /** @deprecated since v16.0.0 - use isPrimary. */
			
 
				+        readonly isMaster: boolean;
			
 
				+        readonly isPrimary: boolean;
			
 
				+        readonly isWorker: boolean;
			
 
				+        schedulingPolicy: number;
			
 
				+        readonly settings: ClusterSettings;
			
 
				+        /** @deprecated since v16.0.0 - use setupPrimary. */
			
 
				+        setupMaster(settings?: ClusterSettings): void;
			
 
				+        /**
			
 
				+         * `setupPrimary` is used to change the default 'fork' behavior. Once called, the settings will be present in cluster.settings.
			
 
				+         */
			
 
				+        setupPrimary(settings?: ClusterSettings): void;
			
 
				+        readonly worker?: Worker | undefined;
			
 
				+        readonly workers?: NodeJS.Dict<Worker> | undefined;
			
 
				+        readonly SCHED_NONE: number;
			
 
				+        readonly SCHED_RR: number;
			
 
				+        /**
			
 
				+         * events.EventEmitter
			
 
				+         *   1. disconnect
			
 
				+         *   2. exit
			
 
				+         *   3. fork
			
 
				+         *   4. listening
			
 
				+         *   5. message
			
 
				+         *   6. online
			
 
				+         *   7. setup
			
 
				+         */
			
 
				+        addListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        addListener(event: 'disconnect', listener: (worker: Worker) => void): this;
			
 
				+        addListener(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
			
 
				+        addListener(event: 'fork', listener: (worker: Worker) => void): this;
			
 
				+        addListener(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
			
 
				+        addListener(event: 'message', listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        addListener(event: 'online', listener: (worker: Worker) => void): this;
			
 
				+        addListener(event: 'setup', listener: (settings: ClusterSettings) => void): this;
			
 
				+        emit(event: string | symbol, ...args: any[]): boolean;
			
 
				+        emit(event: 'disconnect', worker: Worker): boolean;
			
 
				+        emit(event: 'exit', worker: Worker, code: number, signal: string): boolean;
			
 
				+        emit(event: 'fork', worker: Worker): boolean;
			
 
				+        emit(event: 'listening', worker: Worker, address: Address): boolean;
			
 
				+        emit(event: 'message', worker: Worker, message: any, handle: net.Socket | net.Server): boolean;
			
 
				+        emit(event: 'online', worker: Worker): boolean;
			
 
				+        emit(event: 'setup', settings: ClusterSettings): boolean;
			
 
				+        on(event: string, listener: (...args: any[]) => void): this;
			
 
				+        on(event: 'disconnect', listener: (worker: Worker) => void): this;
			
 
				+        on(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
			
 
				+        on(event: 'fork', listener: (worker: Worker) => void): this;
			
 
				+        on(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
			
 
				+        on(event: 'message', listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        on(event: 'online', listener: (worker: Worker) => void): this;
			
 
				+        on(event: 'setup', listener: (settings: ClusterSettings) => void): this;
			
 
				+        once(event: string, listener: (...args: any[]) => void): this;
			
 
				+        once(event: 'disconnect', listener: (worker: Worker) => void): this;
			
 
				+        once(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
			
 
				+        once(event: 'fork', listener: (worker: Worker) => void): this;
			
 
				+        once(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
			
 
				+        once(event: 'message', listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        once(event: 'online', listener: (worker: Worker) => void): this;
			
 
				+        once(event: 'setup', listener: (settings: ClusterSettings) => void): this;
			
 
				+        prependListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependListener(event: 'disconnect', listener: (worker: Worker) => void): this;
			
 
				+        prependListener(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
			
 
				+        prependListener(event: 'fork', listener: (worker: Worker) => void): this;
			
 
				+        prependListener(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
			
 
				+        // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        prependListener(event: 'message', listener: (worker: Worker, message: any, handle?: net.Socket | net.Server) => void): this;
			
 
				+        prependListener(event: 'online', listener: (worker: Worker) => void): this;
			
 
				+        prependListener(event: 'setup', listener: (settings: ClusterSettings) => void): this;
			
 
				+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependOnceListener(event: 'disconnect', listener: (worker: Worker) => void): this;
			
 
				+        prependOnceListener(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
			
 
				+        prependOnceListener(event: 'fork', listener: (worker: Worker) => void): this;
			
 
				+        prependOnceListener(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
			
 
				+        // the handle is a net.Socket or net.Server object, or undefined.
			
 
				+        prependOnceListener(event: 'message', listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;
			
 
				+        prependOnceListener(event: 'online', listener: (worker: Worker) => void): this;
			
 
				+        prependOnceListener(event: 'setup', listener: (settings: ClusterSettings) => void): this;
			
 
				+    }
			
 
				+    const cluster: Cluster;
			
 
				+    export default cluster;
			
 
				+}
			
 
				+declare module 'node:cluster' {
			
 
				+    export * from 'cluster';
			
 
				+    export { default as default } from 'cluster';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/console.d.ts
+++ b/Asistent/node_modules/@types/node/console.d.ts
@@ -0,0 +1,412 @@
 
				+/**
			
 
				+ * The `console` module provides a simple debugging console that is similar to the
			
 
				+ * JavaScript console mechanism provided by web browsers.
			
 
				+ *
			
 
				+ * The module exports two specific components:
			
 
				+ *
			
 
				+ * * A `Console` class with methods such as `console.log()`, `console.error()` and`console.warn()` that can be used to write to any Node.js stream.
			
 
				+ * * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('console')`.
			
 
				+ *
			
 
				+ * _**Warning**_: The global console object's methods are neither consistently
			
 
				+ * synchronous like the browser APIs they resemble, nor are they consistently
			
 
				+ * asynchronous like all other Node.js streams. See the `note on process I/O` for
			
 
				+ * more information.
			
 
				+ *
			
 
				+ * Example using the global `console`:
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * console.log('hello world');
			
 
				+ * // Prints: hello world, to stdout
			
 
				+ * console.log('hello %s', 'world');
			
 
				+ * // Prints: hello world, to stdout
			
 
				+ * console.error(new Error('Whoops, something bad happened'));
			
 
				+ * // Prints error message and stack trace to stderr:
			
 
				+ * //   Error: Whoops, something bad happened
			
 
				+ * //     at [eval]:5:15
			
 
				+ * //     at Script.runInThisContext (node:vm:132:18)
			
 
				+ * //     at Object.runInThisContext (node:vm:309:38)
			
 
				+ * //     at node:internal/process/execution:77:19
			
 
				+ * //     at [eval]-wrapper:6:22
			
 
				+ * //     at evalScript (node:internal/process/execution:76:60)
			
 
				+ * //     at node:internal/main/eval_string:23:3
			
 
				+ *
			
 
				+ * const name = 'Will Robinson';
			
 
				+ * console.warn(`Danger ${name}! Danger!`);
			
 
				+ * // Prints: Danger Will Robinson! Danger!, to stderr
			
 
				+ * ```
			
 
				+ *
			
 
				+ * Example using the `Console` class:
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * const out = getStreamSomehow();
			
 
				+ * const err = getStreamSomehow();
			
 
				+ * const myConsole = new console.Console(out, err);
			
 
				+ *
			
 
				+ * myConsole.log('hello world');
			
 
				+ * // Prints: hello world, to out
			
 
				+ * myConsole.log('hello %s', 'world');
			
 
				+ * // Prints: hello world, to out
			
 
				+ * myConsole.error(new Error('Whoops, something bad happened'));
			
 
				+ * // Prints: [Error: Whoops, something bad happened], to err
			
 
				+ *
			
 
				+ * const name = 'Will Robinson';
			
 
				+ * myConsole.warn(`Danger ${name}! Danger!`);
			
 
				+ * // Prints: Danger Will Robinson! Danger!, to err
			
 
				+ * ```
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/console.js)
			
 
				+ */
			
 
				+declare module 'console' {
			
 
				+    import console = require('node:console');
			
 
				+    export = console;
			
 
				+}
			
 
				+declare module 'node:console' {
			
 
				+    import { InspectOptions } from 'node:util';
			
 
				+    global {
			
 
				+        // This needs to be global to avoid TS2403 in case lib.dom.d.ts is present in the same build
			
 
				+        interface Console {
			
 
				+            Console: console.ConsoleConstructor;
			
 
				+            /**
			
 
				+             * `console.assert()` writes a message if `value` is [falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) or omitted. It only
			
 
				+             * writes a message and does not otherwise affect execution. The output always
			
 
				+             * starts with `"Assertion failed"`. If provided, `message` is formatted using `util.format()`.
			
 
				+             *
			
 
				+             * If `value` is [truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy), nothing happens.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * console.assert(true, 'does nothing');
			
 
				+             *
			
 
				+             * console.assert(false, 'Whoops %s work', 'didn\'t');
			
 
				+             * // Assertion failed: Whoops didn't work
			
 
				+             *
			
 
				+             * console.assert();
			
 
				+             * // Assertion failed
			
 
				+             * ```
			
 
				+             * @since v0.1.101
			
 
				+             * @param value The value tested for being truthy.
			
 
				+             * @param message All arguments besides `value` are used as error message.
			
 
				+             */
			
 
				+            assert(value: any, message?: string, ...optionalParams: any[]): void;
			
 
				+            /**
			
 
				+             * When `stdout` is a TTY, calling `console.clear()` will attempt to clear the
			
 
				+             * TTY. When `stdout` is not a TTY, this method does nothing.
			
 
				+             *
			
 
				+             * The specific operation of `console.clear()` can vary across operating systems
			
 
				+             * and terminal types. For most Linux operating systems, `console.clear()`operates similarly to the `clear` shell command. On Windows, `console.clear()`will clear only the output in the
			
 
				+             * current terminal viewport for the Node.js
			
 
				+             * binary.
			
 
				+             * @since v8.3.0
			
 
				+             */
			
 
				+            clear(): void;
			
 
				+            /**
			
 
				+             * Maintains an internal counter specific to `label` and outputs to `stdout` the
			
 
				+             * number of times `console.count()` has been called with the given `label`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * > console.count()
			
 
				+             * default: 1
			
 
				+             * undefined
			
 
				+             * > console.count('default')
			
 
				+             * default: 2
			
 
				+             * undefined
			
 
				+             * > console.count('abc')
			
 
				+             * abc: 1
			
 
				+             * undefined
			
 
				+             * > console.count('xyz')
			
 
				+             * xyz: 1
			
 
				+             * undefined
			
 
				+             * > console.count('abc')
			
 
				+             * abc: 2
			
 
				+             * undefined
			
 
				+             * > console.count()
			
 
				+             * default: 3
			
 
				+             * undefined
			
 
				+             * >
			
 
				+             * ```
			
 
				+             * @since v8.3.0
			
 
				+             * @param label The display label for the counter.
			
 
				+             */
			
 
				+            count(label?: string): void;
			
 
				+            /**
			
 
				+             * Resets the internal counter specific to `label`.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * > console.count('abc');
			
 
				+             * abc: 1
			
 
				+             * undefined
			
 
				+             * > console.countReset('abc');
			
 
				+             * undefined
			
 
				+             * > console.count('abc');
			
 
				+             * abc: 1
			
 
				+             * undefined
			
 
				+             * >
			
 
				+             * ```
			
 
				+             * @since v8.3.0
			
 
				+             * @param label The display label for the counter.
			
 
				+             */
			
 
				+            countReset(label?: string): void;
			
 
				+            /**
			
 
				+             * The `console.debug()` function is an alias for {@link log}.
			
 
				+             * @since v8.0.0
			
 
				+             */
			
 
				+            debug(message?: any, ...optionalParams: any[]): void;
			
 
				+            /**
			
 
				+             * Uses `util.inspect()` on `obj` and prints the resulting string to `stdout`.
			
 
				+             * This function bypasses any custom `inspect()` function defined on `obj`.
			
 
				+             * @since v0.1.101
			
 
				+             */
			
 
				+            dir(obj: any, options?: InspectOptions): void;
			
 
				+            /**
			
 
				+             * This method calls `console.log()` passing it the arguments received.
			
 
				+             * This method does not produce any XML formatting.
			
 
				+             * @since v8.0.0
			
 
				+             */
			
 
				+            dirxml(...data: any[]): void;
			
 
				+            /**
			
 
				+             * Prints to `stderr` with newline. Multiple arguments can be passed, with the
			
 
				+             * first used as the primary message and all additional used as substitution
			
 
				+             * values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html) (the arguments are all passed to `util.format()`).
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * const code = 5;
			
 
				+             * console.error('error #%d', code);
			
 
				+             * // Prints: error #5, to stderr
			
 
				+             * console.error('error', code);
			
 
				+             * // Prints: error 5, to stderr
			
 
				+             * ```
			
 
				+             *
			
 
				+             * If formatting elements (e.g. `%d`) are not found in the first string then `util.inspect()` is called on each argument and the resulting string
			
 
				+             * values are concatenated. See `util.format()` for more information.
			
 
				+             * @since v0.1.100
			
 
				+             */
			
 
				+            error(message?: any, ...optionalParams: any[]): void;
			
 
				+            /**
			
 
				+             * Increases indentation of subsequent lines by spaces for `groupIndentation`length.
			
 
				+             *
			
 
				+             * If one or more `label`s are provided, those are printed first without the
			
 
				+             * additional indentation.
			
 
				+             * @since v8.5.0
			
 
				+             */
			
 
				+            group(...label: any[]): void;
			
 
				+            /**
			
 
				+             * An alias for {@link group}.
			
 
				+             * @since v8.5.0
			
 
				+             */
			
 
				+            groupCollapsed(...label: any[]): void;
			
 
				+            /**
			
 
				+             * Decreases indentation of subsequent lines by spaces for `groupIndentation`length.
			
 
				+             * @since v8.5.0
			
 
				+             */
			
 
				+            groupEnd(): void;
			
 
				+            /**
			
 
				+             * The `console.info()` function is an alias for {@link log}.
			
 
				+             * @since v0.1.100
			
 
				+             */
			
 
				+            info(message?: any, ...optionalParams: any[]): void;
			
 
				+            /**
			
 
				+             * Prints to `stdout` with newline. Multiple arguments can be passed, with the
			
 
				+             * first used as the primary message and all additional used as substitution
			
 
				+             * values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html) (the arguments are all passed to `util.format()`).
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * const count = 5;
			
 
				+             * console.log('count: %d', count);
			
 
				+             * // Prints: count: 5, to stdout
			
 
				+             * console.log('count:', count);
			
 
				+             * // Prints: count: 5, to stdout
			
 
				+             * ```
			
 
				+             *
			
 
				+             * See `util.format()` for more information.
			
 
				+             * @since v0.1.100
			
 
				+             */
			
 
				+            log(message?: any, ...optionalParams: any[]): void;
			
 
				+            /**
			
 
				+             * Try to construct a table with the columns of the properties of `tabularData`(or use `properties`) and rows of `tabularData` and log it. Falls back to just
			
 
				+             * logging the argument if it can’t be parsed as tabular.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * // These can't be parsed as tabular data
			
 
				+             * console.table(Symbol());
			
 
				+             * // Symbol()
			
 
				+             *
			
 
				+             * console.table(undefined);
			
 
				+             * // undefined
			
 
				+             *
			
 
				+             * console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }]);
			
 
				+             * // ┌─────────┬─────┬─────┐
			
 
				+             * // │ (index) │  a  │  b  │
			
 
				+             * // ├─────────┼─────┼─────┤
			
 
				+             * // │    0    │  1  │ 'Y' │
			
 
				+             * // │    1    │ 'Z' │  2  │
			
 
				+             * // └─────────┴─────┴─────┘
			
 
				+             *
			
 
				+             * console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }], ['a']);
			
 
				+             * // ┌─────────┬─────┐
			
 
				+             * // │ (index) │  a  │
			
 
				+             * // ├─────────┼─────┤
			
 
				+             * // │    0    │  1  │
			
 
				+             * // │    1    │ 'Z' │
			
 
				+             * // └─────────┴─────┘
			
 
				+             * ```
			
 
				+             * @since v10.0.0
			
 
				+             * @param properties Alternate properties for constructing the table.
			
 
				+             */
			
 
				+            table(tabularData: any, properties?: ReadonlyArray<string>): void;
			
 
				+            /**
			
 
				+             * Starts a timer that can be used to compute the duration of an operation. Timers
			
 
				+             * are identified by a unique `label`. Use the same `label` when calling {@link timeEnd} to stop the timer and output the elapsed time in
			
 
				+             * suitable time units to `stdout`. For example, if the elapsed
			
 
				+             * time is 3869ms, `console.timeEnd()` displays "3.869s".
			
 
				+             * @since v0.1.104
			
 
				+             */
			
 
				+            time(label?: string): void;
			
 
				+            /**
			
 
				+             * Stops a timer that was previously started by calling {@link time} and
			
 
				+             * prints the result to `stdout`:
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * console.time('100-elements');
			
 
				+             * for (let i = 0; i < 100; i++) {}
			
 
				+             * console.timeEnd('100-elements');
			
 
				+             * // prints 100-elements: 225.438ms
			
 
				+             * ```
			
 
				+             * @since v0.1.104
			
 
				+             */
			
 
				+            timeEnd(label?: string): void;
			
 
				+            /**
			
 
				+             * For a timer that was previously started by calling {@link time}, prints
			
 
				+             * the elapsed time and other `data` arguments to `stdout`:
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * console.time('process');
			
 
				+             * const value = expensiveProcess1(); // Returns 42
			
 
				+             * console.timeLog('process', value);
			
 
				+             * // Prints "process: 365.227ms 42".
			
 
				+             * doExpensiveProcess2(value);
			
 
				+             * console.timeEnd('process');
			
 
				+             * ```
			
 
				+             * @since v10.7.0
			
 
				+             */
			
 
				+            timeLog(label?: string, ...data: any[]): void;
			
 
				+            /**
			
 
				+             * Prints to `stderr` the string `'Trace: '`, followed by the `util.format()` formatted message and stack trace to the current position in the code.
			
 
				+             *
			
 
				+             * ```js
			
 
				+             * console.trace('Show me');
			
 
				+             * // Prints: (stack trace will vary based on where trace is called)
			
 
				+             * //  Trace: Show me
			
 
				+             * //    at repl:2:9
			
 
				+             * //    at REPLServer.defaultEval (repl.js:248:27)
			
 
				+             * //    at bound (domain.js:287:14)
			
 
				+             * //    at REPLServer.runBound [as eval] (domain.js:300:12)
			
 
				+             * //    at REPLServer.<anonymous> (repl.js:412:12)
			
 
				+             * //    at emitOne (events.js:82:20)
			
 
				+             * //    at REPLServer.emit (events.js:169:7)
			
 
				+             * //    at REPLServer.Interface._onLine (readline.js:210:10)
			
 
				+             * //    at REPLServer.Interface._line (readline.js:549:8)
			
 
				+             * //    at REPLServer.Interface._ttyWrite (readline.js:826:14)
			
 
				+             * ```
			
 
				+             * @since v0.1.104
			
 
				+             */
			
 
				+            trace(message?: any, ...optionalParams: any[]): void;
			
 
				+            /**
			
 
				+             * The `console.warn()` function is an alias for {@link error}.
			
 
				+             * @since v0.1.100
			
 
				+             */
			
 
				+            warn(message?: any, ...optionalParams: any[]): void;
			
 
				+            // --- Inspector mode only ---
			
 
				+            /**
			
 
				+             * This method does not display anything unless used in the inspector.
			
 
				+             *  Starts a JavaScript CPU profile with an optional label.
			
 
				+             */
			
 
				+            profile(label?: string): void;
			
 
				+            /**
			
 
				+             * This method does not display anything unless used in the inspector.
			
 
				+             *  Stops the current JavaScript CPU profiling session if one has been started and prints the report to the Profiles panel of the inspector.
			
 
				+             */
			
 
				+            profileEnd(label?: string): void;
			
 
				+            /**
			
 
				+             * This method does not display anything unless used in the inspector.
			
 
				+             *  Adds an event with the label `label` to the Timeline panel of the inspector.
			
 
				+             */
			
 
				+            timeStamp(label?: string): void;
			
 
				+        }
			
 
				+        /**
			
 
				+         * The `console` module provides a simple debugging console that is similar to the
			
 
				+         * JavaScript console mechanism provided by web browsers.
			
 
				+         *
			
 
				+         * The module exports two specific components:
			
 
				+         *
			
 
				+         * * A `Console` class with methods such as `console.log()`, `console.error()` and`console.warn()` that can be used to write to any Node.js stream.
			
 
				+         * * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('console')`.
			
 
				+         *
			
 
				+         * _**Warning**_: The global console object's methods are neither consistently
			
 
				+         * synchronous like the browser APIs they resemble, nor are they consistently
			
 
				+         * asynchronous like all other Node.js streams. See the `note on process I/O` for
			
 
				+         * more information.
			
 
				+         *
			
 
				+         * Example using the global `console`:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * console.log('hello world');
			
 
				+         * // Prints: hello world, to stdout
			
 
				+         * console.log('hello %s', 'world');
			
 
				+         * // Prints: hello world, to stdout
			
 
				+         * console.error(new Error('Whoops, something bad happened'));
			
 
				+         * // Prints error message and stack trace to stderr:
			
 
				+         * //   Error: Whoops, something bad happened
			
 
				+         * //     at [eval]:5:15
			
 
				+         * //     at Script.runInThisContext (node:vm:132:18)
			
 
				+         * //     at Object.runInThisContext (node:vm:309:38)
			
 
				+         * //     at node:internal/process/execution:77:19
			
 
				+         * //     at [eval]-wrapper:6:22
			
 
				+         * //     at evalScript (node:internal/process/execution:76:60)
			
 
				+         * //     at node:internal/main/eval_string:23:3
			
 
				+         *
			
 
				+         * const name = 'Will Robinson';
			
 
				+         * console.warn(`Danger ${name}! Danger!`);
			
 
				+         * // Prints: Danger Will Robinson! Danger!, to stderr
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Example using the `Console` class:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const out = getStreamSomehow();
			
 
				+         * const err = getStreamSomehow();
			
 
				+         * const myConsole = new console.Console(out, err);
			
 
				+         *
			
 
				+         * myConsole.log('hello world');
			
 
				+         * // Prints: hello world, to out
			
 
				+         * myConsole.log('hello %s', 'world');
			
 
				+         * // Prints: hello world, to out
			
 
				+         * myConsole.error(new Error('Whoops, something bad happened'));
			
 
				+         * // Prints: [Error: Whoops, something bad happened], to err
			
 
				+         *
			
 
				+         * const name = 'Will Robinson';
			
 
				+         * myConsole.warn(`Danger ${name}! Danger!`);
			
 
				+         * // Prints: Danger Will Robinson! Danger!, to err
			
 
				+         * ```
			
 
				+         * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/console.js)
			
 
				+         */
			
 
				+        namespace console {
			
 
				+            interface ConsoleConstructorOptions {
			
 
				+                stdout: NodeJS.WritableStream;
			
 
				+                stderr?: NodeJS.WritableStream | undefined;
			
 
				+                ignoreErrors?: boolean | undefined;
			
 
				+                colorMode?: boolean | 'auto' | undefined;
			
 
				+                inspectOptions?: InspectOptions | undefined;
			
 
				+                /**
			
 
				+                 * Set group indentation
			
 
				+                 * @default 2
			
 
				+                 */
			
 
				+                groupIndentation?: number | undefined;
			
 
				+            }
			
 
				+            interface ConsoleConstructor {
			
 
				+                prototype: Console;
			
 
				+                new (stdout: NodeJS.WritableStream, stderr?: NodeJS.WritableStream, ignoreErrors?: boolean): Console;
			
 
				+                new (options: ConsoleConstructorOptions): Console;
			
 
				+            }
			
 
				+        }
			
 
				+        var console: Console;
			
 
				+    }
			
 
				+    export = globalThis.console;
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/constants.d.ts
+++ b/Asistent/node_modules/@types/node/constants.d.ts
@@ -0,0 +1,18 @@
 
				+/** @deprecated since v6.3.0 - use constants property exposed by the relevant module instead. */
			
 
				+declare module 'constants' {
			
 
				+    import { constants as osConstants, SignalConstants } from 'node:os';
			
 
				+    import { constants as cryptoConstants } from 'node:crypto';
			
 
				+    import { constants as fsConstants } from 'node:fs';
			
 
				+
			
 
				+    const exp: typeof osConstants.errno &
			
 
				+        typeof osConstants.priority &
			
 
				+        SignalConstants &
			
 
				+        typeof cryptoConstants &
			
 
				+        typeof fsConstants;
			
 
				+    export = exp;
			
 
				+}
			
 
				+
			
 
				+declare module 'node:constants' {
			
 
				+    import constants = require('constants');
			
 
				+    export = constants;
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/crypto.d.ts
+++ b/Asistent/node_modules/@types/node/crypto.d.ts
@@ -0,0 +1,3966 @@
 
				+/**
			
 
				+ * The `crypto` module provides cryptographic functionality that includes a set of
			
 
				+ * wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions.
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * const { createHmac } = await import('crypto');
			
 
				+ *
			
 
				+ * const secret = 'abcdefg';
			
 
				+ * const hash = createHmac('sha256', secret)
			
 
				+ *                .update('I love cupcakes')
			
 
				+ *                .digest('hex');
			
 
				+ * console.log(hash);
			
 
				+ * // Prints:
			
 
				+ * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
			
 
				+ * ```
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/crypto.js)
			
 
				+ */
			
 
				+declare module 'crypto' {
			
 
				+    import * as stream from 'node:stream';
			
 
				+    import { PeerCertificate } from 'node:tls';
			
 
				+    /**
			
 
				+     * SPKAC is a Certificate Signing Request mechanism originally implemented by
			
 
				+     * Netscape and was specified formally as part of [HTML5's `keygen` element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/keygen).
			
 
				+     *
			
 
				+     * `<keygen>` is deprecated since [HTML 5.2](https://www.w3.org/TR/html52/changes.html#features-removed) and new projects
			
 
				+     * should not use this element anymore.
			
 
				+     *
			
 
				+     * The `crypto` module provides the `Certificate` class for working with SPKAC
			
 
				+     * data. The most common usage is handling output generated by the HTML5`<keygen>` element. Node.js uses [OpenSSL's SPKAC
			
 
				+     * implementation](https://www.openssl.org/docs/man1.1.0/apps/openssl-spkac.html) internally.
			
 
				+     * @since v0.11.8
			
 
				+     */
			
 
				+    class Certificate {
			
 
				+        /**
			
 
				+         * ```js
			
 
				+         * const { Certificate } = await import('crypto');
			
 
				+         * const spkac = getSpkacSomehow();
			
 
				+         * const challenge = Certificate.exportChallenge(spkac);
			
 
				+         * console.log(challenge.toString('utf8'));
			
 
				+         * // Prints: the challenge as a UTF8 string
			
 
				+         * ```
			
 
				+         * @since v9.0.0
			
 
				+         * @param encoding The `encoding` of the `spkac` string.
			
 
				+         * @return The challenge component of the `spkac` data structure, which includes a public key and a challenge.
			
 
				+         */
			
 
				+        static exportChallenge(spkac: BinaryLike): Buffer;
			
 
				+        /**
			
 
				+         * ```js
			
 
				+         * const { Certificate } = await import('crypto');
			
 
				+         * const spkac = getSpkacSomehow();
			
 
				+         * const publicKey = Certificate.exportPublicKey(spkac);
			
 
				+         * console.log(publicKey);
			
 
				+         * // Prints: the public key as <Buffer ...>
			
 
				+         * ```
			
 
				+         * @since v9.0.0
			
 
				+         * @param encoding The `encoding` of the `spkac` string.
			
 
				+         * @return The public key component of the `spkac` data structure, which includes a public key and a challenge.
			
 
				+         */
			
 
				+        static exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer;
			
 
				+        /**
			
 
				+         * ```js
			
 
				+         * import { Buffer } from 'buffer';
			
 
				+         * const { Certificate } = await import('crypto');
			
 
				+         *
			
 
				+         * const spkac = getSpkacSomehow();
			
 
				+         * console.log(Certificate.verifySpkac(Buffer.from(spkac)));
			
 
				+         * // Prints: true or false
			
 
				+         * ```
			
 
				+         * @since v9.0.0
			
 
				+         * @param encoding The `encoding` of the `spkac` string.
			
 
				+         * @return `true` if the given `spkac` data structure is valid, `false` otherwise.
			
 
				+         */
			
 
				+        static verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
			
 
				+        /**
			
 
				+         * @deprecated
			
 
				+         * @param spkac
			
 
				+         * @returns The challenge component of the `spkac` data structure,
			
 
				+         * which includes a public key and a challenge.
			
 
				+         */
			
 
				+        exportChallenge(spkac: BinaryLike): Buffer;
			
 
				+        /**
			
 
				+         * @deprecated
			
 
				+         * @param spkac
			
 
				+         * @param encoding The encoding of the spkac string.
			
 
				+         * @returns The public key component of the `spkac` data structure,
			
 
				+         * which includes a public key and a challenge.
			
 
				+         */
			
 
				+        exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer;
			
 
				+        /**
			
 
				+         * @deprecated
			
 
				+         * @param spkac
			
 
				+         * @returns `true` if the given `spkac` data structure is valid,
			
 
				+         * `false` otherwise.
			
 
				+         */
			
 
				+        verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
			
 
				+    }
			
 
				+    namespace constants {
			
 
				+        // https://nodejs.org/dist/latest-v10.x/docs/api/crypto.html#crypto_crypto_constants
			
 
				+        const OPENSSL_VERSION_NUMBER: number;
			
 
				+        /** Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail. */
			
 
				+        const SSL_OP_ALL: number;
			
 
				+        /** Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */
			
 
				+        const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;
			
 
				+        /** Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */
			
 
				+        const SSL_OP_CIPHER_SERVER_PREFERENCE: number;
			
 
				+        /** Instructs OpenSSL to use Cisco's "speshul" version of DTLS_BAD_VER. */
			
 
				+        const SSL_OP_CISCO_ANYCONNECT: number;
			
 
				+        /** Instructs OpenSSL to turn on cookie exchange. */
			
 
				+        const SSL_OP_COOKIE_EXCHANGE: number;
			
 
				+        /** Instructs OpenSSL to add server-hello extension from an early version of the cryptopro draft. */
			
 
				+        const SSL_OP_CRYPTOPRO_TLSEXT_BUG: number;
			
 
				+        /** Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability workaround added in OpenSSL 0.9.6d. */
			
 
				+        const SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number;
			
 
				+        /** Instructs OpenSSL to always use the tmp_rsa key when performing RSA operations. */
			
 
				+        const SSL_OP_EPHEMERAL_RSA: number;
			
 
				+        /** Allows initial connection to servers that do not support RI. */
			
 
				+        const SSL_OP_LEGACY_SERVER_CONNECT: number;
			
 
				+        const SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number;
			
 
				+        const SSL_OP_MICROSOFT_SESS_ID_BUG: number;
			
 
				+        /** Instructs OpenSSL to disable the workaround for a man-in-the-middle protocol-version vulnerability in the SSL 2.0 server implementation. */
			
 
				+        const SSL_OP_MSIE_SSLV2_RSA_PADDING: number;
			
 
				+        const SSL_OP_NETSCAPE_CA_DN_BUG: number;
			
 
				+        const SSL_OP_NETSCAPE_CHALLENGE_BUG: number;
			
 
				+        const SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number;
			
 
				+        const SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number;
			
 
				+        /** Instructs OpenSSL to disable support for SSL/TLS compression. */
			
 
				+        const SSL_OP_NO_COMPRESSION: number;
			
 
				+        const SSL_OP_NO_QUERY_MTU: number;
			
 
				+        /** Instructs OpenSSL to always start a new session when performing renegotiation. */
			
 
				+        const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;
			
 
				+        const SSL_OP_NO_SSLv2: number;
			
 
				+        const SSL_OP_NO_SSLv3: number;
			
 
				+        const SSL_OP_NO_TICKET: number;
			
 
				+        const SSL_OP_NO_TLSv1: number;
			
 
				+        const SSL_OP_NO_TLSv1_1: number;
			
 
				+        const SSL_OP_NO_TLSv1_2: number;
			
 
				+        const SSL_OP_PKCS1_CHECK_1: number;
			
 
				+        const SSL_OP_PKCS1_CHECK_2: number;
			
 
				+        /** Instructs OpenSSL to always create a new key when using temporary/ephemeral DH parameters. */
			
 
				+        const SSL_OP_SINGLE_DH_USE: number;
			
 
				+        /** Instructs OpenSSL to always create a new key when using temporary/ephemeral ECDH parameters. */
			
 
				+        const SSL_OP_SINGLE_ECDH_USE: number;
			
 
				+        const SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number;
			
 
				+        const SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number;
			
 
				+        const SSL_OP_TLS_BLOCK_PADDING_BUG: number;
			
 
				+        const SSL_OP_TLS_D5_BUG: number;
			
 
				+        /** Instructs OpenSSL to disable version rollback attack detection. */
			
 
				+        const SSL_OP_TLS_ROLLBACK_BUG: number;
			
 
				+        const ENGINE_METHOD_RSA: number;
			
 
				+        const ENGINE_METHOD_DSA: number;
			
 
				+        const ENGINE_METHOD_DH: number;
			
 
				+        const ENGINE_METHOD_RAND: number;
			
 
				+        const ENGINE_METHOD_EC: number;
			
 
				+        const ENGINE_METHOD_CIPHERS: number;
			
 
				+        const ENGINE_METHOD_DIGESTS: number;
			
 
				+        const ENGINE_METHOD_PKEY_METHS: number;
			
 
				+        const ENGINE_METHOD_PKEY_ASN1_METHS: number;
			
 
				+        const ENGINE_METHOD_ALL: number;
			
 
				+        const ENGINE_METHOD_NONE: number;
			
 
				+        const DH_CHECK_P_NOT_SAFE_PRIME: number;
			
 
				+        const DH_CHECK_P_NOT_PRIME: number;
			
 
				+        const DH_UNABLE_TO_CHECK_GENERATOR: number;
			
 
				+        const DH_NOT_SUITABLE_GENERATOR: number;
			
 
				+        const ALPN_ENABLED: number;
			
 
				+        const RSA_PKCS1_PADDING: number;
			
 
				+        const RSA_SSLV23_PADDING: number;
			
 
				+        const RSA_NO_PADDING: number;
			
 
				+        const RSA_PKCS1_OAEP_PADDING: number;
			
 
				+        const RSA_X931_PADDING: number;
			
 
				+        const RSA_PKCS1_PSS_PADDING: number;
			
 
				+        /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the digest size when signing or verifying. */
			
 
				+        const RSA_PSS_SALTLEN_DIGEST: number;
			
 
				+        /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the maximum permissible value when signing data. */
			
 
				+        const RSA_PSS_SALTLEN_MAX_SIGN: number;
			
 
				+        /** Causes the salt length for RSA_PKCS1_PSS_PADDING to be determined automatically when verifying a signature. */
			
 
				+        const RSA_PSS_SALTLEN_AUTO: number;
			
 
				+        const POINT_CONVERSION_COMPRESSED: number;
			
 
				+        const POINT_CONVERSION_UNCOMPRESSED: number;
			
 
				+        const POINT_CONVERSION_HYBRID: number;
			
 
				+        /** Specifies the built-in default cipher list used by Node.js (colon-separated values). */
			
 
				+        const defaultCoreCipherList: string;
			
 
				+        /** Specifies the active default cipher list used by the current Node.js process  (colon-separated values). */
			
 
				+        const defaultCipherList: string;
			
 
				+    }
			
 
				+    interface HashOptions extends stream.TransformOptions {
			
 
				+        /**
			
 
				+         * For XOF hash functions such as `shake256`, the
			
 
				+         * outputLength option can be used to specify the desired output length in bytes.
			
 
				+         */
			
 
				+        outputLength?: number | undefined;
			
 
				+    }
			
 
				+    /** @deprecated since v10.0.0 */
			
 
				+    const fips: boolean;
			
 
				+    /**
			
 
				+     * Creates and returns a `Hash` object that can be used to generate hash digests
			
 
				+     * using the given `algorithm`. Optional `options` argument controls stream
			
 
				+     * behavior. For XOF hash functions such as `'shake256'`, the `outputLength` option
			
 
				+     * can be used to specify the desired output length in bytes.
			
 
				+     *
			
 
				+     * The `algorithm` is dependent on the available algorithms supported by the
			
 
				+     * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
			
 
				+     * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
			
 
				+     * display the available digest algorithms.
			
 
				+     *
			
 
				+     * Example: generating the sha256 sum of a file
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import {
			
 
				+     *   createReadStream
			
 
				+     * } from 'fs';
			
 
				+     * import { argv } from 'process';
			
 
				+     * const {
			
 
				+     *   createHash
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const filename = argv[2];
			
 
				+     *
			
 
				+     * const hash = createHash('sha256');
			
 
				+     *
			
 
				+     * const input = createReadStream(filename);
			
 
				+     * input.on('readable', () => {
			
 
				+     *   // Only one element is going to be produced by the
			
 
				+     *   // hash stream.
			
 
				+     *   const data = input.read();
			
 
				+     *   if (data)
			
 
				+     *     hash.update(data);
			
 
				+     *   else {
			
 
				+     *     console.log(`${hash.digest('hex')} ${filename}`);
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v0.1.92
			
 
				+     * @param options `stream.transform` options
			
 
				+     */
			
 
				+    function createHash(algorithm: string, options?: HashOptions): Hash;
			
 
				+    /**
			
 
				+     * Creates and returns an `Hmac` object that uses the given `algorithm` and `key`.
			
 
				+     * Optional `options` argument controls stream behavior.
			
 
				+     *
			
 
				+     * The `algorithm` is dependent on the available algorithms supported by the
			
 
				+     * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
			
 
				+     * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
			
 
				+     * display the available digest algorithms.
			
 
				+     *
			
 
				+     * The `key` is the HMAC key used to generate the cryptographic HMAC hash. If it is
			
 
				+     * a `KeyObject`, its type must be `secret`.
			
 
				+     *
			
 
				+     * Example: generating the sha256 HMAC of a file
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import {
			
 
				+     *   createReadStream
			
 
				+     * } from 'fs';
			
 
				+     * import { argv } from 'process';
			
 
				+     * const {
			
 
				+     *   createHmac
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const filename = argv[2];
			
 
				+     *
			
 
				+     * const hmac = createHmac('sha256', 'a secret');
			
 
				+     *
			
 
				+     * const input = createReadStream(filename);
			
 
				+     * input.on('readable', () => {
			
 
				+     *   // Only one element is going to be produced by the
			
 
				+     *   // hash stream.
			
 
				+     *   const data = input.read();
			
 
				+     *   if (data)
			
 
				+     *     hmac.update(data);
			
 
				+     *   else {
			
 
				+     *     console.log(`${hmac.digest('hex')} ${filename}`);
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v0.1.94
			
 
				+     * @param options `stream.transform` options
			
 
				+     */
			
 
				+    function createHmac(algorithm: string, key: BinaryLike | KeyObject, options?: stream.TransformOptions): Hmac;
			
 
				+    // https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
			
 
				+    type BinaryToTextEncoding = 'base64' | 'base64url' | 'hex' | 'binary';
			
 
				+    type CharacterEncoding = 'utf8' | 'utf-8' | 'utf16le' | 'latin1';
			
 
				+    type LegacyCharacterEncoding = 'ascii' | 'binary' | 'ucs2' | 'ucs-2';
			
 
				+    type Encoding = BinaryToTextEncoding | CharacterEncoding | LegacyCharacterEncoding;
			
 
				+    type ECDHKeyFormat = 'compressed' | 'uncompressed' | 'hybrid';
			
 
				+    /**
			
 
				+     * The `Hash` class is a utility for creating hash digests of data. It can be
			
 
				+     * used in one of two ways:
			
 
				+     *
			
 
				+     * * As a `stream` that is both readable and writable, where data is written
			
 
				+     * to produce a computed hash digest on the readable side, or
			
 
				+     * * Using the `hash.update()` and `hash.digest()` methods to produce the
			
 
				+     * computed hash.
			
 
				+     *
			
 
				+     * The {@link createHash} method is used to create `Hash` instances. `Hash`objects are not to be created directly using the `new` keyword.
			
 
				+     *
			
 
				+     * Example: Using `Hash` objects as streams:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   createHash
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const hash = createHash('sha256');
			
 
				+     *
			
 
				+     * hash.on('readable', () => {
			
 
				+     *   // Only one element is going to be produced by the
			
 
				+     *   // hash stream.
			
 
				+     *   const data = hash.read();
			
 
				+     *   if (data) {
			
 
				+     *     console.log(data.toString('hex'));
			
 
				+     *     // Prints:
			
 
				+     *     //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
			
 
				+     *   }
			
 
				+     * });
			
 
				+     *
			
 
				+     * hash.write('some data to hash');
			
 
				+     * hash.end();
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: Using `Hash` and piped streams:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { createReadStream } from 'fs';
			
 
				+     * import { stdout } from 'process';
			
 
				+     * const { createHash } = await import('crypto');
			
 
				+     *
			
 
				+     * const hash = createHash('sha256');
			
 
				+     *
			
 
				+     * const input = createReadStream('test.js');
			
 
				+     * input.pipe(hash).setEncoding('hex').pipe(stdout);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: Using the `hash.update()` and `hash.digest()` methods:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   createHash
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const hash = createHash('sha256');
			
 
				+     *
			
 
				+     * hash.update('some data to hash');
			
 
				+     * console.log(hash.digest('hex'));
			
 
				+     * // Prints:
			
 
				+     * //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
			
 
				+     * ```
			
 
				+     * @since v0.1.92
			
 
				+     */
			
 
				+    class Hash extends stream.Transform {
			
 
				+        private constructor();
			
 
				+        /**
			
 
				+         * Creates a new `Hash` object that contains a deep copy of the internal state
			
 
				+         * of the current `Hash` object.
			
 
				+         *
			
 
				+         * The optional `options` argument controls stream behavior. For XOF hash
			
 
				+         * functions such as `'shake256'`, the `outputLength` option can be used to
			
 
				+         * specify the desired output length in bytes.
			
 
				+         *
			
 
				+         * An error is thrown when an attempt is made to copy the `Hash` object after
			
 
				+         * its `hash.digest()` method has been called.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * // Calculate a rolling hash.
			
 
				+         * const {
			
 
				+         *   createHash
			
 
				+         * } = await import('crypto');
			
 
				+         *
			
 
				+         * const hash = createHash('sha256');
			
 
				+         *
			
 
				+         * hash.update('one');
			
 
				+         * console.log(hash.copy().digest('hex'));
			
 
				+         *
			
 
				+         * hash.update('two');
			
 
				+         * console.log(hash.copy().digest('hex'));
			
 
				+         *
			
 
				+         * hash.update('three');
			
 
				+         * console.log(hash.copy().digest('hex'));
			
 
				+         *
			
 
				+         * // Etc.
			
 
				+         * ```
			
 
				+         * @since v13.1.0
			
 
				+         * @param options `stream.transform` options
			
 
				+         */
			
 
				+        copy(options?: stream.TransformOptions): Hash;
			
 
				+        /**
			
 
				+         * Updates the hash content with the given `data`, the encoding of which
			
 
				+         * is given in `inputEncoding`.
			
 
				+         * If `encoding` is not provided, and the `data` is a string, an
			
 
				+         * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
			
 
				+         *
			
 
				+         * This can be called many times with new data as it is streamed.
			
 
				+         * @since v0.1.92
			
 
				+         * @param inputEncoding The `encoding` of the `data` string.
			
 
				+         */
			
 
				+        update(data: BinaryLike): Hash;
			
 
				+        update(data: string, inputEncoding: Encoding): Hash;
			
 
				+        /**
			
 
				+         * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).
			
 
				+         * If `encoding` is provided a string will be returned; otherwise
			
 
				+         * a `Buffer` is returned.
			
 
				+         *
			
 
				+         * The `Hash` object can not be used again after `hash.digest()` method has been
			
 
				+         * called. Multiple calls will cause an error to be thrown.
			
 
				+         * @since v0.1.92
			
 
				+         * @param encoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        digest(): Buffer;
			
 
				+        digest(encoding: BinaryToTextEncoding): string;
			
 
				+    }
			
 
				+    /**
			
 
				+     * The `Hmac` class is a utility for creating cryptographic HMAC digests. It can
			
 
				+     * be used in one of two ways:
			
 
				+     *
			
 
				+     * * As a `stream` that is both readable and writable, where data is written
			
 
				+     * to produce a computed HMAC digest on the readable side, or
			
 
				+     * * Using the `hmac.update()` and `hmac.digest()` methods to produce the
			
 
				+     * computed HMAC digest.
			
 
				+     *
			
 
				+     * The {@link createHmac} method is used to create `Hmac` instances. `Hmac`objects are not to be created directly using the `new` keyword.
			
 
				+     *
			
 
				+     * Example: Using `Hmac` objects as streams:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   createHmac
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const hmac = createHmac('sha256', 'a secret');
			
 
				+     *
			
 
				+     * hmac.on('readable', () => {
			
 
				+     *   // Only one element is going to be produced by the
			
 
				+     *   // hash stream.
			
 
				+     *   const data = hmac.read();
			
 
				+     *   if (data) {
			
 
				+     *     console.log(data.toString('hex'));
			
 
				+     *     // Prints:
			
 
				+     *     //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
			
 
				+     *   }
			
 
				+     * });
			
 
				+     *
			
 
				+     * hmac.write('some data to hash');
			
 
				+     * hmac.end();
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: Using `Hmac` and piped streams:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { createReadStream } from 'fs';
			
 
				+     * import { stdout } from 'process';
			
 
				+     * const {
			
 
				+     *   createHmac
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const hmac = createHmac('sha256', 'a secret');
			
 
				+     *
			
 
				+     * const input = createReadStream('test.js');
			
 
				+     * input.pipe(hmac).pipe(stdout);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: Using the `hmac.update()` and `hmac.digest()` methods:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   createHmac
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const hmac = createHmac('sha256', 'a secret');
			
 
				+     *
			
 
				+     * hmac.update('some data to hash');
			
 
				+     * console.log(hmac.digest('hex'));
			
 
				+     * // Prints:
			
 
				+     * //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
			
 
				+     * ```
			
 
				+     * @since v0.1.94
			
 
				+     */
			
 
				+    class Hmac extends stream.Transform {
			
 
				+        private constructor();
			
 
				+        /**
			
 
				+         * Updates the `Hmac` content with the given `data`, the encoding of which
			
 
				+         * is given in `inputEncoding`.
			
 
				+         * If `encoding` is not provided, and the `data` is a string, an
			
 
				+         * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
			
 
				+         *
			
 
				+         * This can be called many times with new data as it is streamed.
			
 
				+         * @since v0.1.94
			
 
				+         * @param inputEncoding The `encoding` of the `data` string.
			
 
				+         */
			
 
				+        update(data: BinaryLike): Hmac;
			
 
				+        update(data: string, inputEncoding: Encoding): Hmac;
			
 
				+        /**
			
 
				+         * Calculates the HMAC digest of all of the data passed using `hmac.update()`.
			
 
				+         * If `encoding` is
			
 
				+         * provided a string is returned; otherwise a `Buffer` is returned;
			
 
				+         *
			
 
				+         * The `Hmac` object can not be used again after `hmac.digest()` has been
			
 
				+         * called. Multiple calls to `hmac.digest()` will result in an error being thrown.
			
 
				+         * @since v0.1.94
			
 
				+         * @param encoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        digest(): Buffer;
			
 
				+        digest(encoding: BinaryToTextEncoding): string;
			
 
				+    }
			
 
				+    type KeyObjectType = 'secret' | 'public' | 'private';
			
 
				+    interface KeyExportOptions<T extends KeyFormat> {
			
 
				+        type: 'pkcs1' | 'spki' | 'pkcs8' | 'sec1';
			
 
				+        format: T;
			
 
				+        cipher?: string | undefined;
			
 
				+        passphrase?: string | Buffer | undefined;
			
 
				+    }
			
 
				+    interface JwkKeyExportOptions {
			
 
				+        format: 'jwk';
			
 
				+    }
			
 
				+    interface JsonWebKey {
			
 
				+        crv?: string | undefined;
			
 
				+        d?: string | undefined;
			
 
				+        dp?: string | undefined;
			
 
				+        dq?: string | undefined;
			
 
				+        e?: string | undefined;
			
 
				+        k?: string | undefined;
			
 
				+        kty?: string | undefined;
			
 
				+        n?: string | undefined;
			
 
				+        p?: string | undefined;
			
 
				+        q?: string | undefined;
			
 
				+        qi?: string | undefined;
			
 
				+        x?: string | undefined;
			
 
				+        y?: string | undefined;
			
 
				+        [key: string]: unknown;
			
 
				+    }
			
 
				+    interface AsymmetricKeyDetails {
			
 
				+        /**
			
 
				+         * Key size in bits (RSA, DSA).
			
 
				+         */
			
 
				+        modulusLength?: number | undefined;
			
 
				+        /**
			
 
				+         * Public exponent (RSA).
			
 
				+         */
			
 
				+        publicExponent?: bigint | undefined;
			
 
				+        /**
			
 
				+         * Name of the message digest (RSA-PSS).
			
 
				+         */
			
 
				+        hashAlgorithm?: string | undefined;
			
 
				+        /**
			
 
				+         * Name of the message digest used by MGF1 (RSA-PSS).
			
 
				+         */
			
 
				+        mgf1HashAlgorithm?: string | undefined;
			
 
				+        /**
			
 
				+         * Minimal salt length in bytes (RSA-PSS).
			
 
				+         */
			
 
				+        saltLength?: number | undefined;
			
 
				+        /**
			
 
				+         * Size of q in bits (DSA).
			
 
				+         */
			
 
				+        divisorLength?: number | undefined;
			
 
				+        /**
			
 
				+         * Name of the curve (EC).
			
 
				+         */
			
 
				+        namedCurve?: string | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Node.js uses a `KeyObject` class to represent a symmetric or asymmetric key,
			
 
				+     * and each kind of key exposes different functions. The {@link createSecretKey}, {@link createPublicKey} and {@link createPrivateKey} methods are used to create `KeyObject`instances. `KeyObject`
			
 
				+     * objects are not to be created directly using the `new`keyword.
			
 
				+     *
			
 
				+     * Most applications should consider using the new `KeyObject` API instead of
			
 
				+     * passing keys as strings or `Buffer`s due to improved security features.
			
 
				+     *
			
 
				+     * `KeyObject` instances can be passed to other threads via `postMessage()`.
			
 
				+     * The receiver obtains a cloned `KeyObject`, and the `KeyObject` does not need to
			
 
				+     * be listed in the `transferList` argument.
			
 
				+     * @since v11.6.0
			
 
				+     */
			
 
				+    class KeyObject {
			
 
				+        private constructor();
			
 
				+        /**
			
 
				+         * Example: Converting a `CryptoKey` instance to a `KeyObject`:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { webcrypto, KeyObject } = await import('crypto');
			
 
				+         * const { subtle } = webcrypto;
			
 
				+         *
			
 
				+         * const key = await subtle.generateKey({
			
 
				+         *   name: 'HMAC',
			
 
				+         *   hash: 'SHA-256',
			
 
				+         *   length: 256
			
 
				+         * }, true, ['sign', 'verify']);
			
 
				+         *
			
 
				+         * const keyObject = KeyObject.from(key);
			
 
				+         * console.log(keyObject.symmetricKeySize);
			
 
				+         * // Prints: 32 (symmetric key size in bytes)
			
 
				+         * ```
			
 
				+         * @since v15.0.0
			
 
				+         */
			
 
				+        static from(key: webcrypto.CryptoKey): KeyObject;
			
 
				+        /**
			
 
				+         * For asymmetric keys, this property represents the type of the key. Supported key
			
 
				+         * types are:
			
 
				+         *
			
 
				+         * * `'rsa'` (OID 1.2.840.113549.1.1.1)
			
 
				+         * * `'rsa-pss'` (OID 1.2.840.113549.1.1.10)
			
 
				+         * * `'dsa'` (OID 1.2.840.10040.4.1)
			
 
				+         * * `'ec'` (OID 1.2.840.10045.2.1)
			
 
				+         * * `'x25519'` (OID 1.3.101.110)
			
 
				+         * * `'x448'` (OID 1.3.101.111)
			
 
				+         * * `'ed25519'` (OID 1.3.101.112)
			
 
				+         * * `'ed448'` (OID 1.3.101.113)
			
 
				+         * * `'dh'` (OID 1.2.840.113549.1.3.1)
			
 
				+         *
			
 
				+         * This property is `undefined` for unrecognized `KeyObject` types and symmetric
			
 
				+         * keys.
			
 
				+         * @since v11.6.0
			
 
				+         */
			
 
				+        asymmetricKeyType?: KeyType | undefined;
			
 
				+        /**
			
 
				+         * For asymmetric keys, this property represents the size of the embedded key in
			
 
				+         * bytes. This property is `undefined` for symmetric keys.
			
 
				+         */
			
 
				+        asymmetricKeySize?: number | undefined;
			
 
				+        /**
			
 
				+         * This property exists only on asymmetric keys. Depending on the type of the key,
			
 
				+         * this object contains information about the key. None of the information obtained
			
 
				+         * through this property can be used to uniquely identify a key or to compromise
			
 
				+         * the security of the key.
			
 
				+         *
			
 
				+         * For RSA-PSS keys, if the key material contains a `RSASSA-PSS-params` sequence,
			
 
				+         * the `hashAlgorithm`, `mgf1HashAlgorithm`, and `saltLength` properties will be
			
 
				+         * set.
			
 
				+         *
			
 
				+         * Other key details might be exposed via this API using additional attributes.
			
 
				+         * @since v15.7.0
			
 
				+         */
			
 
				+        asymmetricKeyDetails?: AsymmetricKeyDetails | undefined;
			
 
				+        /**
			
 
				+         * For symmetric keys, the following encoding options can be used:
			
 
				+         *
			
 
				+         * For public keys, the following encoding options can be used:
			
 
				+         *
			
 
				+         * For private keys, the following encoding options can be used:
			
 
				+         *
			
 
				+         * The result type depends on the selected encoding format, when PEM the
			
 
				+         * result is a string, when DER it will be a buffer containing the data
			
 
				+         * encoded as DER, when [JWK](https://tools.ietf.org/html/rfc7517) it will be an object.
			
 
				+         *
			
 
				+         * When [JWK](https://tools.ietf.org/html/rfc7517) encoding format was selected, all other encoding options are
			
 
				+         * ignored.
			
 
				+         *
			
 
				+         * PKCS#1, SEC1, and PKCS#8 type keys can be encrypted by using a combination of
			
 
				+         * the `cipher` and `format` options. The PKCS#8 `type` can be used with any`format` to encrypt any key algorithm (RSA, EC, or DH) by specifying a`cipher`. PKCS#1 and SEC1 can only be
			
 
				+         * encrypted by specifying a `cipher`when the PEM `format` is used. For maximum compatibility, use PKCS#8 for
			
 
				+         * encrypted private keys. Since PKCS#8 defines its own
			
 
				+         * encryption mechanism, PEM-level encryption is not supported when encrypting
			
 
				+         * a PKCS#8 key. See [RFC 5208](https://www.rfc-editor.org/rfc/rfc5208.txt) for PKCS#8 encryption and [RFC 1421](https://www.rfc-editor.org/rfc/rfc1421.txt) for
			
 
				+         * PKCS#1 and SEC1 encryption.
			
 
				+         * @since v11.6.0
			
 
				+         */
			
 
				+        export(options: KeyExportOptions<'pem'>): string | Buffer;
			
 
				+        export(options?: KeyExportOptions<'der'>): Buffer;
			
 
				+        export(options?: JwkKeyExportOptions): JsonWebKey;
			
 
				+        /**
			
 
				+         * For secret keys, this property represents the size of the key in bytes. This
			
 
				+         * property is `undefined` for asymmetric keys.
			
 
				+         * @since v11.6.0
			
 
				+         */
			
 
				+        symmetricKeySize?: number | undefined;
			
 
				+        /**
			
 
				+         * Depending on the type of this `KeyObject`, this property is either`'secret'` for secret (symmetric) keys, `'public'` for public (asymmetric) keys
			
 
				+         * or `'private'` for private (asymmetric) keys.
			
 
				+         * @since v11.6.0
			
 
				+         */
			
 
				+        type: KeyObjectType;
			
 
				+    }
			
 
				+    type CipherCCMTypes = 'aes-128-ccm' | 'aes-192-ccm' | 'aes-256-ccm' | 'chacha20-poly1305';
			
 
				+    type CipherGCMTypes = 'aes-128-gcm' | 'aes-192-gcm' | 'aes-256-gcm';
			
 
				+    type CipherOCBTypes = 'aes-128-ocb' | 'aes-192-ocb' | 'aes-256-ocb';
			
 
				+    type BinaryLike = string | NodeJS.ArrayBufferView;
			
 
				+    type CipherKey = BinaryLike | KeyObject;
			
 
				+    interface CipherCCMOptions extends stream.TransformOptions {
			
 
				+        authTagLength: number;
			
 
				+    }
			
 
				+    interface CipherGCMOptions extends stream.TransformOptions {
			
 
				+        authTagLength?: number | undefined;
			
 
				+    }
			
 
				+    interface CipherOCBOptions extends stream.TransformOptions {
			
 
				+        authTagLength: number;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Creates and returns a `Cipher` object that uses the given `algorithm` and`password`.
			
 
				+     *
			
 
				+     * The `options` argument controls stream behavior and is optional except when a
			
 
				+     * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the
			
 
				+     * authentication tag in bytes, see `CCM mode`. In GCM mode, the `authTagLength`option is not required but can be used to set the length of the authentication
			
 
				+     * tag that will be returned by `getAuthTag()` and defaults to 16 bytes.
			
 
				+     * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes.
			
 
				+     *
			
 
				+     * The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On
			
 
				+     * recent OpenSSL releases, `openssl list -cipher-algorithms` will
			
 
				+     * display the available cipher algorithms.
			
 
				+     *
			
 
				+     * The `password` is used to derive the cipher key and initialization vector (IV).
			
 
				+     * The value must be either a `'latin1'` encoded string, a `Buffer`, a`TypedArray`, or a `DataView`.
			
 
				+     *
			
 
				+     * The implementation of `crypto.createCipher()` derives keys using the OpenSSL
			
 
				+     * function [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) with the digest algorithm set to MD5, one
			
 
				+     * iteration, and no salt. The lack of salt allows dictionary attacks as the same
			
 
				+     * password always creates the same key. The low iteration count and
			
 
				+     * non-cryptographically secure hash algorithm allow passwords to be tested very
			
 
				+     * rapidly.
			
 
				+     *
			
 
				+     * In line with OpenSSL's recommendation to use a more modern algorithm instead of [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) it is recommended that
			
 
				+     * developers derive a key and IV on
			
 
				+     * their own using {@link scrypt} and to use {@link createCipheriv} to create the `Cipher` object. Users should not use ciphers with counter mode
			
 
				+     * (e.g. CTR, GCM, or CCM) in `crypto.createCipher()`. A warning is emitted when
			
 
				+     * they are used in order to avoid the risk of IV reuse that causes
			
 
				+     * vulnerabilities. For the case when IV is reused in GCM, see [Nonce-Disrespecting Adversaries](https://github.com/nonce-disrespect/nonce-disrespect) for details.
			
 
				+     * @since v0.1.94
			
 
				+     * @deprecated Since v10.0.0 - Use {@link createCipheriv} instead.
			
 
				+     * @param options `stream.transform` options
			
 
				+     */
			
 
				+    function createCipher(algorithm: CipherCCMTypes, password: BinaryLike, options: CipherCCMOptions): CipherCCM;
			
 
				+    /** @deprecated since v10.0.0 use `createCipheriv()` */
			
 
				+    function createCipher(algorithm: CipherGCMTypes, password: BinaryLike, options?: CipherGCMOptions): CipherGCM;
			
 
				+    /** @deprecated since v10.0.0 use `createCipheriv()` */
			
 
				+    function createCipher(algorithm: string, password: BinaryLike, options?: stream.TransformOptions): Cipher;
			
 
				+    /**
			
 
				+     * Creates and returns a `Cipher` object, with the given `algorithm`, `key` and
			
 
				+     * initialization vector (`iv`).
			
 
				+     *
			
 
				+     * The `options` argument controls stream behavior and is optional except when a
			
 
				+     * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the
			
 
				+     * authentication tag in bytes, see `CCM mode`. In GCM mode, the `authTagLength`option is not required but can be used to set the length of the authentication
			
 
				+     * tag that will be returned by `getAuthTag()` and defaults to 16 bytes.
			
 
				+     * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes.
			
 
				+     *
			
 
				+     * The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On
			
 
				+     * recent OpenSSL releases, `openssl list -cipher-algorithms` will
			
 
				+     * display the available cipher algorithms.
			
 
				+     *
			
 
				+     * The `key` is the raw key used by the `algorithm` and `iv` is an [initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded
			
 
				+     * strings,`Buffers`, `TypedArray`, or `DataView`s. The `key` may optionally be
			
 
				+     * a `KeyObject` of type `secret`. If the cipher does not need
			
 
				+     * an initialization vector, `iv` may be `null`.
			
 
				+     *
			
 
				+     * When passing strings for `key` or `iv`, please consider `caveats when using strings as inputs to cryptographic APIs`.
			
 
				+     *
			
 
				+     * Initialization vectors should be unpredictable and unique; ideally, they will be
			
 
				+     * cryptographically random. They do not have to be secret: IVs are typically just
			
 
				+     * added to ciphertext messages unencrypted. It may sound contradictory that
			
 
				+     * something has to be unpredictable and unique, but does not have to be secret;
			
 
				+     * remember that an attacker must not be able to predict ahead of time what a
			
 
				+     * given IV will be.
			
 
				+     * @since v0.1.94
			
 
				+     * @param options `stream.transform` options
			
 
				+     */
			
 
				+    function createCipheriv(algorithm: CipherCCMTypes, key: CipherKey, iv: BinaryLike, options: CipherCCMOptions): CipherCCM;
			
 
				+    function createCipheriv(algorithm: CipherOCBTypes, key: CipherKey, iv: BinaryLike, options: CipherOCBOptions): CipherOCB;
			
 
				+    function createCipheriv(algorithm: CipherGCMTypes, key: CipherKey, iv: BinaryLike, options?: CipherGCMOptions): CipherGCM;
			
 
				+    function createCipheriv(algorithm: string, key: CipherKey, iv: BinaryLike | null, options?: stream.TransformOptions): Cipher;
			
 
				+    /**
			
 
				+     * Instances of the `Cipher` class are used to encrypt data. The class can be
			
 
				+     * used in one of two ways:
			
 
				+     *
			
 
				+     * * As a `stream` that is both readable and writable, where plain unencrypted
			
 
				+     * data is written to produce encrypted data on the readable side, or
			
 
				+     * * Using the `cipher.update()` and `cipher.final()` methods to produce
			
 
				+     * the encrypted data.
			
 
				+     *
			
 
				+     * The {@link createCipher} or {@link createCipheriv} methods are
			
 
				+     * used to create `Cipher` instances. `Cipher` objects are not to be created
			
 
				+     * directly using the `new` keyword.
			
 
				+     *
			
 
				+     * Example: Using `Cipher` objects as streams:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   scrypt,
			
 
				+     *   randomFill,
			
 
				+     *   createCipheriv
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const algorithm = 'aes-192-cbc';
			
 
				+     * const password = 'Password used to generate key';
			
 
				+     *
			
 
				+     * // First, we'll generate the key. The key length is dependent on the algorithm.
			
 
				+     * // In this case for aes192, it is 24 bytes (192 bits).
			
 
				+     * scrypt(password, 'salt', 24, (err, key) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   // Then, we'll generate a random initialization vector
			
 
				+     *   randomFill(new Uint8Array(16), (err, iv) => {
			
 
				+     *     if (err) throw err;
			
 
				+     *
			
 
				+     *     // Once we have the key and iv, we can create and use the cipher...
			
 
				+     *     const cipher = createCipheriv(algorithm, key, iv);
			
 
				+     *
			
 
				+     *     let encrypted = '';
			
 
				+     *     cipher.setEncoding('hex');
			
 
				+     *
			
 
				+     *     cipher.on('data', (chunk) => encrypted += chunk);
			
 
				+     *     cipher.on('end', () => console.log(encrypted));
			
 
				+     *
			
 
				+     *     cipher.write('some clear text data');
			
 
				+     *     cipher.end();
			
 
				+     *   });
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: Using `Cipher` and piped streams:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import {
			
 
				+     *   createReadStream,
			
 
				+     *   createWriteStream,
			
 
				+     * } from 'fs';
			
 
				+     *
			
 
				+     * import {
			
 
				+     *   pipeline
			
 
				+     * } from 'stream';
			
 
				+     *
			
 
				+     * const {
			
 
				+     *   scrypt,
			
 
				+     *   randomFill,
			
 
				+     *   createCipheriv
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const algorithm = 'aes-192-cbc';
			
 
				+     * const password = 'Password used to generate key';
			
 
				+     *
			
 
				+     * // First, we'll generate the key. The key length is dependent on the algorithm.
			
 
				+     * // In this case for aes192, it is 24 bytes (192 bits).
			
 
				+     * scrypt(password, 'salt', 24, (err, key) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   // Then, we'll generate a random initialization vector
			
 
				+     *   randomFill(new Uint8Array(16), (err, iv) => {
			
 
				+     *     if (err) throw err;
			
 
				+     *
			
 
				+     *     const cipher = createCipheriv(algorithm, key, iv);
			
 
				+     *
			
 
				+     *     const input = createReadStream('test.js');
			
 
				+     *     const output = createWriteStream('test.enc');
			
 
				+     *
			
 
				+     *     pipeline(input, cipher, output, (err) => {
			
 
				+     *       if (err) throw err;
			
 
				+     *     });
			
 
				+     *   });
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: Using the `cipher.update()` and `cipher.final()` methods:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   scrypt,
			
 
				+     *   randomFill,
			
 
				+     *   createCipheriv
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const algorithm = 'aes-192-cbc';
			
 
				+     * const password = 'Password used to generate key';
			
 
				+     *
			
 
				+     * // First, we'll generate the key. The key length is dependent on the algorithm.
			
 
				+     * // In this case for aes192, it is 24 bytes (192 bits).
			
 
				+     * scrypt(password, 'salt', 24, (err, key) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   // Then, we'll generate a random initialization vector
			
 
				+     *   randomFill(new Uint8Array(16), (err, iv) => {
			
 
				+     *     if (err) throw err;
			
 
				+     *
			
 
				+     *     const cipher = createCipheriv(algorithm, key, iv);
			
 
				+     *
			
 
				+     *     let encrypted = cipher.update('some clear text data', 'utf8', 'hex');
			
 
				+     *     encrypted += cipher.final('hex');
			
 
				+     *     console.log(encrypted);
			
 
				+     *   });
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v0.1.94
			
 
				+     */
			
 
				+    class Cipher extends stream.Transform {
			
 
				+        private constructor();
			
 
				+        /**
			
 
				+         * Updates the cipher with `data`. If the `inputEncoding` argument is given,
			
 
				+         * the `data`argument is a string using the specified encoding. If the `inputEncoding`argument is not given, `data` must be a `Buffer`, `TypedArray`, or`DataView`. If `data` is a `Buffer`,
			
 
				+         * `TypedArray`, or `DataView`, then`inputEncoding` is ignored.
			
 
				+         *
			
 
				+         * The `outputEncoding` specifies the output format of the enciphered
			
 
				+         * data. If the `outputEncoding`is specified, a string using the specified encoding is returned. If no`outputEncoding` is provided, a `Buffer` is returned.
			
 
				+         *
			
 
				+         * The `cipher.update()` method can be called multiple times with new data until `cipher.final()` is called. Calling `cipher.update()` after `cipher.final()` will result in an error being
			
 
				+         * thrown.
			
 
				+         * @since v0.1.94
			
 
				+         * @param inputEncoding The `encoding` of the data.
			
 
				+         * @param outputEncoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        update(data: BinaryLike): Buffer;
			
 
				+        update(data: string, inputEncoding: Encoding): Buffer;
			
 
				+        update(data: NodeJS.ArrayBufferView, inputEncoding: undefined, outputEncoding: Encoding): string;
			
 
				+        update(data: string, inputEncoding: Encoding | undefined, outputEncoding: Encoding): string;
			
 
				+        /**
			
 
				+         * Once the `cipher.final()` method has been called, the `Cipher` object can no
			
 
				+         * longer be used to encrypt data. Attempts to call `cipher.final()` more than
			
 
				+         * once will result in an error being thrown.
			
 
				+         * @since v0.1.94
			
 
				+         * @param outputEncoding The `encoding` of the return value.
			
 
				+         * @return Any remaining enciphered contents. If `outputEncoding` is specified, a string is returned. If an `outputEncoding` is not provided, a {@link Buffer} is returned.
			
 
				+         */
			
 
				+        final(): Buffer;
			
 
				+        final(outputEncoding: BufferEncoding): string;
			
 
				+        /**
			
 
				+         * When using block encryption algorithms, the `Cipher` class will automatically
			
 
				+         * add padding to the input data to the appropriate block size. To disable the
			
 
				+         * default padding call `cipher.setAutoPadding(false)`.
			
 
				+         *
			
 
				+         * When `autoPadding` is `false`, the length of the entire input data must be a
			
 
				+         * multiple of the cipher's block size or `cipher.final()` will throw an error.
			
 
				+         * Disabling automatic padding is useful for non-standard padding, for instance
			
 
				+         * using `0x0` instead of PKCS padding.
			
 
				+         *
			
 
				+         * The `cipher.setAutoPadding()` method must be called before `cipher.final()`.
			
 
				+         * @since v0.7.1
			
 
				+         * @param [autoPadding=true]
			
 
				+         * @return for method chaining.
			
 
				+         */
			
 
				+        setAutoPadding(autoPadding?: boolean): this;
			
 
				+    }
			
 
				+    interface CipherCCM extends Cipher {
			
 
				+        setAAD(
			
 
				+            buffer: NodeJS.ArrayBufferView,
			
 
				+            options: {
			
 
				+                plaintextLength: number;
			
 
				+            }
			
 
				+        ): this;
			
 
				+        getAuthTag(): Buffer;
			
 
				+    }
			
 
				+    interface CipherGCM extends Cipher {
			
 
				+        setAAD(
			
 
				+            buffer: NodeJS.ArrayBufferView,
			
 
				+            options?: {
			
 
				+                plaintextLength: number;
			
 
				+            }
			
 
				+        ): this;
			
 
				+        getAuthTag(): Buffer;
			
 
				+    }
			
 
				+    interface CipherOCB extends Cipher {
			
 
				+        setAAD(
			
 
				+            buffer: NodeJS.ArrayBufferView,
			
 
				+            options?: {
			
 
				+                plaintextLength: number;
			
 
				+            }
			
 
				+        ): this;
			
 
				+        getAuthTag(): Buffer;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Creates and returns a `Decipher` object that uses the given `algorithm` and`password` (key).
			
 
				+     *
			
 
				+     * The `options` argument controls stream behavior and is optional except when a
			
 
				+     * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the
			
 
				+     * authentication tag in bytes, see `CCM mode`.
			
 
				+     * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes.
			
 
				+     *
			
 
				+     * The implementation of `crypto.createDecipher()` derives keys using the OpenSSL
			
 
				+     * function [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) with the digest algorithm set to MD5, one
			
 
				+     * iteration, and no salt. The lack of salt allows dictionary attacks as the same
			
 
				+     * password always creates the same key. The low iteration count and
			
 
				+     * non-cryptographically secure hash algorithm allow passwords to be tested very
			
 
				+     * rapidly.
			
 
				+     *
			
 
				+     * In line with OpenSSL's recommendation to use a more modern algorithm instead of [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) it is recommended that
			
 
				+     * developers derive a key and IV on
			
 
				+     * their own using {@link scrypt} and to use {@link createDecipheriv} to create the `Decipher` object.
			
 
				+     * @since v0.1.94
			
 
				+     * @deprecated Since v10.0.0 - Use {@link createDecipheriv} instead.
			
 
				+     * @param options `stream.transform` options
			
 
				+     */
			
 
				+    function createDecipher(algorithm: CipherCCMTypes, password: BinaryLike, options: CipherCCMOptions): DecipherCCM;
			
 
				+    /** @deprecated since v10.0.0 use `createDecipheriv()` */
			
 
				+    function createDecipher(algorithm: CipherGCMTypes, password: BinaryLike, options?: CipherGCMOptions): DecipherGCM;
			
 
				+    /** @deprecated since v10.0.0 use `createDecipheriv()` */
			
 
				+    function createDecipher(algorithm: string, password: BinaryLike, options?: stream.TransformOptions): Decipher;
			
 
				+    /**
			
 
				+     * Creates and returns a `Decipher` object that uses the given `algorithm`, `key`and initialization vector (`iv`).
			
 
				+     *
			
 
				+     * The `options` argument controls stream behavior and is optional except when a
			
 
				+     * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the
			
 
				+     * authentication tag in bytes, see `CCM mode`. In GCM mode, the `authTagLength`option is not required but can be used to restrict accepted authentication tags
			
 
				+     * to those with the specified length.
			
 
				+     * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes.
			
 
				+     *
			
 
				+     * The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On
			
 
				+     * recent OpenSSL releases, `openssl list -cipher-algorithms` will
			
 
				+     * display the available cipher algorithms.
			
 
				+     *
			
 
				+     * The `key` is the raw key used by the `algorithm` and `iv` is an [initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded
			
 
				+     * strings,`Buffers`, `TypedArray`, or `DataView`s. The `key` may optionally be
			
 
				+     * a `KeyObject` of type `secret`. If the cipher does not need
			
 
				+     * an initialization vector, `iv` may be `null`.
			
 
				+     *
			
 
				+     * When passing strings for `key` or `iv`, please consider `caveats when using strings as inputs to cryptographic APIs`.
			
 
				+     *
			
 
				+     * Initialization vectors should be unpredictable and unique; ideally, they will be
			
 
				+     * cryptographically random. They do not have to be secret: IVs are typically just
			
 
				+     * added to ciphertext messages unencrypted. It may sound contradictory that
			
 
				+     * something has to be unpredictable and unique, but does not have to be secret;
			
 
				+     * remember that an attacker must not be able to predict ahead of time what a given
			
 
				+     * IV will be.
			
 
				+     * @since v0.1.94
			
 
				+     * @param options `stream.transform` options
			
 
				+     */
			
 
				+    function createDecipheriv(algorithm: CipherCCMTypes, key: CipherKey, iv: BinaryLike, options: CipherCCMOptions): DecipherCCM;
			
 
				+    function createDecipheriv(algorithm: CipherOCBTypes, key: CipherKey, iv: BinaryLike, options: CipherOCBOptions): DecipherOCB;
			
 
				+    function createDecipheriv(algorithm: CipherGCMTypes, key: CipherKey, iv: BinaryLike, options?: CipherGCMOptions): DecipherGCM;
			
 
				+    function createDecipheriv(algorithm: string, key: CipherKey, iv: BinaryLike | null, options?: stream.TransformOptions): Decipher;
			
 
				+    /**
			
 
				+     * Instances of the `Decipher` class are used to decrypt data. The class can be
			
 
				+     * used in one of two ways:
			
 
				+     *
			
 
				+     * * As a `stream` that is both readable and writable, where plain encrypted
			
 
				+     * data is written to produce unencrypted data on the readable side, or
			
 
				+     * * Using the `decipher.update()` and `decipher.final()` methods to
			
 
				+     * produce the unencrypted data.
			
 
				+     *
			
 
				+     * The {@link createDecipher} or {@link createDecipheriv} methods are
			
 
				+     * used to create `Decipher` instances. `Decipher` objects are not to be created
			
 
				+     * directly using the `new` keyword.
			
 
				+     *
			
 
				+     * Example: Using `Decipher` objects as streams:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     * const {
			
 
				+     *   scryptSync,
			
 
				+     *   createDecipheriv
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const algorithm = 'aes-192-cbc';
			
 
				+     * const password = 'Password used to generate key';
			
 
				+     * // Key length is dependent on the algorithm. In this case for aes192, it is
			
 
				+     * // 24 bytes (192 bits).
			
 
				+     * // Use the async `crypto.scrypt()` instead.
			
 
				+     * const key = scryptSync(password, 'salt', 24);
			
 
				+     * // The IV is usually passed along with the ciphertext.
			
 
				+     * const iv = Buffer.alloc(16, 0); // Initialization vector.
			
 
				+     *
			
 
				+     * const decipher = createDecipheriv(algorithm, key, iv);
			
 
				+     *
			
 
				+     * let decrypted = '';
			
 
				+     * decipher.on('readable', () => {
			
 
				+     *   while (null !== (chunk = decipher.read())) {
			
 
				+     *     decrypted += chunk.toString('utf8');
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * decipher.on('end', () => {
			
 
				+     *   console.log(decrypted);
			
 
				+     *   // Prints: some clear text data
			
 
				+     * });
			
 
				+     *
			
 
				+     * // Encrypted with same algorithm, key and iv.
			
 
				+     * const encrypted =
			
 
				+     *   'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
			
 
				+     * decipher.write(encrypted, 'hex');
			
 
				+     * decipher.end();
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: Using `Decipher` and piped streams:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import {
			
 
				+     *   createReadStream,
			
 
				+     *   createWriteStream,
			
 
				+     * } from 'fs';
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     * const {
			
 
				+     *   scryptSync,
			
 
				+     *   createDecipheriv
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const algorithm = 'aes-192-cbc';
			
 
				+     * const password = 'Password used to generate key';
			
 
				+     * // Use the async `crypto.scrypt()` instead.
			
 
				+     * const key = scryptSync(password, 'salt', 24);
			
 
				+     * // The IV is usually passed along with the ciphertext.
			
 
				+     * const iv = Buffer.alloc(16, 0); // Initialization vector.
			
 
				+     *
			
 
				+     * const decipher = createDecipheriv(algorithm, key, iv);
			
 
				+     *
			
 
				+     * const input = createReadStream('test.enc');
			
 
				+     * const output = createWriteStream('test.js');
			
 
				+     *
			
 
				+     * input.pipe(decipher).pipe(output);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: Using the `decipher.update()` and `decipher.final()` methods:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     * const {
			
 
				+     *   scryptSync,
			
 
				+     *   createDecipheriv
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const algorithm = 'aes-192-cbc';
			
 
				+     * const password = 'Password used to generate key';
			
 
				+     * // Use the async `crypto.scrypt()` instead.
			
 
				+     * const key = scryptSync(password, 'salt', 24);
			
 
				+     * // The IV is usually passed along with the ciphertext.
			
 
				+     * const iv = Buffer.alloc(16, 0); // Initialization vector.
			
 
				+     *
			
 
				+     * const decipher = createDecipheriv(algorithm, key, iv);
			
 
				+     *
			
 
				+     * // Encrypted using same algorithm, key and iv.
			
 
				+     * const encrypted =
			
 
				+     *   'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
			
 
				+     * let decrypted = decipher.update(encrypted, 'hex', 'utf8');
			
 
				+     * decrypted += decipher.final('utf8');
			
 
				+     * console.log(decrypted);
			
 
				+     * // Prints: some clear text data
			
 
				+     * ```
			
 
				+     * @since v0.1.94
			
 
				+     */
			
 
				+    class Decipher extends stream.Transform {
			
 
				+        private constructor();
			
 
				+        /**
			
 
				+         * Updates the decipher with `data`. If the `inputEncoding` argument is given,
			
 
				+         * the `data`argument is a string using the specified encoding. If the `inputEncoding`argument is not given, `data` must be a `Buffer`. If `data` is a `Buffer` then `inputEncoding` is
			
 
				+         * ignored.
			
 
				+         *
			
 
				+         * The `outputEncoding` specifies the output format of the enciphered
			
 
				+         * data. If the `outputEncoding`is specified, a string using the specified encoding is returned. If no`outputEncoding` is provided, a `Buffer` is returned.
			
 
				+         *
			
 
				+         * The `decipher.update()` method can be called multiple times with new data until `decipher.final()` is called. Calling `decipher.update()` after `decipher.final()` will result in an error
			
 
				+         * being thrown.
			
 
				+         * @since v0.1.94
			
 
				+         * @param inputEncoding The `encoding` of the `data` string.
			
 
				+         * @param outputEncoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        update(data: NodeJS.ArrayBufferView): Buffer;
			
 
				+        update(data: string, inputEncoding: Encoding): Buffer;
			
 
				+        update(data: NodeJS.ArrayBufferView, inputEncoding: undefined, outputEncoding: Encoding): string;
			
 
				+        update(data: string, inputEncoding: Encoding | undefined, outputEncoding: Encoding): string;
			
 
				+        /**
			
 
				+         * Once the `decipher.final()` method has been called, the `Decipher` object can
			
 
				+         * no longer be used to decrypt data. Attempts to call `decipher.final()` more
			
 
				+         * than once will result in an error being thrown.
			
 
				+         * @since v0.1.94
			
 
				+         * @param outputEncoding The `encoding` of the return value.
			
 
				+         * @return Any remaining deciphered contents. If `outputEncoding` is specified, a string is returned. If an `outputEncoding` is not provided, a {@link Buffer} is returned.
			
 
				+         */
			
 
				+        final(): Buffer;
			
 
				+        final(outputEncoding: BufferEncoding): string;
			
 
				+        /**
			
 
				+         * When data has been encrypted without standard block padding, calling`decipher.setAutoPadding(false)` will disable automatic padding to prevent `decipher.final()` from checking for and
			
 
				+         * removing padding.
			
 
				+         *
			
 
				+         * Turning auto padding off will only work if the input data's length is a
			
 
				+         * multiple of the ciphers block size.
			
 
				+         *
			
 
				+         * The `decipher.setAutoPadding()` method must be called before `decipher.final()`.
			
 
				+         * @since v0.7.1
			
 
				+         * @param [autoPadding=true]
			
 
				+         * @return for method chaining.
			
 
				+         */
			
 
				+        setAutoPadding(auto_padding?: boolean): this;
			
 
				+    }
			
 
				+    interface DecipherCCM extends Decipher {
			
 
				+        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
			
 
				+        setAAD(
			
 
				+            buffer: NodeJS.ArrayBufferView,
			
 
				+            options: {
			
 
				+                plaintextLength: number;
			
 
				+            }
			
 
				+        ): this;
			
 
				+    }
			
 
				+    interface DecipherGCM extends Decipher {
			
 
				+        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
			
 
				+        setAAD(
			
 
				+            buffer: NodeJS.ArrayBufferView,
			
 
				+            options?: {
			
 
				+                plaintextLength: number;
			
 
				+            }
			
 
				+        ): this;
			
 
				+    }
			
 
				+    interface DecipherOCB extends Decipher {
			
 
				+        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
			
 
				+        setAAD(
			
 
				+            buffer: NodeJS.ArrayBufferView,
			
 
				+            options?: {
			
 
				+                plaintextLength: number;
			
 
				+            }
			
 
				+        ): this;
			
 
				+    }
			
 
				+    interface PrivateKeyInput {
			
 
				+        key: string | Buffer;
			
 
				+        format?: KeyFormat | undefined;
			
 
				+        type?: 'pkcs1' | 'pkcs8' | 'sec1' | undefined;
			
 
				+        passphrase?: string | Buffer | undefined;
			
 
				+        encoding?: string | undefined;
			
 
				+    }
			
 
				+    interface PublicKeyInput {
			
 
				+        key: string | Buffer;
			
 
				+        format?: KeyFormat | undefined;
			
 
				+        type?: 'pkcs1' | 'spki' | undefined;
			
 
				+        encoding?: string | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Asynchronously generates a new random secret key of the given `length`. The`type` will determine which validations will be performed on the `length`.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   generateKey
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * generateKey('hmac', { length: 64 }, (err, key) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(key.export().toString('hex'));  // 46e..........620
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v15.0.0
			
 
				+     * @param type The intended use of the generated secret key. Currently accepted values are `'hmac'` and `'aes'`.
			
 
				+     */
			
 
				+    function generateKey(
			
 
				+        type: 'hmac' | 'aes',
			
 
				+        options: {
			
 
				+            length: number;
			
 
				+        },
			
 
				+        callback: (err: Error | null, key: KeyObject) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Synchronously generates a new random secret key of the given `length`. The`type` will determine which validations will be performed on the `length`.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   generateKeySync
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const key = generateKeySync('hmac', { length: 64 });
			
 
				+     * console.log(key.export().toString('hex'));  // e89..........41e
			
 
				+     * ```
			
 
				+     * @since v15.0.0
			
 
				+     * @param type The intended use of the generated secret key. Currently accepted values are `'hmac'` and `'aes'`.
			
 
				+     */
			
 
				+    function generateKeySync(
			
 
				+        type: 'hmac' | 'aes',
			
 
				+        options: {
			
 
				+            length: number;
			
 
				+        }
			
 
				+    ): KeyObject;
			
 
				+    interface JsonWebKeyInput {
			
 
				+        key: JsonWebKey;
			
 
				+        format: 'jwk';
			
 
				+    }
			
 
				+    /**
			
 
				+     * Creates and returns a new key object containing a private key. If `key` is a
			
 
				+     * string or `Buffer`, `format` is assumed to be `'pem'`; otherwise, `key`must be an object with the properties described above.
			
 
				+     *
			
 
				+     * If the private key is encrypted, a `passphrase` must be specified. The length
			
 
				+     * of the passphrase is limited to 1024 bytes.
			
 
				+     * @since v11.6.0
			
 
				+     */
			
 
				+    function createPrivateKey(key: PrivateKeyInput | string | Buffer | JsonWebKeyInput): KeyObject;
			
 
				+    /**
			
 
				+     * Creates and returns a new key object containing a public key. If `key` is a
			
 
				+     * string or `Buffer`, `format` is assumed to be `'pem'`; if `key` is a `KeyObject`with type `'private'`, the public key is derived from the given private key;
			
 
				+     * otherwise, `key` must be an object with the properties described above.
			
 
				+     *
			
 
				+     * If the format is `'pem'`, the `'key'` may also be an X.509 certificate.
			
 
				+     *
			
 
				+     * Because public keys can be derived from private keys, a private key may be
			
 
				+     * passed instead of a public key. In that case, this function behaves as if {@link createPrivateKey} had been called, except that the type of the
			
 
				+     * returned `KeyObject` will be `'public'` and that the private key cannot be
			
 
				+     * extracted from the returned `KeyObject`. Similarly, if a `KeyObject` with type`'private'` is given, a new `KeyObject` with type `'public'` will be returned
			
 
				+     * and it will be impossible to extract the private key from the returned object.
			
 
				+     * @since v11.6.0
			
 
				+     */
			
 
				+    function createPublicKey(key: PublicKeyInput | string | Buffer | KeyObject | JsonWebKeyInput): KeyObject;
			
 
				+    /**
			
 
				+     * Creates and returns a new key object containing a secret key for symmetric
			
 
				+     * encryption or `Hmac`.
			
 
				+     * @since v11.6.0
			
 
				+     * @param encoding The string encoding when `key` is a string.
			
 
				+     */
			
 
				+    function createSecretKey(key: NodeJS.ArrayBufferView): KeyObject;
			
 
				+    function createSecretKey(key: string, encoding: BufferEncoding): KeyObject;
			
 
				+    /**
			
 
				+     * Creates and returns a `Sign` object that uses the given `algorithm`. Use {@link getHashes} to obtain the names of the available digest algorithms.
			
 
				+     * Optional `options` argument controls the `stream.Writable` behavior.
			
 
				+     *
			
 
				+     * In some cases, a `Sign` instance can be created using the name of a signature
			
 
				+     * algorithm, such as `'RSA-SHA256'`, instead of a digest algorithm. This will use
			
 
				+     * the corresponding digest algorithm. This does not work for all signature
			
 
				+     * algorithms, such as `'ecdsa-with-SHA256'`, so it is best to always use digest
			
 
				+     * algorithm names.
			
 
				+     * @since v0.1.92
			
 
				+     * @param options `stream.Writable` options
			
 
				+     */
			
 
				+    function createSign(algorithm: string, options?: stream.WritableOptions): Sign;
			
 
				+    type DSAEncoding = 'der' | 'ieee-p1363';
			
 
				+    interface SigningOptions {
			
 
				+        /**
			
 
				+         * @See crypto.constants.RSA_PKCS1_PADDING
			
 
				+         */
			
 
				+        padding?: number | undefined;
			
 
				+        saltLength?: number | undefined;
			
 
				+        dsaEncoding?: DSAEncoding | undefined;
			
 
				+    }
			
 
				+    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {}
			
 
				+    interface SignKeyObjectInput extends SigningOptions {
			
 
				+        key: KeyObject;
			
 
				+    }
			
 
				+    interface VerifyPublicKeyInput extends PublicKeyInput, SigningOptions {}
			
 
				+    interface VerifyKeyObjectInput extends SigningOptions {
			
 
				+        key: KeyObject;
			
 
				+    }
			
 
				+    type KeyLike = string | Buffer | KeyObject;
			
 
				+    /**
			
 
				+     * The `Sign` class is a utility for generating signatures. It can be used in one
			
 
				+     * of two ways:
			
 
				+     *
			
 
				+     * * As a writable `stream`, where data to be signed is written and the `sign.sign()` method is used to generate and return the signature, or
			
 
				+     * * Using the `sign.update()` and `sign.sign()` methods to produce the
			
 
				+     * signature.
			
 
				+     *
			
 
				+     * The {@link createSign} method is used to create `Sign` instances. The
			
 
				+     * argument is the string name of the hash function to use. `Sign` objects are not
			
 
				+     * to be created directly using the `new` keyword.
			
 
				+     *
			
 
				+     * Example: Using `Sign` and `Verify` objects as streams:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   generateKeyPairSync,
			
 
				+     *   createSign,
			
 
				+     *   createVerify
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const { privateKey, publicKey } = generateKeyPairSync('ec', {
			
 
				+     *   namedCurve: 'sect239k1'
			
 
				+     * });
			
 
				+     *
			
 
				+     * const sign = createSign('SHA256');
			
 
				+     * sign.write('some data to sign');
			
 
				+     * sign.end();
			
 
				+     * const signature = sign.sign(privateKey, 'hex');
			
 
				+     *
			
 
				+     * const verify = createVerify('SHA256');
			
 
				+     * verify.write('some data to sign');
			
 
				+     * verify.end();
			
 
				+     * console.log(verify.verify(publicKey, signature, 'hex'));
			
 
				+     * // Prints: true
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Example: Using the `sign.update()` and `verify.update()` methods:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   generateKeyPairSync,
			
 
				+     *   createSign,
			
 
				+     *   createVerify
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const { privateKey, publicKey } = generateKeyPairSync('rsa', {
			
 
				+     *   modulusLength: 2048,
			
 
				+     * });
			
 
				+     *
			
 
				+     * const sign = createSign('SHA256');
			
 
				+     * sign.update('some data to sign');
			
 
				+     * sign.end();
			
 
				+     * const signature = sign.sign(privateKey);
			
 
				+     *
			
 
				+     * const verify = createVerify('SHA256');
			
 
				+     * verify.update('some data to sign');
			
 
				+     * verify.end();
			
 
				+     * console.log(verify.verify(publicKey, signature));
			
 
				+     * // Prints: true
			
 
				+     * ```
			
 
				+     * @since v0.1.92
			
 
				+     */
			
 
				+    class Sign extends stream.Writable {
			
 
				+        private constructor();
			
 
				+        /**
			
 
				+         * Updates the `Sign` content with the given `data`, the encoding of which
			
 
				+         * is given in `inputEncoding`.
			
 
				+         * If `encoding` is not provided, and the `data` is a string, an
			
 
				+         * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
			
 
				+         *
			
 
				+         * This can be called many times with new data as it is streamed.
			
 
				+         * @since v0.1.92
			
 
				+         * @param inputEncoding The `encoding` of the `data` string.
			
 
				+         */
			
 
				+        update(data: BinaryLike): this;
			
 
				+        update(data: string, inputEncoding: Encoding): this;
			
 
				+        /**
			
 
				+         * Calculates the signature on all the data passed through using either `sign.update()` or `sign.write()`.
			
 
				+         *
			
 
				+         * If `privateKey` is not a `KeyObject`, this function behaves as if`privateKey` had been passed to {@link createPrivateKey}. If it is an
			
 
				+         * object, the following additional properties can be passed:
			
 
				+         *
			
 
				+         * If `outputEncoding` is provided a string is returned; otherwise a `Buffer` is returned.
			
 
				+         *
			
 
				+         * The `Sign` object can not be again used after `sign.sign()` method has been
			
 
				+         * called. Multiple calls to `sign.sign()` will result in an error being thrown.
			
 
				+         * @since v0.1.92
			
 
				+         */
			
 
				+        sign(privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput): Buffer;
			
 
				+        sign(privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput, outputFormat: BinaryToTextEncoding): string;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Creates and returns a `Verify` object that uses the given algorithm.
			
 
				+     * Use {@link getHashes} to obtain an array of names of the available
			
 
				+     * signing algorithms. Optional `options` argument controls the`stream.Writable` behavior.
			
 
				+     *
			
 
				+     * In some cases, a `Verify` instance can be created using the name of a signature
			
 
				+     * algorithm, such as `'RSA-SHA256'`, instead of a digest algorithm. This will use
			
 
				+     * the corresponding digest algorithm. This does not work for all signature
			
 
				+     * algorithms, such as `'ecdsa-with-SHA256'`, so it is best to always use digest
			
 
				+     * algorithm names.
			
 
				+     * @since v0.1.92
			
 
				+     * @param options `stream.Writable` options
			
 
				+     */
			
 
				+    function createVerify(algorithm: string, options?: stream.WritableOptions): Verify;
			
 
				+    /**
			
 
				+     * The `Verify` class is a utility for verifying signatures. It can be used in one
			
 
				+     * of two ways:
			
 
				+     *
			
 
				+     * * As a writable `stream` where written data is used to validate against the
			
 
				+     * supplied signature, or
			
 
				+     * * Using the `verify.update()` and `verify.verify()` methods to verify
			
 
				+     * the signature.
			
 
				+     *
			
 
				+     * The {@link createVerify} method is used to create `Verify` instances.`Verify` objects are not to be created directly using the `new` keyword.
			
 
				+     *
			
 
				+     * See `Sign` for examples.
			
 
				+     * @since v0.1.92
			
 
				+     */
			
 
				+    class Verify extends stream.Writable {
			
 
				+        private constructor();
			
 
				+        /**
			
 
				+         * Updates the `Verify` content with the given `data`, the encoding of which
			
 
				+         * is given in `inputEncoding`.
			
 
				+         * If `inputEncoding` is not provided, and the `data` is a string, an
			
 
				+         * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
			
 
				+         *
			
 
				+         * This can be called many times with new data as it is streamed.
			
 
				+         * @since v0.1.92
			
 
				+         * @param inputEncoding The `encoding` of the `data` string.
			
 
				+         */
			
 
				+        update(data: BinaryLike): Verify;
			
 
				+        update(data: string, inputEncoding: Encoding): Verify;
			
 
				+        /**
			
 
				+         * Verifies the provided data using the given `object` and `signature`.
			
 
				+         *
			
 
				+         * If `object` is not a `KeyObject`, this function behaves as if`object` had been passed to {@link createPublicKey}. If it is an
			
 
				+         * object, the following additional properties can be passed:
			
 
				+         *
			
 
				+         * The `signature` argument is the previously calculated signature for the data, in
			
 
				+         * the `signatureEncoding`.
			
 
				+         * If a `signatureEncoding` is specified, the `signature` is expected to be a
			
 
				+         * string; otherwise `signature` is expected to be a `Buffer`,`TypedArray`, or `DataView`.
			
 
				+         *
			
 
				+         * The `verify` object can not be used again after `verify.verify()` has been
			
 
				+         * called. Multiple calls to `verify.verify()` will result in an error being
			
 
				+         * thrown.
			
 
				+         *
			
 
				+         * Because public keys can be derived from private keys, a private key may
			
 
				+         * be passed instead of a public key.
			
 
				+         * @since v0.1.92
			
 
				+         */
			
 
				+        verify(object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, signature: NodeJS.ArrayBufferView): boolean;
			
 
				+        verify(object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, signature: string, signature_format?: BinaryToTextEncoding): boolean;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Creates a `DiffieHellman` key exchange object using the supplied `prime` and an
			
 
				+     * optional specific `generator`.
			
 
				+     *
			
 
				+     * The `generator` argument can be a number, string, or `Buffer`. If`generator` is not specified, the value `2` is used.
			
 
				+     *
			
 
				+     * If `primeEncoding` is specified, `prime` is expected to be a string; otherwise
			
 
				+     * a `Buffer`, `TypedArray`, or `DataView` is expected.
			
 
				+     *
			
 
				+     * If `generatorEncoding` is specified, `generator` is expected to be a string;
			
 
				+     * otherwise a number, `Buffer`, `TypedArray`, or `DataView` is expected.
			
 
				+     * @since v0.11.12
			
 
				+     * @param primeEncoding The `encoding` of the `prime` string.
			
 
				+     * @param [generator=2]
			
 
				+     * @param generatorEncoding The `encoding` of the `generator` string.
			
 
				+     */
			
 
				+    function createDiffieHellman(primeLength: number, generator?: number): DiffieHellman;
			
 
				+    function createDiffieHellman(prime: ArrayBuffer | NodeJS.ArrayBufferView, generator?: number | ArrayBuffer | NodeJS.ArrayBufferView): DiffieHellman;
			
 
				+    function createDiffieHellman(prime: ArrayBuffer | NodeJS.ArrayBufferView, generator: string, generatorEncoding: BinaryToTextEncoding): DiffieHellman;
			
 
				+    function createDiffieHellman(prime: string, primeEncoding: BinaryToTextEncoding, generator?: number | ArrayBuffer | NodeJS.ArrayBufferView): DiffieHellman;
			
 
				+    function createDiffieHellman(prime: string, primeEncoding: BinaryToTextEncoding, generator: string, generatorEncoding: BinaryToTextEncoding): DiffieHellman;
			
 
				+    /**
			
 
				+     * The `DiffieHellman` class is a utility for creating Diffie-Hellman key
			
 
				+     * exchanges.
			
 
				+     *
			
 
				+     * Instances of the `DiffieHellman` class can be created using the {@link createDiffieHellman} function.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import assert from 'assert';
			
 
				+     *
			
 
				+     * const {
			
 
				+     *   createDiffieHellman
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * // Generate Alice's keys...
			
 
				+     * const alice = createDiffieHellman(2048);
			
 
				+     * const aliceKey = alice.generateKeys();
			
 
				+     *
			
 
				+     * // Generate Bob's keys...
			
 
				+     * const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator());
			
 
				+     * const bobKey = bob.generateKeys();
			
 
				+     *
			
 
				+     * // Exchange and generate the secret...
			
 
				+     * const aliceSecret = alice.computeSecret(bobKey);
			
 
				+     * const bobSecret = bob.computeSecret(aliceKey);
			
 
				+     *
			
 
				+     * // OK
			
 
				+     * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
			
 
				+     * ```
			
 
				+     * @since v0.5.0
			
 
				+     */
			
 
				+    class DiffieHellman {
			
 
				+        private constructor();
			
 
				+        /**
			
 
				+         * Generates private and public Diffie-Hellman key values, and returns
			
 
				+         * the public key in the specified `encoding`. This key should be
			
 
				+         * transferred to the other party.
			
 
				+         * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned.
			
 
				+         * @since v0.5.0
			
 
				+         * @param encoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        generateKeys(): Buffer;
			
 
				+        generateKeys(encoding: BinaryToTextEncoding): string;
			
 
				+        /**
			
 
				+         * Computes the shared secret using `otherPublicKey` as the other
			
 
				+         * party's public key and returns the computed shared secret. The supplied
			
 
				+         * key is interpreted using the specified `inputEncoding`, and secret is
			
 
				+         * encoded using specified `outputEncoding`.
			
 
				+         * If the `inputEncoding` is not
			
 
				+         * provided, `otherPublicKey` is expected to be a `Buffer`,`TypedArray`, or `DataView`.
			
 
				+         *
			
 
				+         * If `outputEncoding` is given a string is returned; otherwise, a `Buffer` is returned.
			
 
				+         * @since v0.5.0
			
 
				+         * @param inputEncoding The `encoding` of an `otherPublicKey` string.
			
 
				+         * @param outputEncoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, inputEncoding?: null, outputEncoding?: null): Buffer;
			
 
				+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding, outputEncoding?: null): Buffer;
			
 
				+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, inputEncoding: null, outputEncoding: BinaryToTextEncoding): string;
			
 
				+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding, outputEncoding: BinaryToTextEncoding): string;
			
 
				+        /**
			
 
				+         * Returns the Diffie-Hellman prime in the specified `encoding`.
			
 
				+         * If `encoding` is provided a string is
			
 
				+         * returned; otherwise a `Buffer` is returned.
			
 
				+         * @since v0.5.0
			
 
				+         * @param encoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        getPrime(): Buffer;
			
 
				+        getPrime(encoding: BinaryToTextEncoding): string;
			
 
				+        /**
			
 
				+         * Returns the Diffie-Hellman generator in the specified `encoding`.
			
 
				+         * If `encoding` is provided a string is
			
 
				+         * returned; otherwise a `Buffer` is returned.
			
 
				+         * @since v0.5.0
			
 
				+         * @param encoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        getGenerator(): Buffer;
			
 
				+        getGenerator(encoding: BinaryToTextEncoding): string;
			
 
				+        /**
			
 
				+         * Returns the Diffie-Hellman public key in the specified `encoding`.
			
 
				+         * If `encoding` is provided a
			
 
				+         * string is returned; otherwise a `Buffer` is returned.
			
 
				+         * @since v0.5.0
			
 
				+         * @param encoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        getPublicKey(): Buffer;
			
 
				+        getPublicKey(encoding: BinaryToTextEncoding): string;
			
 
				+        /**
			
 
				+         * Returns the Diffie-Hellman private key in the specified `encoding`.
			
 
				+         * If `encoding` is provided a
			
 
				+         * string is returned; otherwise a `Buffer` is returned.
			
 
				+         * @since v0.5.0
			
 
				+         * @param encoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        getPrivateKey(): Buffer;
			
 
				+        getPrivateKey(encoding: BinaryToTextEncoding): string;
			
 
				+        /**
			
 
				+         * Sets the Diffie-Hellman public key. If the `encoding` argument is provided,`publicKey` is expected
			
 
				+         * to be a string. If no `encoding` is provided, `publicKey` is expected
			
 
				+         * to be a `Buffer`, `TypedArray`, or `DataView`.
			
 
				+         * @since v0.5.0
			
 
				+         * @param encoding The `encoding` of the `publicKey` string.
			
 
				+         */
			
 
				+        setPublicKey(publicKey: NodeJS.ArrayBufferView): void;
			
 
				+        setPublicKey(publicKey: string, encoding: BufferEncoding): void;
			
 
				+        /**
			
 
				+         * Sets the Diffie-Hellman private key. If the `encoding` argument is provided,`privateKey` is expected
			
 
				+         * to be a string. If no `encoding` is provided, `privateKey` is expected
			
 
				+         * to be a `Buffer`, `TypedArray`, or `DataView`.
			
 
				+         * @since v0.5.0
			
 
				+         * @param encoding The `encoding` of the `privateKey` string.
			
 
				+         */
			
 
				+        setPrivateKey(privateKey: NodeJS.ArrayBufferView): void;
			
 
				+        setPrivateKey(privateKey: string, encoding: BufferEncoding): void;
			
 
				+        /**
			
 
				+         * A bit field containing any warnings and/or errors resulting from a check
			
 
				+         * performed during initialization of the `DiffieHellman` object.
			
 
				+         *
			
 
				+         * The following values are valid for this property (as defined in `constants`module):
			
 
				+         *
			
 
				+         * * `DH_CHECK_P_NOT_SAFE_PRIME`
			
 
				+         * * `DH_CHECK_P_NOT_PRIME`
			
 
				+         * * `DH_UNABLE_TO_CHECK_GENERATOR`
			
 
				+         * * `DH_NOT_SUITABLE_GENERATOR`
			
 
				+         * @since v0.11.12
			
 
				+         */
			
 
				+        verifyError: number;
			
 
				+    }
			
 
				+    /**
			
 
				+     * The `DiffieHellmanGroup` class takes a well-known modp group as its argument.
			
 
				+     * It works the same as `DiffieHellman`, except that it does not allow changing its keys after creation.
			
 
				+     * In other words, it does not implement `setPublicKey()` or `setPrivateKey()` methods.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { createDiffieHellmanGroup } = await import('node:crypto');
			
 
				+     * const dh = createDiffieHellmanGroup('modp1');
			
 
				+     * ```
			
 
				+     * The name (e.g. `'modp1'`) is taken from [RFC 2412](https://www.rfc-editor.org/rfc/rfc2412.txt) (modp1 and 2) and [RFC 3526](https://www.rfc-editor.org/rfc/rfc3526.txt):
			
 
				+     * ```bash
			
 
				+     * $ perl -ne 'print "$1\n" if /"(modp\d+)"/' src/node_crypto_groups.h
			
 
				+     * modp1  #  768 bits
			
 
				+     * modp2  # 1024 bits
			
 
				+     * modp5  # 1536 bits
			
 
				+     * modp14 # 2048 bits
			
 
				+     * modp15 # etc.
			
 
				+     * modp16
			
 
				+     * modp17
			
 
				+     * modp18
			
 
				+     * ```
			
 
				+     * @since v0.7.5
			
 
				+     */
			
 
				+    const DiffieHellmanGroup: DiffieHellmanGroupConstructor;
			
 
				+    interface DiffieHellmanGroupConstructor {
			
 
				+        new(name: string): DiffieHellmanGroup;
			
 
				+        (name: string): DiffieHellmanGroup;
			
 
				+        readonly prototype: DiffieHellmanGroup;
			
 
				+    }
			
 
				+    type DiffieHellmanGroup = Omit<DiffieHellman, 'setPublicKey' | 'setPrivateKey'>;
			
 
				+    /**
			
 
				+     * Creates a predefined `DiffieHellmanGroup` key exchange object. The
			
 
				+     * supported groups are: `'modp1'`, `'modp2'`, `'modp5'` (defined in [RFC 2412](https://www.rfc-editor.org/rfc/rfc2412.txt), but see `Caveats`) and `'modp14'`, `'modp15'`,`'modp16'`, `'modp17'`,
			
 
				+     * `'modp18'` (defined in [RFC 3526](https://www.rfc-editor.org/rfc/rfc3526.txt)). The
			
 
				+     * returned object mimics the interface of objects created by {@link createDiffieHellman}, but will not allow changing
			
 
				+     * the keys (with `diffieHellman.setPublicKey()`, for example). The
			
 
				+     * advantage of using this method is that the parties do not have to
			
 
				+     * generate nor exchange a group modulus beforehand, saving both processor
			
 
				+     * and communication time.
			
 
				+     *
			
 
				+     * Example (obtaining a shared secret):
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   getDiffieHellman
			
 
				+     * } = await import('crypto');
			
 
				+     * const alice = getDiffieHellman('modp14');
			
 
				+     * const bob = getDiffieHellman('modp14');
			
 
				+     *
			
 
				+     * alice.generateKeys();
			
 
				+     * bob.generateKeys();
			
 
				+     *
			
 
				+     * const aliceSecret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
			
 
				+     * const bobSecret = bob.computeSecret(alice.getPublicKey(), null, 'hex');
			
 
				+     *
			
 
				+     * // aliceSecret and bobSecret should be the same
			
 
				+     * console.log(aliceSecret === bobSecret);
			
 
				+     * ```
			
 
				+     * @since v0.7.5
			
 
				+     */
			
 
				+    function getDiffieHellman(groupName: string): DiffieHellmanGroup;
			
 
				+    /**
			
 
				+     * An alias for {@link getDiffieHellman}
			
 
				+     * @since v0.9.3
			
 
				+     */
			
 
				+    function createDiffieHellmanGroup(name: string): DiffieHellmanGroup;
			
 
				+    /**
			
 
				+     * Provides an asynchronous Password-Based Key Derivation Function 2 (PBKDF2)
			
 
				+     * implementation. A selected HMAC digest algorithm specified by `digest` is
			
 
				+     * applied to derive a key of the requested byte length (`keylen`) from the`password`, `salt` and `iterations`.
			
 
				+     *
			
 
				+     * The supplied `callback` function is called with two arguments: `err` and`derivedKey`. If an error occurs while deriving the key, `err` will be set;
			
 
				+     * otherwise `err` will be `null`. By default, the successfully generated`derivedKey` will be passed to the callback as a `Buffer`. An error will be
			
 
				+     * thrown if any of the input arguments specify invalid values or types.
			
 
				+     *
			
 
				+     * If `digest` is `null`, `'sha1'` will be used. This behavior is deprecated,
			
 
				+     * please specify a `digest` explicitly.
			
 
				+     *
			
 
				+     * The `iterations` argument must be a number set as high as possible. The
			
 
				+     * higher the number of iterations, the more secure the derived key will be,
			
 
				+     * but will take a longer amount of time to complete.
			
 
				+     *
			
 
				+     * The `salt` should be as unique as possible. It is recommended that a salt is
			
 
				+     * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details.
			
 
				+     *
			
 
				+     * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   pbkdf2
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The `crypto.DEFAULT_ENCODING` property can be used to change the way the`derivedKey` is passed to the callback. This property, however, has been
			
 
				+     * deprecated and use should be avoided.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import crypto from 'crypto';
			
 
				+     * crypto.DEFAULT_ENCODING = 'hex';
			
 
				+     * crypto.pbkdf2('secret', 'salt', 100000, 512, 'sha512', (err, derivedKey) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(derivedKey);  // '3745e48...aa39b34'
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * An array of supported digest functions can be retrieved using {@link getHashes}.
			
 
				+     *
			
 
				+     * This API uses libuv's threadpool, which can have surprising and
			
 
				+     * negative performance implications for some applications; see the `UV_THREADPOOL_SIZE` documentation for more information.
			
 
				+     * @since v0.5.5
			
 
				+     */
			
 
				+    function pbkdf2(password: BinaryLike, salt: BinaryLike, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey: Buffer) => void): void;
			
 
				+    /**
			
 
				+     * Provides a synchronous Password-Based Key Derivation Function 2 (PBKDF2)
			
 
				+     * implementation. A selected HMAC digest algorithm specified by `digest` is
			
 
				+     * applied to derive a key of the requested byte length (`keylen`) from the`password`, `salt` and `iterations`.
			
 
				+     *
			
 
				+     * If an error occurs an `Error` will be thrown, otherwise the derived key will be
			
 
				+     * returned as a `Buffer`.
			
 
				+     *
			
 
				+     * If `digest` is `null`, `'sha1'` will be used. This behavior is deprecated,
			
 
				+     * please specify a `digest` explicitly.
			
 
				+     *
			
 
				+     * The `iterations` argument must be a number set as high as possible. The
			
 
				+     * higher the number of iterations, the more secure the derived key will be,
			
 
				+     * but will take a longer amount of time to complete.
			
 
				+     *
			
 
				+     * The `salt` should be as unique as possible. It is recommended that a salt is
			
 
				+     * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details.
			
 
				+     *
			
 
				+     * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   pbkdf2Sync
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512');
			
 
				+     * console.log(key.toString('hex'));  // '3745e48...08d59ae'
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The `crypto.DEFAULT_ENCODING` property may be used to change the way the`derivedKey` is returned. This property, however, is deprecated and use
			
 
				+     * should be avoided.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import crypto from 'crypto';
			
 
				+     * crypto.DEFAULT_ENCODING = 'hex';
			
 
				+     * const key = crypto.pbkdf2Sync('secret', 'salt', 100000, 512, 'sha512');
			
 
				+     * console.log(key);  // '3745e48...aa39b34'
			
 
				+     * ```
			
 
				+     *
			
 
				+     * An array of supported digest functions can be retrieved using {@link getHashes}.
			
 
				+     * @since v0.9.3
			
 
				+     */
			
 
				+    function pbkdf2Sync(password: BinaryLike, salt: BinaryLike, iterations: number, keylen: number, digest: string): Buffer;
			
 
				+    /**
			
 
				+     * Generates cryptographically strong pseudorandom data. The `size` argument
			
 
				+     * is a number indicating the number of bytes to generate.
			
 
				+     *
			
 
				+     * If a `callback` function is provided, the bytes are generated asynchronously
			
 
				+     * and the `callback` function is invoked with two arguments: `err` and `buf`.
			
 
				+     * If an error occurs, `err` will be an `Error` object; otherwise it is `null`. The`buf` argument is a `Buffer` containing the generated bytes.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * // Asynchronous
			
 
				+     * const {
			
 
				+     *   randomBytes
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * randomBytes(256, (err, buf) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If the `callback` function is not provided, the random bytes are generated
			
 
				+     * synchronously and returned as a `Buffer`. An error will be thrown if
			
 
				+     * there is a problem generating the bytes.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * // Synchronous
			
 
				+     * const {
			
 
				+     *   randomBytes
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const buf = randomBytes(256);
			
 
				+     * console.log(
			
 
				+     *   `${buf.length} bytes of random data: ${buf.toString('hex')}`);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The `crypto.randomBytes()` method will not complete until there is
			
 
				+     * sufficient entropy available.
			
 
				+     * This should normally never take longer than a few milliseconds. The only time
			
 
				+     * when generating the random bytes may conceivably block for a longer period of
			
 
				+     * time is right after boot, when the whole system is still low on entropy.
			
 
				+     *
			
 
				+     * This API uses libuv's threadpool, which can have surprising and
			
 
				+     * negative performance implications for some applications; see the `UV_THREADPOOL_SIZE` documentation for more information.
			
 
				+     *
			
 
				+     * The asynchronous version of `crypto.randomBytes()` is carried out in a single
			
 
				+     * threadpool request. To minimize threadpool task length variation, partition
			
 
				+     * large `randomBytes` requests when doing so as part of fulfilling a client
			
 
				+     * request.
			
 
				+     * @since v0.5.8
			
 
				+     * @param size The number of bytes to generate. The `size` must not be larger than `2**31 - 1`.
			
 
				+     * @return if the `callback` function is not provided.
			
 
				+     */
			
 
				+    function randomBytes(size: number): Buffer;
			
 
				+    function randomBytes(size: number, callback: (err: Error | null, buf: Buffer) => void): void;
			
 
				+    function pseudoRandomBytes(size: number): Buffer;
			
 
				+    function pseudoRandomBytes(size: number, callback: (err: Error | null, buf: Buffer) => void): void;
			
 
				+    /**
			
 
				+     * Return a random integer `n` such that `min <= n < max`.  This
			
 
				+     * implementation avoids [modulo bias](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias).
			
 
				+     *
			
 
				+     * The range (`max - min`) must be less than 2^48. `min` and `max` must
			
 
				+     * be [safe integers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
			
 
				+     *
			
 
				+     * If the `callback` function is not provided, the random integer is
			
 
				+     * generated synchronously.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * // Asynchronous
			
 
				+     * const {
			
 
				+     *   randomInt
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * randomInt(3, (err, n) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(`Random number chosen from (0, 1, 2): ${n}`);
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * // Synchronous
			
 
				+     * const {
			
 
				+     *   randomInt
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const n = randomInt(3);
			
 
				+     * console.log(`Random number chosen from (0, 1, 2): ${n}`);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * // With `min` argument
			
 
				+     * const {
			
 
				+     *   randomInt
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const n = randomInt(1, 7);
			
 
				+     * console.log(`The dice rolled: ${n}`);
			
 
				+     * ```
			
 
				+     * @since v14.10.0, v12.19.0
			
 
				+     * @param [min=0] Start of random range (inclusive).
			
 
				+     * @param max End of random range (exclusive).
			
 
				+     * @param callback `function(err, n) {}`.
			
 
				+     */
			
 
				+    function randomInt(max: number): number;
			
 
				+    function randomInt(min: number, max: number): number;
			
 
				+    function randomInt(max: number, callback: (err: Error | null, value: number) => void): void;
			
 
				+    function randomInt(min: number, max: number, callback: (err: Error | null, value: number) => void): void;
			
 
				+    /**
			
 
				+     * Synchronous version of {@link randomFill}.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     * const { randomFillSync } = await import('crypto');
			
 
				+     *
			
 
				+     * const buf = Buffer.alloc(10);
			
 
				+     * console.log(randomFillSync(buf).toString('hex'));
			
 
				+     *
			
 
				+     * randomFillSync(buf, 5);
			
 
				+     * console.log(buf.toString('hex'));
			
 
				+     *
			
 
				+     * // The above is equivalent to the following:
			
 
				+     * randomFillSync(buf, 5, 5);
			
 
				+     * console.log(buf.toString('hex'));
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Any `ArrayBuffer`, `TypedArray` or `DataView` instance may be passed as`buffer`.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     * const { randomFillSync } = await import('crypto');
			
 
				+     *
			
 
				+     * const a = new Uint32Array(10);
			
 
				+     * console.log(Buffer.from(randomFillSync(a).buffer,
			
 
				+     *                         a.byteOffset, a.byteLength).toString('hex'));
			
 
				+     *
			
 
				+     * const b = new DataView(new ArrayBuffer(10));
			
 
				+     * console.log(Buffer.from(randomFillSync(b).buffer,
			
 
				+     *                         b.byteOffset, b.byteLength).toString('hex'));
			
 
				+     *
			
 
				+     * const c = new ArrayBuffer(10);
			
 
				+     * console.log(Buffer.from(randomFillSync(c)).toString('hex'));
			
 
				+     * ```
			
 
				+     * @since v7.10.0, v6.13.0
			
 
				+     * @param buffer Must be supplied. The size of the provided `buffer` must not be larger than `2**31 - 1`.
			
 
				+     * @param [offset=0]
			
 
				+     * @param [size=buffer.length - offset]
			
 
				+     * @return The object passed as `buffer` argument.
			
 
				+     */
			
 
				+    function randomFillSync<T extends NodeJS.ArrayBufferView>(buffer: T, offset?: number, size?: number): T;
			
 
				+    /**
			
 
				+     * This function is similar to {@link randomBytes} but requires the first
			
 
				+     * argument to be a `Buffer` that will be filled. It also
			
 
				+     * requires that a callback is passed in.
			
 
				+     *
			
 
				+     * If the `callback` function is not provided, an error will be thrown.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     * const { randomFill } = await import('crypto');
			
 
				+     *
			
 
				+     * const buf = Buffer.alloc(10);
			
 
				+     * randomFill(buf, (err, buf) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(buf.toString('hex'));
			
 
				+     * });
			
 
				+     *
			
 
				+     * randomFill(buf, 5, (err, buf) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(buf.toString('hex'));
			
 
				+     * });
			
 
				+     *
			
 
				+     * // The above is equivalent to the following:
			
 
				+     * randomFill(buf, 5, 5, (err, buf) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(buf.toString('hex'));
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Any `ArrayBuffer`, `TypedArray`, or `DataView` instance may be passed as`buffer`.
			
 
				+     *
			
 
				+     * While this includes instances of `Float32Array` and `Float64Array`, this
			
 
				+     * function should not be used to generate random floating-point numbers. The
			
 
				+     * result may contain `+Infinity`, `-Infinity`, and `NaN`, and even if the array
			
 
				+     * contains finite numbers only, they are not drawn from a uniform random
			
 
				+     * distribution and have no meaningful lower or upper bounds.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     * const { randomFill } = await import('crypto');
			
 
				+     *
			
 
				+     * const a = new Uint32Array(10);
			
 
				+     * randomFill(a, (err, buf) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
			
 
				+     *     .toString('hex'));
			
 
				+     * });
			
 
				+     *
			
 
				+     * const b = new DataView(new ArrayBuffer(10));
			
 
				+     * randomFill(b, (err, buf) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
			
 
				+     *     .toString('hex'));
			
 
				+     * });
			
 
				+     *
			
 
				+     * const c = new ArrayBuffer(10);
			
 
				+     * randomFill(c, (err, buf) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(Buffer.from(buf).toString('hex'));
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * This API uses libuv's threadpool, which can have surprising and
			
 
				+     * negative performance implications for some applications; see the `UV_THREADPOOL_SIZE` documentation for more information.
			
 
				+     *
			
 
				+     * The asynchronous version of `crypto.randomFill()` is carried out in a single
			
 
				+     * threadpool request. To minimize threadpool task length variation, partition
			
 
				+     * large `randomFill` requests when doing so as part of fulfilling a client
			
 
				+     * request.
			
 
				+     * @since v7.10.0, v6.13.0
			
 
				+     * @param buffer Must be supplied. The size of the provided `buffer` must not be larger than `2**31 - 1`.
			
 
				+     * @param [offset=0]
			
 
				+     * @param [size=buffer.length - offset]
			
 
				+     * @param callback `function(err, buf) {}`.
			
 
				+     */
			
 
				+    function randomFill<T extends NodeJS.ArrayBufferView>(buffer: T, callback: (err: Error | null, buf: T) => void): void;
			
 
				+    function randomFill<T extends NodeJS.ArrayBufferView>(buffer: T, offset: number, callback: (err: Error | null, buf: T) => void): void;
			
 
				+    function randomFill<T extends NodeJS.ArrayBufferView>(buffer: T, offset: number, size: number, callback: (err: Error | null, buf: T) => void): void;
			
 
				+    interface ScryptOptions {
			
 
				+        cost?: number | undefined;
			
 
				+        blockSize?: number | undefined;
			
 
				+        parallelization?: number | undefined;
			
 
				+        N?: number | undefined;
			
 
				+        r?: number | undefined;
			
 
				+        p?: number | undefined;
			
 
				+        maxmem?: number | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Provides an asynchronous [scrypt](https://en.wikipedia.org/wiki/Scrypt) implementation. Scrypt is a password-based
			
 
				+     * key derivation function that is designed to be expensive computationally and
			
 
				+     * memory-wise in order to make brute-force attacks unrewarding.
			
 
				+     *
			
 
				+     * The `salt` should be as unique as possible. It is recommended that a salt is
			
 
				+     * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details.
			
 
				+     *
			
 
				+     * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`.
			
 
				+     *
			
 
				+     * The `callback` function is called with two arguments: `err` and `derivedKey`.`err` is an exception object when key derivation fails, otherwise `err` is`null`. `derivedKey` is passed to the
			
 
				+     * callback as a `Buffer`.
			
 
				+     *
			
 
				+     * An exception is thrown when any of the input arguments specify invalid values
			
 
				+     * or types.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   scrypt
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * // Using the factory defaults.
			
 
				+     * scrypt('password', 'salt', 64, (err, derivedKey) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
			
 
				+     * });
			
 
				+     * // Using a custom N parameter. Must be a power of two.
			
 
				+     * scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v10.5.0
			
 
				+     */
			
 
				+    function scrypt(password: BinaryLike, salt: BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: Buffer) => void): void;
			
 
				+    function scrypt(password: BinaryLike, salt: BinaryLike, keylen: number, options: ScryptOptions, callback: (err: Error | null, derivedKey: Buffer) => void): void;
			
 
				+    /**
			
 
				+     * Provides a synchronous [scrypt](https://en.wikipedia.org/wiki/Scrypt) implementation. Scrypt is a password-based
			
 
				+     * key derivation function that is designed to be expensive computationally and
			
 
				+     * memory-wise in order to make brute-force attacks unrewarding.
			
 
				+     *
			
 
				+     * The `salt` should be as unique as possible. It is recommended that a salt is
			
 
				+     * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details.
			
 
				+     *
			
 
				+     * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`.
			
 
				+     *
			
 
				+     * An exception is thrown when key derivation fails, otherwise the derived key is
			
 
				+     * returned as a `Buffer`.
			
 
				+     *
			
 
				+     * An exception is thrown when any of the input arguments specify invalid values
			
 
				+     * or types.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   scryptSync
			
 
				+     * } = await import('crypto');
			
 
				+     * // Using the factory defaults.
			
 
				+     *
			
 
				+     * const key1 = scryptSync('password', 'salt', 64);
			
 
				+     * console.log(key1.toString('hex'));  // '3745e48...08d59ae'
			
 
				+     * // Using a custom N parameter. Must be a power of two.
			
 
				+     * const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
			
 
				+     * console.log(key2.toString('hex'));  // '3745e48...aa39b34'
			
 
				+     * ```
			
 
				+     * @since v10.5.0
			
 
				+     */
			
 
				+    function scryptSync(password: BinaryLike, salt: BinaryLike, keylen: number, options?: ScryptOptions): Buffer;
			
 
				+    interface RsaPublicKey {
			
 
				+        key: KeyLike;
			
 
				+        padding?: number | undefined;
			
 
				+    }
			
 
				+    interface RsaPrivateKey {
			
 
				+        key: KeyLike;
			
 
				+        passphrase?: string | undefined;
			
 
				+        /**
			
 
				+         * @default 'sha1'
			
 
				+         */
			
 
				+        oaepHash?: string | undefined;
			
 
				+        oaepLabel?: NodeJS.TypedArray | undefined;
			
 
				+        padding?: number | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Encrypts the content of `buffer` with `key` and returns a new `Buffer` with encrypted content. The returned data can be decrypted using
			
 
				+     * the corresponding private key, for example using {@link privateDecrypt}.
			
 
				+     *
			
 
				+     * If `key` is not a `KeyObject`, this function behaves as if`key` had been passed to {@link createPublicKey}. If it is an
			
 
				+     * object, the `padding` property can be passed. Otherwise, this function uses`RSA_PKCS1_OAEP_PADDING`.
			
 
				+     *
			
 
				+     * Because RSA public keys can be derived from private keys, a private key may
			
 
				+     * be passed instead of a public key.
			
 
				+     * @since v0.11.14
			
 
				+     */
			
 
				+    function publicEncrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
			
 
				+    /**
			
 
				+     * Decrypts `buffer` with `key`.`buffer` was previously encrypted using
			
 
				+     * the corresponding private key, for example using {@link privateEncrypt}.
			
 
				+     *
			
 
				+     * If `key` is not a `KeyObject`, this function behaves as if`key` had been passed to {@link createPublicKey}. If it is an
			
 
				+     * object, the `padding` property can be passed. Otherwise, this function uses`RSA_PKCS1_PADDING`.
			
 
				+     *
			
 
				+     * Because RSA public keys can be derived from private keys, a private key may
			
 
				+     * be passed instead of a public key.
			
 
				+     * @since v1.1.0
			
 
				+     */
			
 
				+    function publicDecrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
			
 
				+    /**
			
 
				+     * Decrypts `buffer` with `privateKey`. `buffer` was previously encrypted using
			
 
				+     * the corresponding public key, for example using {@link publicEncrypt}.
			
 
				+     *
			
 
				+     * If `privateKey` is not a `KeyObject`, this function behaves as if`privateKey` had been passed to {@link createPrivateKey}. If it is an
			
 
				+     * object, the `padding` property can be passed. Otherwise, this function uses`RSA_PKCS1_OAEP_PADDING`.
			
 
				+     * @since v0.11.14
			
 
				+     */
			
 
				+    function privateDecrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
			
 
				+    /**
			
 
				+     * Encrypts `buffer` with `privateKey`. The returned data can be decrypted using
			
 
				+     * the corresponding public key, for example using {@link publicDecrypt}.
			
 
				+     *
			
 
				+     * If `privateKey` is not a `KeyObject`, this function behaves as if`privateKey` had been passed to {@link createPrivateKey}. If it is an
			
 
				+     * object, the `padding` property can be passed. Otherwise, this function uses`RSA_PKCS1_PADDING`.
			
 
				+     * @since v1.1.0
			
 
				+     */
			
 
				+    function privateEncrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
			
 
				+    /**
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   getCiphers
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...]
			
 
				+     * ```
			
 
				+     * @since v0.9.3
			
 
				+     * @return An array with the names of the supported cipher algorithms.
			
 
				+     */
			
 
				+    function getCiphers(): string[];
			
 
				+    /**
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   getCurves
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]
			
 
				+     * ```
			
 
				+     * @since v2.3.0
			
 
				+     * @return An array with the names of the supported elliptic curves.
			
 
				+     */
			
 
				+    function getCurves(): string[];
			
 
				+    /**
			
 
				+     * @since v10.0.0
			
 
				+     * @return `1` if and only if a FIPS compliant crypto provider is currently in use, `0` otherwise. A future semver-major release may change the return type of this API to a {boolean}.
			
 
				+     */
			
 
				+    function getFips(): 1 | 0;
			
 
				+    /**
			
 
				+     * Enables the FIPS compliant crypto provider in a FIPS-enabled Node.js build. Throws an error if FIPS mode is not available.
			
 
				+     * @since v10.0.0
			
 
				+     * @param bool `true` to enable FIPS mode.
			
 
				+     */
			
 
				+    function setFips(bool: boolean): void;
			
 
				+    /**
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   getHashes
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]
			
 
				+     * ```
			
 
				+     * @since v0.9.3
			
 
				+     * @return An array of the names of the supported hash algorithms, such as `'RSA-SHA256'`. Hash algorithms are also called "digest" algorithms.
			
 
				+     */
			
 
				+    function getHashes(): string[];
			
 
				+    /**
			
 
				+     * The `ECDH` class is a utility for creating Elliptic Curve Diffie-Hellman (ECDH)
			
 
				+     * key exchanges.
			
 
				+     *
			
 
				+     * Instances of the `ECDH` class can be created using the {@link createECDH} function.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import assert from 'assert';
			
 
				+     *
			
 
				+     * const {
			
 
				+     *   createECDH
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * // Generate Alice's keys...
			
 
				+     * const alice = createECDH('secp521r1');
			
 
				+     * const aliceKey = alice.generateKeys();
			
 
				+     *
			
 
				+     * // Generate Bob's keys...
			
 
				+     * const bob = createECDH('secp521r1');
			
 
				+     * const bobKey = bob.generateKeys();
			
 
				+     *
			
 
				+     * // Exchange and generate the secret...
			
 
				+     * const aliceSecret = alice.computeSecret(bobKey);
			
 
				+     * const bobSecret = bob.computeSecret(aliceKey);
			
 
				+     *
			
 
				+     * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
			
 
				+     * // OK
			
 
				+     * ```
			
 
				+     * @since v0.11.14
			
 
				+     */
			
 
				+    class ECDH {
			
 
				+        private constructor();
			
 
				+        /**
			
 
				+         * Converts the EC Diffie-Hellman public key specified by `key` and `curve` to the
			
 
				+         * format specified by `format`. The `format` argument specifies point encoding
			
 
				+         * and can be `'compressed'`, `'uncompressed'` or `'hybrid'`. The supplied key is
			
 
				+         * interpreted using the specified `inputEncoding`, and the returned key is encoded
			
 
				+         * using the specified `outputEncoding`.
			
 
				+         *
			
 
				+         * Use {@link getCurves} to obtain a list of available curve names.
			
 
				+         * On recent OpenSSL releases, `openssl ecparam -list_curves` will also display
			
 
				+         * the name and description of each available elliptic curve.
			
 
				+         *
			
 
				+         * If `format` is not specified the point will be returned in `'uncompressed'`format.
			
 
				+         *
			
 
				+         * If the `inputEncoding` is not provided, `key` is expected to be a `Buffer`,`TypedArray`, or `DataView`.
			
 
				+         *
			
 
				+         * Example (uncompressing a key):
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const {
			
 
				+         *   createECDH,
			
 
				+         *   ECDH
			
 
				+         * } = await import('crypto');
			
 
				+         *
			
 
				+         * const ecdh = createECDH('secp256k1');
			
 
				+         * ecdh.generateKeys();
			
 
				+         *
			
 
				+         * const compressedKey = ecdh.getPublicKey('hex', 'compressed');
			
 
				+         *
			
 
				+         * const uncompressedKey = ECDH.convertKey(compressedKey,
			
 
				+         *                                         'secp256k1',
			
 
				+         *                                         'hex',
			
 
				+         *                                         'hex',
			
 
				+         *                                         'uncompressed');
			
 
				+         *
			
 
				+         * // The converted key and the uncompressed public key should be the same
			
 
				+         * console.log(uncompressedKey === ecdh.getPublicKey('hex'));
			
 
				+         * ```
			
 
				+         * @since v10.0.0
			
 
				+         * @param inputEncoding The `encoding` of the `key` string.
			
 
				+         * @param outputEncoding The `encoding` of the return value.
			
 
				+         * @param [format='uncompressed']
			
 
				+         */
			
 
				+        static convertKey(
			
 
				+            key: BinaryLike,
			
 
				+            curve: string,
			
 
				+            inputEncoding?: BinaryToTextEncoding,
			
 
				+            outputEncoding?: 'latin1' | 'hex' | 'base64' | 'base64url',
			
 
				+            format?: 'uncompressed' | 'compressed' | 'hybrid'
			
 
				+        ): Buffer | string;
			
 
				+        /**
			
 
				+         * Generates private and public EC Diffie-Hellman key values, and returns
			
 
				+         * the public key in the specified `format` and `encoding`. This key should be
			
 
				+         * transferred to the other party.
			
 
				+         *
			
 
				+         * The `format` argument specifies point encoding and can be `'compressed'` or`'uncompressed'`. If `format` is not specified, the point will be returned in`'uncompressed'` format.
			
 
				+         *
			
 
				+         * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned.
			
 
				+         * @since v0.11.14
			
 
				+         * @param encoding The `encoding` of the return value.
			
 
				+         * @param [format='uncompressed']
			
 
				+         */
			
 
				+        generateKeys(): Buffer;
			
 
				+        generateKeys(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
			
 
				+        /**
			
 
				+         * Computes the shared secret using `otherPublicKey` as the other
			
 
				+         * party's public key and returns the computed shared secret. The supplied
			
 
				+         * key is interpreted using specified `inputEncoding`, and the returned secret
			
 
				+         * is encoded using the specified `outputEncoding`.
			
 
				+         * If the `inputEncoding` is not
			
 
				+         * provided, `otherPublicKey` is expected to be a `Buffer`, `TypedArray`, or`DataView`.
			
 
				+         *
			
 
				+         * If `outputEncoding` is given a string will be returned; otherwise a `Buffer` is returned.
			
 
				+         *
			
 
				+         * `ecdh.computeSecret` will throw an`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY` error when `otherPublicKey`lies outside of the elliptic curve. Since `otherPublicKey` is
			
 
				+         * usually supplied from a remote user over an insecure network,
			
 
				+         * be sure to handle this exception accordingly.
			
 
				+         * @since v0.11.14
			
 
				+         * @param inputEncoding The `encoding` of the `otherPublicKey` string.
			
 
				+         * @param outputEncoding The `encoding` of the return value.
			
 
				+         */
			
 
				+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView): Buffer;
			
 
				+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding): Buffer;
			
 
				+        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, outputEncoding: BinaryToTextEncoding): string;
			
 
				+        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding, outputEncoding: BinaryToTextEncoding): string;
			
 
				+        /**
			
 
				+         * If `encoding` is specified, a string is returned; otherwise a `Buffer` is
			
 
				+         * returned.
			
 
				+         * @since v0.11.14
			
 
				+         * @param encoding The `encoding` of the return value.
			
 
				+         * @return The EC Diffie-Hellman in the specified `encoding`.
			
 
				+         */
			
 
				+        getPrivateKey(): Buffer;
			
 
				+        getPrivateKey(encoding: BinaryToTextEncoding): string;
			
 
				+        /**
			
 
				+         * The `format` argument specifies point encoding and can be `'compressed'` or`'uncompressed'`. If `format` is not specified the point will be returned in`'uncompressed'` format.
			
 
				+         *
			
 
				+         * If `encoding` is specified, a string is returned; otherwise a `Buffer` is
			
 
				+         * returned.
			
 
				+         * @since v0.11.14
			
 
				+         * @param [encoding] The `encoding` of the return value.
			
 
				+         * @param [format='uncompressed']
			
 
				+         * @return The EC Diffie-Hellman public key in the specified `encoding` and `format`.
			
 
				+         */
			
 
				+        getPublicKey(encoding?: null, format?: ECDHKeyFormat): Buffer;
			
 
				+        getPublicKey(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
			
 
				+        /**
			
 
				+         * Sets the EC Diffie-Hellman private key.
			
 
				+         * If `encoding` is provided, `privateKey` is expected
			
 
				+         * to be a string; otherwise `privateKey` is expected to be a `Buffer`,`TypedArray`, or `DataView`.
			
 
				+         *
			
 
				+         * If `privateKey` is not valid for the curve specified when the `ECDH` object was
			
 
				+         * created, an error is thrown. Upon setting the private key, the associated
			
 
				+         * public point (key) is also generated and set in the `ECDH` object.
			
 
				+         * @since v0.11.14
			
 
				+         * @param encoding The `encoding` of the `privateKey` string.
			
 
				+         */
			
 
				+        setPrivateKey(privateKey: NodeJS.ArrayBufferView): void;
			
 
				+        setPrivateKey(privateKey: string, encoding: BinaryToTextEncoding): void;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Creates an Elliptic Curve Diffie-Hellman (`ECDH`) key exchange object using a
			
 
				+     * predefined curve specified by the `curveName` string. Use {@link getCurves} to obtain a list of available curve names. On recent
			
 
				+     * OpenSSL releases, `openssl ecparam -list_curves` will also display the name
			
 
				+     * and description of each available elliptic curve.
			
 
				+     * @since v0.11.14
			
 
				+     */
			
 
				+    function createECDH(curveName: string): ECDH;
			
 
				+    /**
			
 
				+     * This function is based on a constant-time algorithm.
			
 
				+     * Returns true if `a` is equal to `b`, without leaking timing information that
			
 
				+     * would allow an attacker to guess one of the values. This is suitable for
			
 
				+     * comparing HMAC digests or secret values like authentication cookies or [capability urls](https://www.w3.org/TR/capability-urls/).
			
 
				+     *
			
 
				+     * `a` and `b` must both be `Buffer`s, `TypedArray`s, or `DataView`s, and they
			
 
				+     * must have the same byte length. An error is thrown if `a` and `b` have
			
 
				+     * different byte lengths.
			
 
				+     *
			
 
				+     * If at least one of `a` and `b` is a `TypedArray` with more than one byte per
			
 
				+     * entry, such as `Uint16Array`, the result will be computed using the platform
			
 
				+     * byte order.
			
 
				+     *
			
 
				+     * Use of `crypto.timingSafeEqual` does not guarantee that the _surrounding_ code
			
 
				+     * is timing-safe. Care should be taken to ensure that the surrounding code does
			
 
				+     * not introduce timing vulnerabilities.
			
 
				+     * @since v6.6.0
			
 
				+     */
			
 
				+    function timingSafeEqual(a: NodeJS.ArrayBufferView, b: NodeJS.ArrayBufferView): boolean;
			
 
				+    /** @deprecated since v10.0.0 */
			
 
				+    const DEFAULT_ENCODING: BufferEncoding;
			
 
				+    type KeyType = 'rsa' | 'rsa-pss' | 'dsa' | 'ec' | 'ed25519' | 'ed448' | 'x25519' | 'x448';
			
 
				+    type KeyFormat = 'pem' | 'der' | 'jwk';
			
 
				+    interface BasePrivateKeyEncodingOptions<T extends KeyFormat> {
			
 
				+        format: T;
			
 
				+        cipher?: string | undefined;
			
 
				+        passphrase?: string | undefined;
			
 
				+    }
			
 
				+    interface KeyPairKeyObjectResult {
			
 
				+        publicKey: KeyObject;
			
 
				+        privateKey: KeyObject;
			
 
				+    }
			
 
				+    interface ED25519KeyPairKeyObjectOptions {}
			
 
				+    interface ED448KeyPairKeyObjectOptions {}
			
 
				+    interface X25519KeyPairKeyObjectOptions {}
			
 
				+    interface X448KeyPairKeyObjectOptions {}
			
 
				+    interface ECKeyPairKeyObjectOptions {
			
 
				+        /**
			
 
				+         * Name of the curve to use
			
 
				+         */
			
 
				+        namedCurve: string;
			
 
				+    }
			
 
				+    interface RSAKeyPairKeyObjectOptions {
			
 
				+        /**
			
 
				+         * Key size in bits
			
 
				+         */
			
 
				+        modulusLength: number;
			
 
				+        /**
			
 
				+         * Public exponent
			
 
				+         * @default 0x10001
			
 
				+         */
			
 
				+        publicExponent?: number | undefined;
			
 
				+    }
			
 
				+    interface RSAPSSKeyPairKeyObjectOptions {
			
 
				+        /**
			
 
				+         * Key size in bits
			
 
				+         */
			
 
				+        modulusLength: number;
			
 
				+        /**
			
 
				+         * Public exponent
			
 
				+         * @default 0x10001
			
 
				+         */
			
 
				+        publicExponent?: number | undefined;
			
 
				+        /**
			
 
				+         * Name of the message digest
			
 
				+         */
			
 
				+        hashAlgorithm?: string;
			
 
				+        /**
			
 
				+         * Name of the message digest used by MGF1
			
 
				+         */
			
 
				+        mgf1HashAlgorithm?: string;
			
 
				+        /**
			
 
				+         * Minimal salt length in bytes
			
 
				+         */
			
 
				+        saltLength?: string;
			
 
				+    }
			
 
				+    interface DSAKeyPairKeyObjectOptions {
			
 
				+        /**
			
 
				+         * Key size in bits
			
 
				+         */
			
 
				+        modulusLength: number;
			
 
				+        /**
			
 
				+         * Size of q in bits
			
 
				+         */
			
 
				+        divisorLength: number;
			
 
				+    }
			
 
				+    interface RSAKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
			
 
				+        /**
			
 
				+         * Key size in bits
			
 
				+         */
			
 
				+        modulusLength: number;
			
 
				+        /**
			
 
				+         * Public exponent
			
 
				+         * @default 0x10001
			
 
				+         */
			
 
				+        publicExponent?: number | undefined;
			
 
				+        publicKeyEncoding: {
			
 
				+            type: 'pkcs1' | 'spki';
			
 
				+            format: PubF;
			
 
				+        };
			
 
				+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
			
 
				+            type: 'pkcs1' | 'pkcs8';
			
 
				+        };
			
 
				+    }
			
 
				+    interface RSAPSSKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
			
 
				+        /**
			
 
				+         * Key size in bits
			
 
				+         */
			
 
				+        modulusLength: number;
			
 
				+        /**
			
 
				+         * Public exponent
			
 
				+         * @default 0x10001
			
 
				+         */
			
 
				+        publicExponent?: number | undefined;
			
 
				+        /**
			
 
				+         * Name of the message digest
			
 
				+         */
			
 
				+        hashAlgorithm?: string;
			
 
				+        /**
			
 
				+         * Name of the message digest used by MGF1
			
 
				+         */
			
 
				+        mgf1HashAlgorithm?: string;
			
 
				+        /**
			
 
				+         * Minimal salt length in bytes
			
 
				+         */
			
 
				+        saltLength?: string;
			
 
				+        publicKeyEncoding: {
			
 
				+            type: 'spki';
			
 
				+            format: PubF;
			
 
				+        };
			
 
				+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
			
 
				+            type: 'pkcs8';
			
 
				+        };
			
 
				+    }
			
 
				+    interface DSAKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
			
 
				+        /**
			
 
				+         * Key size in bits
			
 
				+         */
			
 
				+        modulusLength: number;
			
 
				+        /**
			
 
				+         * Size of q in bits
			
 
				+         */
			
 
				+        divisorLength: number;
			
 
				+        publicKeyEncoding: {
			
 
				+            type: 'spki';
			
 
				+            format: PubF;
			
 
				+        };
			
 
				+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
			
 
				+            type: 'pkcs8';
			
 
				+        };
			
 
				+    }
			
 
				+    interface ECKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
			
 
				+        /**
			
 
				+         * Name of the curve to use.
			
 
				+         */
			
 
				+        namedCurve: string;
			
 
				+        publicKeyEncoding: {
			
 
				+            type: 'pkcs1' | 'spki';
			
 
				+            format: PubF;
			
 
				+        };
			
 
				+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
			
 
				+            type: 'sec1' | 'pkcs8';
			
 
				+        };
			
 
				+    }
			
 
				+    interface ED25519KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
			
 
				+        publicKeyEncoding: {
			
 
				+            type: 'spki';
			
 
				+            format: PubF;
			
 
				+        };
			
 
				+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
			
 
				+            type: 'pkcs8';
			
 
				+        };
			
 
				+    }
			
 
				+    interface ED448KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
			
 
				+        publicKeyEncoding: {
			
 
				+            type: 'spki';
			
 
				+            format: PubF;
			
 
				+        };
			
 
				+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
			
 
				+            type: 'pkcs8';
			
 
				+        };
			
 
				+    }
			
 
				+    interface X25519KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
			
 
				+        publicKeyEncoding: {
			
 
				+            type: 'spki';
			
 
				+            format: PubF;
			
 
				+        };
			
 
				+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
			
 
				+            type: 'pkcs8';
			
 
				+        };
			
 
				+    }
			
 
				+    interface X448KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
			
 
				+        publicKeyEncoding: {
			
 
				+            type: 'spki';
			
 
				+            format: PubF;
			
 
				+        };
			
 
				+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
			
 
				+            type: 'pkcs8';
			
 
				+        };
			
 
				+    }
			
 
				+    interface KeyPairSyncResult<T1 extends string | Buffer, T2 extends string | Buffer> {
			
 
				+        publicKey: T1;
			
 
				+        privateKey: T2;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
			
 
				+     * Ed25519, Ed448, X25519, X448, and DH are currently supported.
			
 
				+     *
			
 
				+     * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
			
 
				+     * behaves as if `keyObject.export()` had been called on its result. Otherwise,
			
 
				+     * the respective part of the key is returned as a `KeyObject`.
			
 
				+     *
			
 
				+     * When encoding public keys, it is recommended to use `'spki'`. When encoding
			
 
				+     * private keys, it is recommended to use `'pkcs8'` with a strong passphrase,
			
 
				+     * and to keep the passphrase confidential.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   generateKeyPairSync
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const {
			
 
				+     *   publicKey,
			
 
				+     *   privateKey,
			
 
				+     * } = generateKeyPairSync('rsa', {
			
 
				+     *   modulusLength: 4096,
			
 
				+     *   publicKeyEncoding: {
			
 
				+     *     type: 'spki',
			
 
				+     *     format: 'pem'
			
 
				+     *   },
			
 
				+     *   privateKeyEncoding: {
			
 
				+     *     type: 'pkcs8',
			
 
				+     *     format: 'pem',
			
 
				+     *     cipher: 'aes-256-cbc',
			
 
				+     *     passphrase: 'top secret'
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The return value `{ publicKey, privateKey }` represents the generated key pair.
			
 
				+     * When PEM encoding was selected, the respective key will be a string, otherwise
			
 
				+     * it will be a buffer containing the data encoded as DER.
			
 
				+     * @since v10.12.0
			
 
				+     * @param type Must be `'rsa'`, `'rsa-pss'`, `'dsa'`, `'ec'`, `'ed25519'`, `'ed448'`, `'x25519'`, `'x448'`, or `'dh'`.
			
 
				+     */
			
 
				+    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
			
 
				+    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
			
 
				+    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
			
 
				+    function generateKeyPairSync(type: 'rsa-pss', options: RSAPSSKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
			
 
				+    function generateKeyPairSync(type: 'rsa-pss', options: RSAPSSKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'rsa-pss', options: RSAPSSKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
			
 
				+    function generateKeyPairSync(type: 'rsa-pss', options: RSAPSSKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'rsa-pss', options: RSAPSSKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
			
 
				+    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
			
 
				+    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
			
 
				+    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
			
 
				+    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
			
 
				+    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
			
 
				+    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'ec', options: ECKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
			
 
				+    function generateKeyPairSync(type: 'ed25519', options: ED25519KeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
			
 
				+    function generateKeyPairSync(type: 'ed25519', options: ED25519KeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'ed25519', options: ED25519KeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
			
 
				+    function generateKeyPairSync(type: 'ed25519', options: ED25519KeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'ed25519', options?: ED25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
			
 
				+    function generateKeyPairSync(type: 'ed448', options: ED448KeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
			
 
				+    function generateKeyPairSync(type: 'ed448', options: ED448KeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'ed448', options: ED448KeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
			
 
				+    function generateKeyPairSync(type: 'ed448', options: ED448KeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'ed448', options?: ED448KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
			
 
				+    function generateKeyPairSync(type: 'x25519', options: X25519KeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
			
 
				+    function generateKeyPairSync(type: 'x25519', options: X25519KeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'x25519', options: X25519KeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
			
 
				+    function generateKeyPairSync(type: 'x25519', options: X25519KeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'x25519', options?: X25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
			
 
				+    function generateKeyPairSync(type: 'x448', options: X448KeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
			
 
				+    function generateKeyPairSync(type: 'x448', options: X448KeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'x448', options: X448KeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
			
 
				+    function generateKeyPairSync(type: 'x448', options: X448KeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
			
 
				+    function generateKeyPairSync(type: 'x448', options?: X448KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
			
 
				+    /**
			
 
				+     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
			
 
				+     * Ed25519, Ed448, X25519, X448, and DH are currently supported.
			
 
				+     *
			
 
				+     * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
			
 
				+     * behaves as if `keyObject.export()` had been called on its result. Otherwise,
			
 
				+     * the respective part of the key is returned as a `KeyObject`.
			
 
				+     *
			
 
				+     * It is recommended to encode public keys as `'spki'` and private keys as`'pkcs8'` with encryption for long-term storage:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const {
			
 
				+     *   generateKeyPair
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * generateKeyPair('rsa', {
			
 
				+     *   modulusLength: 4096,
			
 
				+     *   publicKeyEncoding: {
			
 
				+     *     type: 'spki',
			
 
				+     *     format: 'pem'
			
 
				+     *   },
			
 
				+     *   privateKeyEncoding: {
			
 
				+     *     type: 'pkcs8',
			
 
				+     *     format: 'pem',
			
 
				+     *     cipher: 'aes-256-cbc',
			
 
				+     *     passphrase: 'top secret'
			
 
				+     *   }
			
 
				+     * }, (err, publicKey, privateKey) => {
			
 
				+     *   // Handle errors and use the generated key pair.
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * On completion, `callback` will be called with `err` set to `undefined` and`publicKey` / `privateKey` representing the generated key pair.
			
 
				+     *
			
 
				+     * If this method is invoked as its `util.promisify()` ed version, it returns
			
 
				+     * a `Promise` for an `Object` with `publicKey` and `privateKey` properties.
			
 
				+     * @since v10.12.0
			
 
				+     * @param type Must be `'rsa'`, `'rsa-pss'`, `'dsa'`, `'ec'`, `'ed25519'`, `'ed448'`, `'x25519'`, `'x448'`, or `'dh'`.
			
 
				+     */
			
 
				+    function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'rsa', options: RSAKeyPairKeyObjectOptions, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
			
 
				+    function generateKeyPair(type: 'rsa-pss', options: RSAPSSKeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'rsa-pss', options: RSAPSSKeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'rsa-pss', options: RSAPSSKeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'rsa-pss', options: RSAPSSKeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'rsa-pss', options: RSAPSSKeyPairKeyObjectOptions, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
			
 
				+    function generateKeyPair(type: 'dsa', options: DSAKeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'dsa', options: DSAKeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'dsa', options: DSAKeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'dsa', options: DSAKeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'dsa', options: DSAKeyPairKeyObjectOptions, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
			
 
				+    function generateKeyPair(type: 'ec', options: ECKeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'ec', options: ECKeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'ec', options: ECKeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'ec', options: ECKeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'ec', options: ECKeyPairKeyObjectOptions, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
			
 
				+    function generateKeyPair(type: 'ed25519', options: ED25519KeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'ed25519', options: ED25519KeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'ed25519', options: ED25519KeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'ed25519', options: ED25519KeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'ed25519', options: ED25519KeyPairKeyObjectOptions | undefined, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
			
 
				+    function generateKeyPair(type: 'ed448', options: ED448KeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'ed448', options: ED448KeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'ed448', options: ED448KeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'ed448', options: ED448KeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'ed448', options: ED448KeyPairKeyObjectOptions | undefined, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
			
 
				+    function generateKeyPair(type: 'x25519', options: X25519KeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'x25519', options: X25519KeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'x25519', options: X25519KeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'x25519', options: X25519KeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'x25519', options: X25519KeyPairKeyObjectOptions | undefined, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
			
 
				+    function generateKeyPair(type: 'x448', options: X448KeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'x448', options: X448KeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'x448', options: X448KeyPairOptions<'der', 'pem'>, callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void): void;
			
 
				+    function generateKeyPair(type: 'x448', options: X448KeyPairOptions<'der', 'der'>, callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void): void;
			
 
				+    function generateKeyPair(type: 'x448', options: X448KeyPairKeyObjectOptions | undefined, callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
			
 
				+    namespace generateKeyPair {
			
 
				+        function __promisify__(
			
 
				+            type: 'rsa',
			
 
				+            options: RSAKeyPairOptions<'pem', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'rsa',
			
 
				+            options: RSAKeyPairOptions<'pem', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'rsa',
			
 
				+            options: RSAKeyPairOptions<'der', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'rsa',
			
 
				+            options: RSAKeyPairOptions<'der', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(type: 'rsa', options: RSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
			
 
				+        function __promisify__(
			
 
				+            type: 'rsa-pss',
			
 
				+            options: RSAPSSKeyPairOptions<'pem', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'rsa-pss',
			
 
				+            options: RSAPSSKeyPairOptions<'pem', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'rsa-pss',
			
 
				+            options: RSAPSSKeyPairOptions<'der', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'rsa-pss',
			
 
				+            options: RSAPSSKeyPairOptions<'der', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(type: 'rsa-pss', options: RSAPSSKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
			
 
				+        function __promisify__(
			
 
				+            type: 'dsa',
			
 
				+            options: DSAKeyPairOptions<'pem', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'dsa',
			
 
				+            options: DSAKeyPairOptions<'pem', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'dsa',
			
 
				+            options: DSAKeyPairOptions<'der', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'dsa',
			
 
				+            options: DSAKeyPairOptions<'der', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(type: 'dsa', options: DSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ec',
			
 
				+            options: ECKeyPairOptions<'pem', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ec',
			
 
				+            options: ECKeyPairOptions<'pem', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ec',
			
 
				+            options: ECKeyPairOptions<'der', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ec',
			
 
				+            options: ECKeyPairOptions<'der', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(type: 'ec', options: ECKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ed25519',
			
 
				+            options: ED25519KeyPairOptions<'pem', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ed25519',
			
 
				+            options: ED25519KeyPairOptions<'pem', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ed25519',
			
 
				+            options: ED25519KeyPairOptions<'der', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ed25519',
			
 
				+            options: ED25519KeyPairOptions<'der', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(type: 'ed25519', options?: ED25519KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ed448',
			
 
				+            options: ED448KeyPairOptions<'pem', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ed448',
			
 
				+            options: ED448KeyPairOptions<'pem', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ed448',
			
 
				+            options: ED448KeyPairOptions<'der', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'ed448',
			
 
				+            options: ED448KeyPairOptions<'der', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(type: 'ed448', options?: ED448KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
			
 
				+        function __promisify__(
			
 
				+            type: 'x25519',
			
 
				+            options: X25519KeyPairOptions<'pem', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'x25519',
			
 
				+            options: X25519KeyPairOptions<'pem', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'x25519',
			
 
				+            options: X25519KeyPairOptions<'der', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'x25519',
			
 
				+            options: X25519KeyPairOptions<'der', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(type: 'x25519', options?: X25519KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
			
 
				+        function __promisify__(
			
 
				+            type: 'x448',
			
 
				+            options: X448KeyPairOptions<'pem', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'x448',
			
 
				+            options: X448KeyPairOptions<'pem', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: string;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'x448',
			
 
				+            options: X448KeyPairOptions<'der', 'pem'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: string;
			
 
				+        }>;
			
 
				+        function __promisify__(
			
 
				+            type: 'x448',
			
 
				+            options: X448KeyPairOptions<'der', 'der'>
			
 
				+        ): Promise<{
			
 
				+            publicKey: Buffer;
			
 
				+            privateKey: Buffer;
			
 
				+        }>;
			
 
				+        function __promisify__(type: 'x448', options?: X448KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Calculates and returns the signature for `data` using the given private key and
			
 
				+     * algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is
			
 
				+     * dependent upon the key type (especially Ed25519 and Ed448).
			
 
				+     *
			
 
				+     * If `key` is not a `KeyObject`, this function behaves as if `key` had been
			
 
				+     * passed to {@link createPrivateKey}. If it is an object, the following
			
 
				+     * additional properties can be passed:
			
 
				+     *
			
 
				+     * If the `callback` function is provided this function uses libuv's threadpool.
			
 
				+     * @since v12.0.0
			
 
				+     */
			
 
				+    function sign(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput): Buffer;
			
 
				+    function sign(
			
 
				+        algorithm: string | null | undefined,
			
 
				+        data: NodeJS.ArrayBufferView,
			
 
				+        key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput,
			
 
				+        callback: (error: Error | null, data: Buffer) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Verifies the given signature for `data` using the given key and algorithm. If`algorithm` is `null` or `undefined`, then the algorithm is dependent upon the
			
 
				+     * key type (especially Ed25519 and Ed448).
			
 
				+     *
			
 
				+     * If `key` is not a `KeyObject`, this function behaves as if `key` had been
			
 
				+     * passed to {@link createPublicKey}. If it is an object, the following
			
 
				+     * additional properties can be passed:
			
 
				+     *
			
 
				+     * The `signature` argument is the previously calculated signature for the `data`.
			
 
				+     *
			
 
				+     * Because public keys can be derived from private keys, a private key or a public
			
 
				+     * key may be passed for `key`.
			
 
				+     *
			
 
				+     * If the `callback` function is provided this function uses libuv's threadpool.
			
 
				+     * @since v12.0.0
			
 
				+     */
			
 
				+    function verify(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, signature: NodeJS.ArrayBufferView): boolean;
			
 
				+    function verify(
			
 
				+        algorithm: string | null | undefined,
			
 
				+        data: NodeJS.ArrayBufferView,
			
 
				+        key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput,
			
 
				+        signature: NodeJS.ArrayBufferView,
			
 
				+        callback: (error: Error | null, result: boolean) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Computes the Diffie-Hellman secret based on a `privateKey` and a `publicKey`.
			
 
				+     * Both keys must have the same `asymmetricKeyType`, which must be one of `'dh'`(for Diffie-Hellman), `'ec'` (for ECDH), `'x448'`, or `'x25519'` (for ECDH-ES).
			
 
				+     * @since v13.9.0, v12.17.0
			
 
				+     */
			
 
				+    function diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject }): Buffer;
			
 
				+    type CipherMode = 'cbc' | 'ccm' | 'cfb' | 'ctr' | 'ecb' | 'gcm' | 'ocb' | 'ofb' | 'stream' | 'wrap' | 'xts';
			
 
				+    interface CipherInfoOptions {
			
 
				+        /**
			
 
				+         * A test key length.
			
 
				+         */
			
 
				+        keyLength?: number | undefined;
			
 
				+        /**
			
 
				+         * A test IV length.
			
 
				+         */
			
 
				+        ivLength?: number | undefined;
			
 
				+    }
			
 
				+    interface CipherInfo {
			
 
				+        /**
			
 
				+         * The name of the cipher.
			
 
				+         */
			
 
				+        name: string;
			
 
				+        /**
			
 
				+         * The nid of the cipher.
			
 
				+         */
			
 
				+        nid: number;
			
 
				+        /**
			
 
				+         * The block size of the cipher in bytes.
			
 
				+         * This property is omitted when mode is 'stream'.
			
 
				+         */
			
 
				+        blockSize?: number | undefined;
			
 
				+        /**
			
 
				+         * The expected or default initialization vector length in bytes.
			
 
				+         * This property is omitted if the cipher does not use an initialization vector.
			
 
				+         */
			
 
				+        ivLength?: number | undefined;
			
 
				+        /**
			
 
				+         * The expected or default key length in bytes.
			
 
				+         */
			
 
				+        keyLength: number;
			
 
				+        /**
			
 
				+         * The cipher mode.
			
 
				+         */
			
 
				+        mode: CipherMode;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns information about a given cipher.
			
 
				+     *
			
 
				+     * Some ciphers accept variable length keys and initialization vectors. By default,
			
 
				+     * the `crypto.getCipherInfo()` method will return the default values for these
			
 
				+     * ciphers. To test if a given key length or iv length is acceptable for given
			
 
				+     * cipher, use the `keyLength` and `ivLength` options. If the given values are
			
 
				+     * unacceptable, `undefined` will be returned.
			
 
				+     * @since v15.0.0
			
 
				+     * @param nameOrNid The name or nid of the cipher to query.
			
 
				+     */
			
 
				+    function getCipherInfo(nameOrNid: string | number, options?: CipherInfoOptions): CipherInfo | undefined;
			
 
				+    /**
			
 
				+     * HKDF is a simple key derivation function defined in RFC 5869\. The given `ikm`,`salt` and `info` are used with the `digest` to derive a key of `keylen` bytes.
			
 
				+     *
			
 
				+     * The supplied `callback` function is called with two arguments: `err` and`derivedKey`. If an errors occurs while deriving the key, `err` will be set;
			
 
				+     * otherwise `err` will be `null`. The successfully generated `derivedKey` will
			
 
				+     * be passed to the callback as an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). An error will be thrown if any
			
 
				+     * of the input arguments specify invalid values or types.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     * const {
			
 
				+     *   hkdf
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v15.0.0
			
 
				+     * @param digest The digest algorithm to use.
			
 
				+     * @param ikm The input keying material. It must be at least one byte in length.
			
 
				+     * @param salt The salt value. Must be provided but can be zero-length.
			
 
				+     * @param info Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes.
			
 
				+     * @param keylen The length of the key to generate. Must be greater than 0. The maximum allowable value is `255` times the number of bytes produced by the selected digest function (e.g. `sha512`
			
 
				+     * generates 64-byte hashes, making the maximum HKDF output 16320 bytes).
			
 
				+     */
			
 
				+    function hkdf(digest: string, irm: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: ArrayBuffer) => void): void;
			
 
				+    /**
			
 
				+     * Provides a synchronous HKDF key derivation function as defined in RFC 5869\. The
			
 
				+     * given `ikm`, `salt` and `info` are used with the `digest` to derive a key of`keylen` bytes.
			
 
				+     *
			
 
				+     * The successfully generated `derivedKey` will be returned as an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
			
 
				+     *
			
 
				+     * An error will be thrown if any of the input arguments specify invalid values or
			
 
				+     * types, or if the derived key cannot be generated.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     * const {
			
 
				+     *   hkdfSync
			
 
				+     * } = await import('crypto');
			
 
				+     *
			
 
				+     * const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
			
 
				+     * console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
			
 
				+     * ```
			
 
				+     * @since v15.0.0
			
 
				+     * @param digest The digest algorithm to use.
			
 
				+     * @param ikm The input keying material. It must be at least one byte in length.
			
 
				+     * @param salt The salt value. Must be provided but can be zero-length.
			
 
				+     * @param info Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes.
			
 
				+     * @param keylen The length of the key to generate. Must be greater than 0. The maximum allowable value is `255` times the number of bytes produced by the selected digest function (e.g. `sha512`
			
 
				+     * generates 64-byte hashes, making the maximum HKDF output 16320 bytes).
			
 
				+     */
			
 
				+    function hkdfSync(digest: string, ikm: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number): ArrayBuffer;
			
 
				+    interface SecureHeapUsage {
			
 
				+        /**
			
 
				+         * The total allocated secure heap size as specified using the `--secure-heap=n` command-line flag.
			
 
				+         */
			
 
				+        total: number;
			
 
				+        /**
			
 
				+         * The minimum allocation from the secure heap as specified using the `--secure-heap-min` command-line flag.
			
 
				+         */
			
 
				+        min: number;
			
 
				+        /**
			
 
				+         * The total number of bytes currently allocated from the secure heap.
			
 
				+         */
			
 
				+        used: number;
			
 
				+        /**
			
 
				+         * The calculated ratio of `used` to `total` allocated bytes.
			
 
				+         */
			
 
				+        utilization: number;
			
 
				+    }
			
 
				+    /**
			
 
				+     * @since v15.6.0
			
 
				+     */
			
 
				+    function secureHeapUsed(): SecureHeapUsage;
			
 
				+    interface RandomUUIDOptions {
			
 
				+        /**
			
 
				+         * By default, to improve performance,
			
 
				+         * Node.js will pre-emptively generate and persistently cache enough
			
 
				+         * random data to generate up to 128 random UUIDs. To generate a UUID
			
 
				+         * without using the cache, set `disableEntropyCache` to `true`.
			
 
				+         *
			
 
				+         * @default `false`
			
 
				+         */
			
 
				+        disableEntropyCache?: boolean | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Generates a random [RFC 4122](https://www.rfc-editor.org/rfc/rfc4122.txt) version 4 UUID. The UUID is generated using a
			
 
				+     * cryptographic pseudorandom number generator.
			
 
				+     * @since v15.6.0, v14.17.0
			
 
				+     */
			
 
				+    function randomUUID(options?: RandomUUIDOptions): string;
			
 
				+    interface X509CheckOptions {
			
 
				+        /**
			
 
				+         * @default 'always'
			
 
				+         */
			
 
				+        subject?: 'always' | 'default' | 'never';
			
 
				+        /**
			
 
				+         * @default true
			
 
				+         */
			
 
				+        wildcards?: boolean;
			
 
				+        /**
			
 
				+         * @default true
			
 
				+         */
			
 
				+        partialWildcards?: boolean;
			
 
				+        /**
			
 
				+         * @default false
			
 
				+         */
			
 
				+        multiLabelWildcards?: boolean;
			
 
				+        /**
			
 
				+         * @default false
			
 
				+         */
			
 
				+        singleLabelSubdomains?: boolean;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Encapsulates an X509 certificate and provides read-only access to
			
 
				+     * its information.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { X509Certificate } = await import('crypto');
			
 
				+     *
			
 
				+     * const x509 = new X509Certificate('{... pem encoded cert ...}');
			
 
				+     *
			
 
				+     * console.log(x509.subject);
			
 
				+     * ```
			
 
				+     * @since v15.6.0
			
 
				+     */
			
 
				+    class X509Certificate {
			
 
				+        /**
			
 
				+         * Will be \`true\` if this is a Certificate Authority (CA) certificate.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly ca: boolean;
			
 
				+        /**
			
 
				+         * The SHA-1 fingerprint of this certificate.
			
 
				+         *
			
 
				+         * Because SHA-1 is cryptographically broken and because the security of SHA-1 is
			
 
				+         * significantly worse than that of algorithms that are commonly used to sign
			
 
				+         * certificates, consider using `x509.fingerprint256` instead.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly fingerprint: string;
			
 
				+        /**
			
 
				+         * The SHA-256 fingerprint of this certificate.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly fingerprint256: string;
			
 
				+        /**
			
 
				+         * The SHA-512 fingerprint of this certificate.
			
 
				+         * @since v16.14.0
			
 
				+         */
			
 
				+         readonly fingerprint512: string;
			
 
				+        /**
			
 
				+         * The complete subject of this certificate.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly subject: string;
			
 
				+        /**
			
 
				+         * The subject alternative name specified for this certificate or `undefined`
			
 
				+         * if not available.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly subjectAltName: string | undefined;
			
 
				+        /**
			
 
				+         * The information access content of this certificate or `undefined` if not
			
 
				+         * available.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly infoAccess: string | undefined;
			
 
				+        /**
			
 
				+         * An array detailing the key usages for this certificate.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly keyUsage: string[];
			
 
				+        /**
			
 
				+         * The issuer identification included in this certificate.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly issuer: string;
			
 
				+        /**
			
 
				+         * The issuer certificate or `undefined` if the issuer certificate is not
			
 
				+         * available.
			
 
				+         * @since v15.9.0
			
 
				+         */
			
 
				+        readonly issuerCertificate?: X509Certificate | undefined;
			
 
				+        /**
			
 
				+         * The public key `KeyObject` for this certificate.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly publicKey: KeyObject;
			
 
				+        /**
			
 
				+         * A `Buffer` containing the DER encoding of this certificate.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly raw: Buffer;
			
 
				+        /**
			
 
				+         * The serial number of this certificate.
			
 
				+         *
			
 
				+         * Serial numbers are assigned by certificate authorities and do not uniquely
			
 
				+         * identify certificates. Consider using `x509.fingerprint256` as a unique
			
 
				+         * identifier instead.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly serialNumber: string;
			
 
				+        /**
			
 
				+         * The date/time from which this certificate is considered valid.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly validFrom: string;
			
 
				+        /**
			
 
				+         * The date/time until which this certificate is considered valid.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        readonly validTo: string;
			
 
				+        constructor(buffer: BinaryLike);
			
 
				+        /**
			
 
				+         * Checks whether the certificate matches the given email address.
			
 
				+         *
			
 
				+         * If the `'subject'` option is undefined or set to `'default'`, the certificate
			
 
				+         * subject is only considered if the subject alternative name extension either does
			
 
				+         * not exist or does not contain any email addresses.
			
 
				+         *
			
 
				+         * If the `'subject'` option is set to `'always'` and if the subject alternative
			
 
				+         * name extension either does not exist or does not contain a matching email
			
 
				+         * address, the certificate subject is considered.
			
 
				+         *
			
 
				+         * If the `'subject'` option is set to `'never'`, the certificate subject is never
			
 
				+         * considered, even if the certificate contains no subject alternative names.
			
 
				+         * @since v15.6.0
			
 
				+         * @return Returns `email` if the certificate matches, `undefined` if it does not.
			
 
				+         */
			
 
				+        checkEmail(email: string, options?: Pick<X509CheckOptions, 'subject'>): string | undefined;
			
 
				+        /**
			
 
				+         * Checks whether the certificate matches the given host name.
			
 
				+         *
			
 
				+         * If the certificate matches the given host name, the matching subject name is
			
 
				+         * returned. The returned name might be an exact match (e.g., `foo.example.com`)
			
 
				+         * or it might contain wildcards (e.g., `*.example.com`). Because host name
			
 
				+         * comparisons are case-insensitive, the returned subject name might also differ
			
 
				+         * from the given `name` in capitalization.
			
 
				+         *
			
 
				+         * If the `'subject'` option is undefined or set to `'default'`, the certificate
			
 
				+         * subject is only considered if the subject alternative name extension either does
			
 
				+         * not exist or does not contain any DNS names. This behavior is consistent with [RFC 2818](https://www.rfc-editor.org/rfc/rfc2818.txt) ("HTTP Over TLS").
			
 
				+         *
			
 
				+         * If the `'subject'` option is set to `'always'` and if the subject alternative
			
 
				+         * name extension either does not exist or does not contain a matching DNS name,
			
 
				+         * the certificate subject is considered.
			
 
				+         *
			
 
				+         * If the `'subject'` option is set to `'never'`, the certificate subject is never
			
 
				+         * considered, even if the certificate contains no subject alternative names.
			
 
				+         * @since v15.6.0
			
 
				+         * @return Returns a subject name that matches `name`, or `undefined` if no subject name matches `name`.
			
 
				+         */
			
 
				+        checkHost(name: string, options?: X509CheckOptions): string | undefined;
			
 
				+        /**
			
 
				+         * Checks whether the certificate matches the given IP address (IPv4 or IPv6).
			
 
				+         *
			
 
				+         * Only [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280.txt) `iPAddress` subject alternative names are considered, and they
			
 
				+         * must match the given `ip` address exactly. Other subject alternative names as
			
 
				+         * well as the subject field of the certificate are ignored.
			
 
				+         * @since v15.6.0
			
 
				+         * @return Returns `ip` if the certificate matches, `undefined` if it does not.
			
 
				+         */
			
 
				+        checkIP(ip: string): string | undefined;
			
 
				+        /**
			
 
				+         * Checks whether this certificate was issued by the given `otherCert`.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        checkIssued(otherCert: X509Certificate): boolean;
			
 
				+        /**
			
 
				+         * Checks whether the public key for this certificate is consistent with
			
 
				+         * the given private key.
			
 
				+         * @since v15.6.0
			
 
				+         * @param privateKey A private key.
			
 
				+         */
			
 
				+        checkPrivateKey(privateKey: KeyObject): boolean;
			
 
				+        /**
			
 
				+         * There is no standard JSON encoding for X509 certificates. The`toJSON()` method returns a string containing the PEM encoded
			
 
				+         * certificate.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        toJSON(): string;
			
 
				+        /**
			
 
				+         * Returns information about this certificate using the legacy `certificate object` encoding.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        toLegacyObject(): PeerCertificate;
			
 
				+        /**
			
 
				+         * Returns the PEM-encoded certificate.
			
 
				+         * @since v15.6.0
			
 
				+         */
			
 
				+        toString(): string;
			
 
				+        /**
			
 
				+         * Verifies that this certificate was signed by the given public key.
			
 
				+         * Does not perform any other validation checks on the certificate.
			
 
				+         * @since v15.6.0
			
 
				+         * @param publicKey A public key.
			
 
				+         */
			
 
				+        verify(publicKey: KeyObject): boolean;
			
 
				+    }
			
 
				+    type LargeNumberLike = NodeJS.ArrayBufferView | SharedArrayBuffer | ArrayBuffer | bigint;
			
 
				+    interface GeneratePrimeOptions {
			
 
				+        add?: LargeNumberLike | undefined;
			
 
				+        rem?: LargeNumberLike | undefined;
			
 
				+        /**
			
 
				+         * @default false
			
 
				+         */
			
 
				+        safe?: boolean | undefined;
			
 
				+        bigint?: boolean | undefined;
			
 
				+    }
			
 
				+    interface GeneratePrimeOptionsBigInt extends GeneratePrimeOptions {
			
 
				+        bigint: true;
			
 
				+    }
			
 
				+    interface GeneratePrimeOptionsArrayBuffer extends GeneratePrimeOptions {
			
 
				+        bigint?: false | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Generates a pseudorandom prime of `size` bits.
			
 
				+     *
			
 
				+     * If `options.safe` is `true`, the prime will be a safe prime -- that is,`(prime - 1) / 2` will also be a prime.
			
 
				+     *
			
 
				+     * The `options.add` and `options.rem` parameters can be used to enforce additional
			
 
				+     * requirements, e.g., for Diffie-Hellman:
			
 
				+     *
			
 
				+     * * If `options.add` and `options.rem` are both set, the prime will satisfy the
			
 
				+     * condition that `prime % add = rem`.
			
 
				+     * * If only `options.add` is set and `options.safe` is not `true`, the prime will
			
 
				+     * satisfy the condition that `prime % add = 1`.
			
 
				+     * * If only `options.add` is set and `options.safe` is set to `true`, the prime
			
 
				+     * will instead satisfy the condition that `prime % add = 3`. This is necessary
			
 
				+     * because `prime % add = 1` for `options.add > 2` would contradict the condition
			
 
				+     * enforced by `options.safe`.
			
 
				+     * * `options.rem` is ignored if `options.add` is not given.
			
 
				+     *
			
 
				+     * Both `options.add` and `options.rem` must be encoded as big-endian sequences
			
 
				+     * if given as an `ArrayBuffer`, `SharedArrayBuffer`, `TypedArray`, `Buffer`, or`DataView`.
			
 
				+     *
			
 
				+     * By default, the prime is encoded as a big-endian sequence of octets
			
 
				+     * in an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). If the `bigint` option is `true`, then a
			
 
				+     * [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) is provided.
			
 
				+     * @since v15.8.0
			
 
				+     * @param size The size (in bits) of the prime to generate.
			
 
				+     */
			
 
				+    function generatePrime(size: number, callback: (err: Error | null, prime: ArrayBuffer) => void): void;
			
 
				+    function generatePrime(size: number, options: GeneratePrimeOptionsBigInt, callback: (err: Error | null, prime: bigint) => void): void;
			
 
				+    function generatePrime(size: number, options: GeneratePrimeOptionsArrayBuffer, callback: (err: Error | null, prime: ArrayBuffer) => void): void;
			
 
				+    function generatePrime(size: number, options: GeneratePrimeOptions, callback: (err: Error | null, prime: ArrayBuffer | bigint) => void): void;
			
 
				+    /**
			
 
				+     * Generates a pseudorandom prime of `size` bits.
			
 
				+     *
			
 
				+     * If `options.safe` is `true`, the prime will be a safe prime -- that is,`(prime - 1) / 2` will also be a prime.
			
 
				+     *
			
 
				+     * The `options.add` and `options.rem` parameters can be used to enforce additional
			
 
				+     * requirements, e.g., for Diffie-Hellman:
			
 
				+     *
			
 
				+     * * If `options.add` and `options.rem` are both set, the prime will satisfy the
			
 
				+     * condition that `prime % add = rem`.
			
 
				+     * * If only `options.add` is set and `options.safe` is not `true`, the prime will
			
 
				+     * satisfy the condition that `prime % add = 1`.
			
 
				+     * * If only `options.add` is set and `options.safe` is set to `true`, the prime
			
 
				+     * will instead satisfy the condition that `prime % add = 3`. This is necessary
			
 
				+     * because `prime % add = 1` for `options.add > 2` would contradict the condition
			
 
				+     * enforced by `options.safe`.
			
 
				+     * * `options.rem` is ignored if `options.add` is not given.
			
 
				+     *
			
 
				+     * Both `options.add` and `options.rem` must be encoded as big-endian sequences
			
 
				+     * if given as an `ArrayBuffer`, `SharedArrayBuffer`, `TypedArray`, `Buffer`, or`DataView`.
			
 
				+     *
			
 
				+     * By default, the prime is encoded as a big-endian sequence of octets
			
 
				+     * in an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). If the `bigint` option is `true`, then a
			
 
				+     * [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) is provided.
			
 
				+     * @since v15.8.0
			
 
				+     * @param size The size (in bits) of the prime to generate.
			
 
				+     */
			
 
				+    function generatePrimeSync(size: number): ArrayBuffer;
			
 
				+    function generatePrimeSync(size: number, options: GeneratePrimeOptionsBigInt): bigint;
			
 
				+    function generatePrimeSync(size: number, options: GeneratePrimeOptionsArrayBuffer): ArrayBuffer;
			
 
				+    function generatePrimeSync(size: number, options: GeneratePrimeOptions): ArrayBuffer | bigint;
			
 
				+    interface CheckPrimeOptions {
			
 
				+        /**
			
 
				+         * The number of Miller-Rabin probabilistic primality iterations to perform.
			
 
				+         * When the value is 0 (zero), a number of checks is used that yields a false positive rate of at most `2**-64` for random input.
			
 
				+         * Care must be used when selecting a number of checks.
			
 
				+         * Refer to the OpenSSL documentation for the BN_is_prime_ex function nchecks options for more details.
			
 
				+         *
			
 
				+         * @default 0
			
 
				+         */
			
 
				+        checks?: number | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Checks the primality of the `candidate`.
			
 
				+     * @since v15.8.0
			
 
				+     * @param candidate A possible prime encoded as a sequence of big endian octets of arbitrary length.
			
 
				+     */
			
 
				+    function checkPrime(value: LargeNumberLike, callback: (err: Error | null, result: boolean) => void): void;
			
 
				+    function checkPrime(value: LargeNumberLike, options: CheckPrimeOptions, callback: (err: Error | null, result: boolean) => void): void;
			
 
				+    /**
			
 
				+     * Checks the primality of the `candidate`.
			
 
				+     * @since v15.8.0
			
 
				+     * @param candidate A possible prime encoded as a sequence of big endian octets of arbitrary length.
			
 
				+     * @return `true` if the candidate is a prime with an error probability less than `0.25 ** options.checks`.
			
 
				+     */
			
 
				+    function checkPrimeSync(candidate: LargeNumberLike, options?: CheckPrimeOptions): boolean;
			
 
				+    /**
			
 
				+     * Load and set the `engine` for some or all OpenSSL functions (selected by flags).
			
 
				+     *
			
 
				+     * `engine` could be either an id or a path to the engine's shared library.
			
 
				+     *
			
 
				+     * The optional `flags` argument uses `ENGINE_METHOD_ALL` by default.
			
 
				+     * The `flags` is a bit field taking one of or a mix of the following flags (defined in `crypto.constants`):
			
 
				+     *
			
 
				+     * - `crypto.constants.ENGINE_METHOD_RSA`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_DSA`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_DH`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_RAND`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_EC`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_CIPHERS`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_DIGESTS`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_PKEY_METHS`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_PKEY_ASN1_METHS`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_ALL`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_NONE`
			
 
				+     *
			
 
				+     * The flags below are deprecated in OpenSSL-1.1.0.
			
 
				+     *
			
 
				+     * - `crypto.constants.ENGINE_METHOD_ECDH`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_ECDSA`
			
 
				+     * - `crypto.constants.ENGINE_METHOD_STORE`
			
 
				+     * @since v0.11.11
			
 
				+     * @param [flags=crypto.constants.ENGINE_METHOD_ALL]
			
 
				+     */
			
 
				+    function setEngine(engine: string, flags?: number): void;
			
 
				+    /**
			
 
				+     * A convenient alias for `crypto.webcrypto.getRandomValues()`.
			
 
				+     * This implementation is not compliant with the Web Crypto spec,
			
 
				+     * to write web-compatible code use `crypto.webcrypto.getRandomValues()` instead.
			
 
				+     * @since v17.4.0
			
 
				+     * @returns Returns `typedArray`.
			
 
				+     */
			
 
				+    function getRandomValues<T extends webcrypto.BufferSource>(typedArray: T): T;
			
 
				+    /**
			
 
				+     * A convenient alias for `crypto.webcrypto.subtle`.
			
 
				+     * @since v17.4.0
			
 
				+     */
			
 
				+    const subtle: webcrypto.SubtleCrypto;
			
 
				+    /**
			
 
				+     * An implementation of the Web Crypto API standard.
			
 
				+     *
			
 
				+     * See the {@link https://nodejs.org/docs/latest/api/webcrypto.html Web Crypto API documentation} for details.
			
 
				+     * @since v15.0.0
			
 
				+     */
			
 
				+    const webcrypto: webcrypto.Crypto;
			
 
				+    namespace webcrypto {
			
 
				+        type BufferSource = ArrayBufferView | ArrayBuffer;
			
 
				+        type KeyFormat = 'jwk' | 'pkcs8' | 'raw' | 'spki';
			
 
				+        type KeyType = 'private' | 'public' | 'secret';
			
 
				+        type KeyUsage = 'decrypt' | 'deriveBits' | 'deriveKey' | 'encrypt' | 'sign' | 'unwrapKey' | 'verify' | 'wrapKey';
			
 
				+        type AlgorithmIdentifier = Algorithm | string;
			
 
				+        type HashAlgorithmIdentifier = AlgorithmIdentifier;
			
 
				+        type NamedCurve = string;
			
 
				+        type BigInteger = Uint8Array;
			
 
				+        interface AesCbcParams extends Algorithm {
			
 
				+            iv: BufferSource;
			
 
				+        }
			
 
				+        interface AesCtrParams extends Algorithm {
			
 
				+            counter: BufferSource;
			
 
				+            length: number;
			
 
				+        }
			
 
				+        interface AesDerivedKeyParams extends Algorithm {
			
 
				+            length: number;
			
 
				+        }
			
 
				+        interface AesGcmParams extends Algorithm {
			
 
				+            additionalData?: BufferSource;
			
 
				+            iv: BufferSource;
			
 
				+            tagLength?: number;
			
 
				+        }
			
 
				+        interface AesKeyAlgorithm extends KeyAlgorithm {
			
 
				+            length: number;
			
 
				+        }
			
 
				+        interface AesKeyGenParams extends Algorithm {
			
 
				+            length: number;
			
 
				+        }
			
 
				+        interface Algorithm {
			
 
				+            name: string;
			
 
				+        }
			
 
				+        interface EcKeyAlgorithm extends KeyAlgorithm {
			
 
				+            namedCurve: NamedCurve;
			
 
				+        }
			
 
				+        interface EcKeyGenParams extends Algorithm {
			
 
				+            namedCurve: NamedCurve;
			
 
				+        }
			
 
				+        interface EcKeyImportParams extends Algorithm {
			
 
				+            namedCurve: NamedCurve;
			
 
				+        }
			
 
				+        interface EcdhKeyDeriveParams extends Algorithm {
			
 
				+            public: CryptoKey;
			
 
				+        }
			
 
				+        interface EcdsaParams extends Algorithm {
			
 
				+            hash: HashAlgorithmIdentifier;
			
 
				+        }
			
 
				+        interface Ed448Params extends Algorithm {
			
 
				+            context?: BufferSource;
			
 
				+        }
			
 
				+        interface HkdfParams extends Algorithm {
			
 
				+            hash: HashAlgorithmIdentifier;
			
 
				+            info: BufferSource;
			
 
				+            salt: BufferSource;
			
 
				+        }
			
 
				+        interface HmacImportParams extends Algorithm {
			
 
				+            hash: HashAlgorithmIdentifier;
			
 
				+            length?: number;
			
 
				+        }
			
 
				+        interface HmacKeyAlgorithm extends KeyAlgorithm {
			
 
				+            hash: KeyAlgorithm;
			
 
				+            length: number;
			
 
				+        }
			
 
				+        interface HmacKeyGenParams extends Algorithm {
			
 
				+            hash: HashAlgorithmIdentifier;
			
 
				+            length?: number;
			
 
				+        }
			
 
				+        interface JsonWebKey {
			
 
				+            alg?: string;
			
 
				+            crv?: string;
			
 
				+            d?: string;
			
 
				+            dp?: string;
			
 
				+            dq?: string;
			
 
				+            e?: string;
			
 
				+            ext?: boolean;
			
 
				+            k?: string;
			
 
				+            key_ops?: string[];
			
 
				+            kty?: string;
			
 
				+            n?: string;
			
 
				+            oth?: RsaOtherPrimesInfo[];
			
 
				+            p?: string;
			
 
				+            q?: string;
			
 
				+            qi?: string;
			
 
				+            use?: string;
			
 
				+            x?: string;
			
 
				+            y?: string;
			
 
				+        }
			
 
				+        interface KeyAlgorithm {
			
 
				+            name: string;
			
 
				+        }
			
 
				+        interface Pbkdf2Params extends Algorithm {
			
 
				+            hash: HashAlgorithmIdentifier;
			
 
				+            iterations: number;
			
 
				+            salt: BufferSource;
			
 
				+        }
			
 
				+        interface RsaHashedImportParams extends Algorithm {
			
 
				+            hash: HashAlgorithmIdentifier;
			
 
				+        }
			
 
				+        interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
			
 
				+            hash: KeyAlgorithm;
			
 
				+        }
			
 
				+        interface RsaHashedKeyGenParams extends RsaKeyGenParams {
			
 
				+            hash: HashAlgorithmIdentifier;
			
 
				+        }
			
 
				+        interface RsaKeyAlgorithm extends KeyAlgorithm {
			
 
				+            modulusLength: number;
			
 
				+            publicExponent: BigInteger;
			
 
				+        }
			
 
				+        interface RsaKeyGenParams extends Algorithm {
			
 
				+            modulusLength: number;
			
 
				+            publicExponent: BigInteger;
			
 
				+        }
			
 
				+        interface RsaOaepParams extends Algorithm {
			
 
				+            label?: BufferSource;
			
 
				+        }
			
 
				+        interface RsaOtherPrimesInfo {
			
 
				+            d?: string;
			
 
				+            r?: string;
			
 
				+            t?: string;
			
 
				+        }
			
 
				+        interface RsaPssParams extends Algorithm {
			
 
				+            saltLength: number;
			
 
				+        }
			
 
				+        /**
			
 
				+         * Calling `require('node:crypto').webcrypto` returns an instance of the `Crypto` class.
			
 
				+         * `Crypto` is a singleton that provides access to the remainder of the crypto API.
			
 
				+         * @since v15.0.0
			
 
				+         */
			
 
				+        interface Crypto {
			
 
				+            /**
			
 
				+             * Provides access to the `SubtleCrypto` API.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            readonly subtle: SubtleCrypto;
			
 
				+            /**
			
 
				+             * Generates cryptographically strong random values.
			
 
				+             * The given `typedArray` is filled with random values, and a reference to `typedArray` is returned.
			
 
				+             *
			
 
				+             * The given `typedArray` must be an integer-based instance of {@link NodeJS.TypedArray}, i.e. `Float32Array` and `Float64Array` are not accepted.
			
 
				+             *
			
 
				+             * An error will be thrown if the given `typedArray` is larger than 65,536 bytes.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            getRandomValues<T extends Exclude<NodeJS.TypedArray, Float32Array | Float64Array>>(typedArray: T): T;
			
 
				+            /**
			
 
				+             * Generates a random {@link https://www.rfc-editor.org/rfc/rfc4122.txt RFC 4122} version 4 UUID.
			
 
				+             * The UUID is generated using a cryptographic pseudorandom number generator.
			
 
				+             * @since v16.7.0
			
 
				+             */
			
 
				+            randomUUID(): string;
			
 
				+            CryptoKey: CryptoKeyConstructor;
			
 
				+        }
			
 
				+        // This constructor throws ILLEGAL_CONSTRUCTOR so it should not be newable.
			
 
				+        interface CryptoKeyConstructor {
			
 
				+            /** Illegal constructor */
			
 
				+            (_: { readonly _: unique symbol }): never; // Allows instanceof to work but not be callable by the user.
			
 
				+            readonly length: 0;
			
 
				+            readonly name: 'CryptoKey';
			
 
				+            readonly prototype: CryptoKey;
			
 
				+        }
			
 
				+        /**
			
 
				+         * @since v15.0.0
			
 
				+         */
			
 
				+        interface CryptoKey {
			
 
				+            /**
			
 
				+             * An object detailing the algorithm for which the key can be used along with additional algorithm-specific parameters.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            readonly algorithm: KeyAlgorithm;
			
 
				+            /**
			
 
				+             * When `true`, the {@link CryptoKey} can be extracted using either `subtleCrypto.exportKey()` or `subtleCrypto.wrapKey()`.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            readonly extractable: boolean;
			
 
				+            /**
			
 
				+             * A string identifying whether the key is a symmetric (`'secret'`) or asymmetric (`'private'` or `'public'`) key.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            readonly type: KeyType;
			
 
				+            /**
			
 
				+             * An array of strings identifying the operations for which the key may be used.
			
 
				+             *
			
 
				+             * The possible usages are:
			
 
				+             * - `'encrypt'` - The key may be used to encrypt data.
			
 
				+             * - `'decrypt'` - The key may be used to decrypt data.
			
 
				+             * - `'sign'` - The key may be used to generate digital signatures.
			
 
				+             * - `'verify'` - The key may be used to verify digital signatures.
			
 
				+             * - `'deriveKey'` - The key may be used to derive a new key.
			
 
				+             * - `'deriveBits'` - The key may be used to derive bits.
			
 
				+             * - `'wrapKey'` - The key may be used to wrap another key.
			
 
				+             * - `'unwrapKey'` - The key may be used to unwrap another key.
			
 
				+             *
			
 
				+             * Valid key usages depend on the key algorithm (identified by `cryptokey.algorithm.name`).
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            readonly usages: KeyUsage[];
			
 
				+        }
			
 
				+        /**
			
 
				+         * The `CryptoKeyPair` is a simple dictionary object with `publicKey` and `privateKey` properties, representing an asymmetric key pair.
			
 
				+         * @since v15.0.0
			
 
				+         */
			
 
				+        interface CryptoKeyPair {
			
 
				+            /**
			
 
				+             * A {@link CryptoKey} whose type will be `'private'`.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            privateKey: CryptoKey;
			
 
				+            /**
			
 
				+             * A {@link CryptoKey} whose type will be `'public'`.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            publicKey: CryptoKey;
			
 
				+        }
			
 
				+        /**
			
 
				+         * @since v15.0.0
			
 
				+         */
			
 
				+        interface SubtleCrypto {
			
 
				+            /**
			
 
				+             * Using the method and parameters specified in `algorithm` and the keying material provided by `key`,
			
 
				+             * `subtle.decrypt()` attempts to decipher the provided `data`. If successful,
			
 
				+             * the returned promise will be resolved with an `<ArrayBuffer>` containing the plaintext result.
			
 
				+             *
			
 
				+             * The algorithms currently supported include:
			
 
				+             *
			
 
				+             * - `'RSA-OAEP'`
			
 
				+             * - `'AES-CTR'`
			
 
				+             * - `'AES-CBC'`
			
 
				+             * - `'AES-GCM'`
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
			
 
				+            /**
			
 
				+             * Using the method and parameters specified in `algorithm` and the keying material provided by `baseKey`,
			
 
				+             * `subtle.deriveBits()` attempts to generate `length` bits.
			
 
				+             * The Node.js implementation requires that when `length` is a number it must be multiple of `8`.
			
 
				+             * When `length` is `null` the maximum number of bits for a given algorithm is generated. This is allowed
			
 
				+             * for the `'ECDH'`, `'X25519'`, and `'X448'` algorithms.
			
 
				+             * If successful, the returned promise will be resolved with an `<ArrayBuffer>` containing the generated data.
			
 
				+             *
			
 
				+             * The algorithms currently supported include:
			
 
				+             *
			
 
				+             * - `'ECDH'`
			
 
				+             * - `'X25519'`
			
 
				+             * - `'X448'`
			
 
				+             * - `'HKDF'`
			
 
				+             * - `'PBKDF2'`
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            deriveBits(algorithm: EcdhKeyDeriveParams, baseKey: CryptoKey, length: number | null): Promise<ArrayBuffer>;
			
 
				+            deriveBits(algorithm: AlgorithmIdentifier | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
			
 
				+            /**
			
 
				+             * Using the method and parameters specified in `algorithm`, and the keying material provided by `baseKey`,
			
 
				+             * `subtle.deriveKey()` attempts to generate a new <CryptoKey>` based on the method and parameters in `derivedKeyAlgorithm`.
			
 
				+             *
			
 
				+             * Calling `subtle.deriveKey()` is equivalent to calling `subtle.deriveBits()` to generate raw keying material,
			
 
				+             * then passing the result into the `subtle.importKey()` method using the `deriveKeyAlgorithm`, `extractable`, and `keyUsages` parameters as input.
			
 
				+             *
			
 
				+             * The algorithms currently supported include:
			
 
				+             *
			
 
				+             * - `'ECDH'`
			
 
				+             * - `'X25519'`
			
 
				+             * - `'X448'`
			
 
				+             * - `'HKDF'`
			
 
				+             * - `'PBKDF2'`
			
 
				+             * @param keyUsages See {@link https://nodejs.org/docs/latest/api/webcrypto.html#cryptokeyusages Key usages}.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            deriveKey(
			
 
				+                algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params,
			
 
				+                baseKey: CryptoKey,
			
 
				+                derivedKeyAlgorithm: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params,
			
 
				+                extractable: boolean,
			
 
				+                keyUsages: ReadonlyArray<KeyUsage>
			
 
				+            ): Promise<CryptoKey>;
			
 
				+            /**
			
 
				+             * Using the method identified by `algorithm`, `subtle.digest()` attempts to generate a digest of `data`.
			
 
				+             * If successful, the returned promise is resolved with an `<ArrayBuffer>` containing the computed digest.
			
 
				+             *
			
 
				+             * If `algorithm` is provided as a `<string>`, it must be one of:
			
 
				+             *
			
 
				+             * - `'SHA-1'`
			
 
				+             * - `'SHA-256'`
			
 
				+             * - `'SHA-384'`
			
 
				+             * - `'SHA-512'`
			
 
				+             *
			
 
				+             * If `algorithm` is provided as an `<Object>`, it must have a `name` property whose value is one of the above.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise<ArrayBuffer>;
			
 
				+            /**
			
 
				+             * Using the method and parameters specified by `algorithm` and the keying material provided by `key`,
			
 
				+             * `subtle.encrypt()` attempts to encipher `data`. If successful,
			
 
				+             * the returned promise is resolved with an `<ArrayBuffer>` containing the encrypted result.
			
 
				+             *
			
 
				+             * The algorithms currently supported include:
			
 
				+             *
			
 
				+             * - `'RSA-OAEP'`
			
 
				+             * - `'AES-CTR'`
			
 
				+             * - `'AES-CBC'`
			
 
				+             * - `'AES-GCM'`
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
			
 
				+            /**
			
 
				+             * Exports the given key into the specified format, if supported.
			
 
				+             *
			
 
				+             * If the `<CryptoKey>` is not extractable, the returned promise will reject.
			
 
				+             *
			
 
				+             * When `format` is either `'pkcs8'` or `'spki'` and the export is successful,
			
 
				+             * the returned promise will be resolved with an `<ArrayBuffer>` containing the exported key data.
			
 
				+             *
			
 
				+             * When `format` is `'jwk'` and the export is successful, the returned promise will be resolved with a
			
 
				+             * JavaScript object conforming to the {@link https://tools.ietf.org/html/rfc7517 JSON Web Key} specification.
			
 
				+             * @param format Must be one of `'raw'`, `'pkcs8'`, `'spki'`, or `'jwk'`.
			
 
				+             * @returns `<Promise>` containing `<ArrayBuffer>`.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            exportKey(format: 'jwk', key: CryptoKey): Promise<JsonWebKey>;
			
 
				+            exportKey(format: Exclude<KeyFormat, 'jwk'>, key: CryptoKey): Promise<ArrayBuffer>;
			
 
				+            /**
			
 
				+             * Using the method and parameters provided in `algorithm`,
			
 
				+             * `subtle.generateKey()` attempts to generate new keying material.
			
 
				+             * Depending the method used, the method may generate either a single `<CryptoKey>` or a `<CryptoKeyPair>`.
			
 
				+             *
			
 
				+             * The `<CryptoKeyPair>` (public and private key) generating algorithms supported include:
			
 
				+             *
			
 
				+             * - `'RSASSA-PKCS1-v1_5'`
			
 
				+             * - `'RSA-PSS'`
			
 
				+             * - `'RSA-OAEP'`
			
 
				+             * - `'ECDSA'`
			
 
				+             * - `'Ed25519'`
			
 
				+             * - `'Ed448'`
			
 
				+             * - `'ECDH'`
			
 
				+             * - `'X25519'`
			
 
				+             * - `'X448'`
			
 
				+             * The `<CryptoKey>` (secret key) generating algorithms supported include:
			
 
				+             *
			
 
				+             * - `'HMAC'`
			
 
				+             * - `'AES-CTR'`
			
 
				+             * - `'AES-CBC'`
			
 
				+             * - `'AES-GCM'`
			
 
				+             * - `'AES-KW'`
			
 
				+             * @param keyUsages See {@link https://nodejs.org/docs/latest/api/webcrypto.html#cryptokeyusages Key usages}.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams, extractable: boolean, keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKeyPair>;
			
 
				+            generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean, keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKey>;
			
 
				+            generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair | CryptoKey>;
			
 
				+            /**
			
 
				+             * The `subtle.importKey()` method attempts to interpret the provided `keyData` as the given `format`
			
 
				+             * to create a `<CryptoKey>` instance using the provided `algorithm`, `extractable`, and `keyUsages` arguments.
			
 
				+             * If the import is successful, the returned promise will be resolved with the created `<CryptoKey>`.
			
 
				+             *
			
 
				+             * If importing a `'PBKDF2'` key, `extractable` must be `false`.
			
 
				+             * @param format Must be one of `'raw'`, `'pkcs8'`, `'spki'`, or `'jwk'`.
			
 
				+             * @param keyUsages See {@link https://nodejs.org/docs/latest/api/webcrypto.html#cryptokeyusages Key usages}.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            importKey(
			
 
				+                format: 'jwk',
			
 
				+                keyData: JsonWebKey,
			
 
				+                algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm,
			
 
				+                extractable: boolean,
			
 
				+                keyUsages: ReadonlyArray<KeyUsage>
			
 
				+            ): Promise<CryptoKey>;
			
 
				+            importKey(
			
 
				+                format: Exclude<KeyFormat, 'jwk'>,
			
 
				+                keyData: BufferSource,
			
 
				+                algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm,
			
 
				+                extractable: boolean,
			
 
				+                keyUsages: KeyUsage[]
			
 
				+            ): Promise<CryptoKey>;
			
 
				+            /**
			
 
				+             * Using the method and parameters given by `algorithm` and the keying material provided by `key`,
			
 
				+             * `subtle.sign()` attempts to generate a cryptographic signature of `data`. If successful,
			
 
				+             * the returned promise is resolved with an `<ArrayBuffer>` containing the generated signature.
			
 
				+             *
			
 
				+             * The algorithms currently supported include:
			
 
				+             *
			
 
				+             * - `'RSASSA-PKCS1-v1_5'`
			
 
				+             * - `'RSA-PSS'`
			
 
				+             * - `'ECDSA'`
			
 
				+             * - `'Ed25519'`
			
 
				+             * - `'Ed448'`
			
 
				+             * - `'HMAC'`
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | Ed448Params, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
			
 
				+            /**
			
 
				+             * In cryptography, "wrapping a key" refers to exporting and then encrypting the keying material.
			
 
				+             * The `subtle.unwrapKey()` method attempts to decrypt a wrapped key and create a `<CryptoKey>` instance.
			
 
				+             * It is equivalent to calling `subtle.decrypt()` first on the encrypted key data (using the `wrappedKey`, `unwrapAlgo`, and `unwrappingKey` arguments as input)
			
 
				+             * then passing the results in to the `subtle.importKey()` method using the `unwrappedKeyAlgo`, `extractable`, and `keyUsages` arguments as inputs.
			
 
				+             * If successful, the returned promise is resolved with a `<CryptoKey>` object.
			
 
				+             *
			
 
				+             * The wrapping algorithms currently supported include:
			
 
				+             *
			
 
				+             * - `'RSA-OAEP'`
			
 
				+             * - `'AES-CTR'`
			
 
				+             * - `'AES-CBC'`
			
 
				+             * - `'AES-GCM'`
			
 
				+             * - `'AES-KW'`
			
 
				+             *
			
 
				+             * The unwrapped key algorithms supported include:
			
 
				+             *
			
 
				+             * - `'RSASSA-PKCS1-v1_5'`
			
 
				+             * - `'RSA-PSS'`
			
 
				+             * - `'RSA-OAEP'`
			
 
				+             * - `'ECDSA'`
			
 
				+             * - `'Ed25519'`
			
 
				+             * - `'Ed448'`
			
 
				+             * - `'ECDH'`
			
 
				+             * - `'X25519'`
			
 
				+             * - `'X448'`
			
 
				+             * - `'HMAC'`
			
 
				+             * - `'AES-CTR'`
			
 
				+             * - `'AES-CBC'`
			
 
				+             * - `'AES-GCM'`
			
 
				+             * - `'AES-KW'`
			
 
				+             * @param format Must be one of `'raw'`, `'pkcs8'`, `'spki'`, or `'jwk'`.
			
 
				+             * @param keyUsages See {@link https://nodejs.org/docs/latest/api/webcrypto.html#cryptokeyusages Key usages}.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            unwrapKey(
			
 
				+                format: KeyFormat,
			
 
				+                wrappedKey: BufferSource,
			
 
				+                unwrappingKey: CryptoKey,
			
 
				+                unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams,
			
 
				+                unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm,
			
 
				+                extractable: boolean,
			
 
				+                keyUsages: KeyUsage[]
			
 
				+            ): Promise<CryptoKey>;
			
 
				+            /**
			
 
				+             * Using the method and parameters given in `algorithm` and the keying material provided by `key`,
			
 
				+             * `subtle.verify()` attempts to verify that `signature` is a valid cryptographic signature of `data`.
			
 
				+             * The returned promise is resolved with either `true` or `false`.
			
 
				+             *
			
 
				+             * The algorithms currently supported include:
			
 
				+             *
			
 
				+             * - `'RSASSA-PKCS1-v1_5'`
			
 
				+             * - `'RSA-PSS'`
			
 
				+             * - `'ECDSA'`
			
 
				+             * - `'Ed25519'`
			
 
				+             * - `'Ed448'`
			
 
				+             * - `'HMAC'`
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams | Ed448Params, key: CryptoKey, signature: BufferSource, data: BufferSource): Promise<boolean>;
			
 
				+            /**
			
 
				+             * In cryptography, "wrapping a key" refers to exporting and then encrypting the keying material.
			
 
				+             * The `subtle.wrapKey()` method exports the keying material into the format identified by `format`,
			
 
				+             * then encrypts it using the method and parameters specified by `wrapAlgo` and the keying material provided by `wrappingKey`.
			
 
				+             * It is the equivalent to calling `subtle.exportKey()` using `format` and `key` as the arguments,
			
 
				+             * then passing the result to the `subtle.encrypt()` method using `wrappingKey` and `wrapAlgo` as inputs.
			
 
				+             * If successful, the returned promise will be resolved with an `<ArrayBuffer>` containing the encrypted key data.
			
 
				+             *
			
 
				+             * The wrapping algorithms currently supported include:
			
 
				+             *
			
 
				+             * - `'RSA-OAEP'`
			
 
				+             * - `'AES-CTR'`
			
 
				+             * - `'AES-CBC'`
			
 
				+             * - `'AES-GCM'`
			
 
				+             * - `'AES-KW'`
			
 
				+             * @param format Must be one of `'raw'`, `'pkcs8'`, `'spki'`, or `'jwk'`.
			
 
				+             * @since v15.0.0
			
 
				+             */
			
 
				+            wrapKey(format: KeyFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams): Promise<ArrayBuffer>;
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+declare module 'node:crypto' {
			
 
				+    export * from 'crypto';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/dgram.d.ts
+++ b/Asistent/node_modules/@types/node/dgram.d.ts
@@ -0,0 +1,545 @@
 
				+/**
			
 
				+ * The `dgram` module provides an implementation of UDP datagram sockets.
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * import dgram from 'dgram';
			
 
				+ *
			
 
				+ * const server = dgram.createSocket('udp4');
			
 
				+ *
			
 
				+ * server.on('error', (err) => {
			
 
				+ *   console.log(`server error:\n${err.stack}`);
			
 
				+ *   server.close();
			
 
				+ * });
			
 
				+ *
			
 
				+ * server.on('message', (msg, rinfo) => {
			
 
				+ *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
			
 
				+ * });
			
 
				+ *
			
 
				+ * server.on('listening', () => {
			
 
				+ *   const address = server.address();
			
 
				+ *   console.log(`server listening ${address.address}:${address.port}`);
			
 
				+ * });
			
 
				+ *
			
 
				+ * server.bind(41234);
			
 
				+ * // Prints: server listening 0.0.0.0:41234
			
 
				+ * ```
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/dgram.js)
			
 
				+ */
			
 
				+declare module 'dgram' {
			
 
				+    import { AddressInfo } from 'node:net';
			
 
				+    import * as dns from 'node:dns';
			
 
				+    import { EventEmitter, Abortable } from 'node:events';
			
 
				+    interface RemoteInfo {
			
 
				+        address: string;
			
 
				+        family: 'IPv4' | 'IPv6';
			
 
				+        port: number;
			
 
				+        size: number;
			
 
				+    }
			
 
				+    interface BindOptions {
			
 
				+        port?: number | undefined;
			
 
				+        address?: string | undefined;
			
 
				+        exclusive?: boolean | undefined;
			
 
				+        fd?: number | undefined;
			
 
				+    }
			
 
				+    type SocketType = 'udp4' | 'udp6';
			
 
				+    interface SocketOptions extends Abortable {
			
 
				+        type: SocketType;
			
 
				+        reuseAddr?: boolean | undefined;
			
 
				+        /**
			
 
				+         * @default false
			
 
				+         */
			
 
				+        ipv6Only?: boolean | undefined;
			
 
				+        recvBufferSize?: number | undefined;
			
 
				+        sendBufferSize?: number | undefined;
			
 
				+        lookup?: ((hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void) | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Creates a `dgram.Socket` object. Once the socket is created, calling `socket.bind()` will instruct the socket to begin listening for datagram
			
 
				+     * messages. When `address` and `port` are not passed to `socket.bind()` the
			
 
				+     * method will bind the socket to the "all interfaces" address on a random port
			
 
				+     * (it does the right thing for both `udp4` and `udp6` sockets). The bound address
			
 
				+     * and port can be retrieved using `socket.address().address` and `socket.address().port`.
			
 
				+     *
			
 
				+     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.close()` on the socket:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const controller = new AbortController();
			
 
				+     * const { signal } = controller;
			
 
				+     * const server = dgram.createSocket({ type: 'udp4', signal });
			
 
				+     * server.on('message', (msg, rinfo) => {
			
 
				+     *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
			
 
				+     * });
			
 
				+     * // Later, when you want to close the server.
			
 
				+     * controller.abort();
			
 
				+     * ```
			
 
				+     * @since v0.11.13
			
 
				+     * @param options Available options are:
			
 
				+     * @param callback Attached as a listener for `'message'` events. Optional.
			
 
				+     */
			
 
				+    function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
			
 
				+    function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
			
 
				+    /**
			
 
				+     * Encapsulates the datagram functionality.
			
 
				+     *
			
 
				+     * New instances of `dgram.Socket` are created using {@link createSocket}.
			
 
				+     * The `new` keyword is not to be used to create `dgram.Socket` instances.
			
 
				+     * @since v0.1.99
			
 
				+     */
			
 
				+    class Socket extends EventEmitter {
			
 
				+        /**
			
 
				+         * Tells the kernel to join a multicast group at the given `multicastAddress` and`multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the`multicastInterface` argument is not
			
 
				+         * specified, the operating system will choose
			
 
				+         * one interface and will add membership to it. To add membership to every
			
 
				+         * available interface, call `addMembership` multiple times, once per interface.
			
 
				+         *
			
 
				+         * When called on an unbound socket, this method will implicitly bind to a random
			
 
				+         * port, listening on all interfaces.
			
 
				+         *
			
 
				+         * When sharing a UDP socket across multiple `cluster` workers, the`socket.addMembership()` function must be called only once or an`EADDRINUSE` error will occur:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import cluster from 'cluster';
			
 
				+         * import dgram from 'dgram';
			
 
				+         *
			
 
				+         * if (cluster.isPrimary) {
			
 
				+         *   cluster.fork(); // Works ok.
			
 
				+         *   cluster.fork(); // Fails with EADDRINUSE.
			
 
				+         * } else {
			
 
				+         *   const s = dgram.createSocket('udp4');
			
 
				+         *   s.bind(1234, () => {
			
 
				+         *     s.addMembership('224.0.0.114');
			
 
				+         *   });
			
 
				+         * }
			
 
				+         * ```
			
 
				+         * @since v0.6.9
			
 
				+         */
			
 
				+        addMembership(multicastAddress: string, multicastInterface?: string): void;
			
 
				+        /**
			
 
				+         * Returns an object containing the address information for a socket.
			
 
				+         * For UDP sockets, this object will contain `address`, `family` and `port`properties.
			
 
				+         *
			
 
				+         * This method throws `EBADF` if called on an unbound socket.
			
 
				+         * @since v0.1.99
			
 
				+         */
			
 
				+        address(): AddressInfo;
			
 
				+        /**
			
 
				+         * For UDP sockets, causes the `dgram.Socket` to listen for datagram
			
 
				+         * messages on a named `port` and optional `address`. If `port` is not
			
 
				+         * specified or is `0`, the operating system will attempt to bind to a
			
 
				+         * random port. If `address` is not specified, the operating system will
			
 
				+         * attempt to listen on all addresses. Once binding is complete, a`'listening'` event is emitted and the optional `callback` function is
			
 
				+         * called.
			
 
				+         *
			
 
				+         * Specifying both a `'listening'` event listener and passing a`callback` to the `socket.bind()` method is not harmful but not very
			
 
				+         * useful.
			
 
				+         *
			
 
				+         * A bound datagram socket keeps the Node.js process running to receive
			
 
				+         * datagram messages.
			
 
				+         *
			
 
				+         * If binding fails, an `'error'` event is generated. In rare case (e.g.
			
 
				+         * attempting to bind with a closed socket), an `Error` may be thrown.
			
 
				+         *
			
 
				+         * Example of a UDP server listening on port 41234:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import dgram from 'dgram';
			
 
				+         *
			
 
				+         * const server = dgram.createSocket('udp4');
			
 
				+         *
			
 
				+         * server.on('error', (err) => {
			
 
				+         *   console.log(`server error:\n${err.stack}`);
			
 
				+         *   server.close();
			
 
				+         * });
			
 
				+         *
			
 
				+         * server.on('message', (msg, rinfo) => {
			
 
				+         *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
			
 
				+         * });
			
 
				+         *
			
 
				+         * server.on('listening', () => {
			
 
				+         *   const address = server.address();
			
 
				+         *   console.log(`server listening ${address.address}:${address.port}`);
			
 
				+         * });
			
 
				+         *
			
 
				+         * server.bind(41234);
			
 
				+         * // Prints: server listening 0.0.0.0:41234
			
 
				+         * ```
			
 
				+         * @since v0.1.99
			
 
				+         * @param callback with no parameters. Called when binding is complete.
			
 
				+         */
			
 
				+        bind(port?: number, address?: string, callback?: () => void): this;
			
 
				+        bind(port?: number, callback?: () => void): this;
			
 
				+        bind(callback?: () => void): this;
			
 
				+        bind(options: BindOptions, callback?: () => void): this;
			
 
				+        /**
			
 
				+         * Close the underlying socket and stop listening for data on it. If a callback is
			
 
				+         * provided, it is added as a listener for the `'close'` event.
			
 
				+         * @since v0.1.99
			
 
				+         * @param callback Called when the socket has been closed.
			
 
				+         */
			
 
				+        close(callback?: () => void): this;
			
 
				+        /**
			
 
				+         * Associates the `dgram.Socket` to a remote address and port. Every
			
 
				+         * message sent by this handle is automatically sent to that destination. Also,
			
 
				+         * the socket will only receive messages from that remote peer.
			
 
				+         * Trying to call `connect()` on an already connected socket will result
			
 
				+         * in an `ERR_SOCKET_DGRAM_IS_CONNECTED` exception. If `address` is not
			
 
				+         * provided, `'127.0.0.1'` (for `udp4` sockets) or `'::1'` (for `udp6` sockets)
			
 
				+         * will be used by default. Once the connection is complete, a `'connect'` event
			
 
				+         * is emitted and the optional `callback` function is called. In case of failure,
			
 
				+         * the `callback` is called or, failing this, an `'error'` event is emitted.
			
 
				+         * @since v12.0.0
			
 
				+         * @param callback Called when the connection is completed or on error.
			
 
				+         */
			
 
				+        connect(port: number, address?: string, callback?: () => void): void;
			
 
				+        connect(port: number, callback: () => void): void;
			
 
				+        /**
			
 
				+         * A synchronous function that disassociates a connected `dgram.Socket` from
			
 
				+         * its remote address. Trying to call `disconnect()` on an unbound or already
			
 
				+         * disconnected socket will result in an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception.
			
 
				+         * @since v12.0.0
			
 
				+         */
			
 
				+        disconnect(): void;
			
 
				+        /**
			
 
				+         * Instructs the kernel to leave a multicast group at `multicastAddress` using the`IP_DROP_MEMBERSHIP` socket option. This method is automatically called by the
			
 
				+         * kernel when the socket is closed or the process terminates, so most apps will
			
 
				+         * never have reason to call this.
			
 
				+         *
			
 
				+         * If `multicastInterface` is not specified, the operating system will attempt to
			
 
				+         * drop membership on all valid interfaces.
			
 
				+         * @since v0.6.9
			
 
				+         */
			
 
				+        dropMembership(multicastAddress: string, multicastInterface?: string): void;
			
 
				+        /**
			
 
				+         * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
			
 
				+         * @since v8.7.0
			
 
				+         * @return the `SO_RCVBUF` socket receive buffer size in bytes.
			
 
				+         */
			
 
				+        getRecvBufferSize(): number;
			
 
				+        /**
			
 
				+         * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
			
 
				+         * @since v8.7.0
			
 
				+         * @return the `SO_SNDBUF` socket send buffer size in bytes.
			
 
				+         */
			
 
				+        getSendBufferSize(): number;
			
 
				+        /**
			
 
				+         * By default, binding a socket will cause it to block the Node.js process from
			
 
				+         * exiting as long as the socket is open. The `socket.unref()` method can be used
			
 
				+         * to exclude the socket from the reference counting that keeps the Node.js
			
 
				+         * process active. The `socket.ref()` method adds the socket back to the reference
			
 
				+         * counting and restores the default behavior.
			
 
				+         *
			
 
				+         * Calling `socket.ref()` multiples times will have no additional effect.
			
 
				+         *
			
 
				+         * The `socket.ref()` method returns a reference to the socket so calls can be
			
 
				+         * chained.
			
 
				+         * @since v0.9.1
			
 
				+         */
			
 
				+        ref(): this;
			
 
				+        /**
			
 
				+         * Returns an object containing the `address`, `family`, and `port` of the remote
			
 
				+         * endpoint. This method throws an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception
			
 
				+         * if the socket is not connected.
			
 
				+         * @since v12.0.0
			
 
				+         */
			
 
				+        remoteAddress(): AddressInfo;
			
 
				+        /**
			
 
				+         * Broadcasts a datagram on the socket.
			
 
				+         * For connectionless sockets, the destination `port` and `address` must be
			
 
				+         * specified. Connected sockets, on the other hand, will use their associated
			
 
				+         * remote endpoint, so the `port` and `address` arguments must not be set.
			
 
				+         *
			
 
				+         * The `msg` argument contains the message to be sent.
			
 
				+         * Depending on its type, different behavior can apply. If `msg` is a `Buffer`,
			
 
				+         * any `TypedArray` or a `DataView`,
			
 
				+         * the `offset` and `length` specify the offset within the `Buffer` where the
			
 
				+         * message begins and the number of bytes in the message, respectively.
			
 
				+         * If `msg` is a `String`, then it is automatically converted to a `Buffer`with `'utf8'` encoding. With messages that
			
 
				+         * contain multi-byte characters, `offset` and `length` will be calculated with
			
 
				+         * respect to `byte length` and not the character position.
			
 
				+         * If `msg` is an array, `offset` and `length` must not be specified.
			
 
				+         *
			
 
				+         * The `address` argument is a string. If the value of `address` is a host name,
			
 
				+         * DNS will be used to resolve the address of the host. If `address` is not
			
 
				+         * provided or otherwise nullish, `'127.0.0.1'` (for `udp4` sockets) or `'::1'`(for `udp6` sockets) will be used by default.
			
 
				+         *
			
 
				+         * If the socket has not been previously bound with a call to `bind`, the socket
			
 
				+         * is assigned a random port number and is bound to the "all interfaces" address
			
 
				+         * (`'0.0.0.0'` for `udp4` sockets, `'::0'` for `udp6` sockets.)
			
 
				+         *
			
 
				+         * An optional `callback` function may be specified to as a way of reporting
			
 
				+         * DNS errors or for determining when it is safe to reuse the `buf` object.
			
 
				+         * DNS lookups delay the time to send for at least one tick of the
			
 
				+         * Node.js event loop.
			
 
				+         *
			
 
				+         * The only way to know for sure that the datagram has been sent is by using a`callback`. If an error occurs and a `callback` is given, the error will be
			
 
				+         * passed as the first argument to the `callback`. If a `callback` is not given,
			
 
				+         * the error is emitted as an `'error'` event on the `socket` object.
			
 
				+         *
			
 
				+         * Offset and length are optional but both _must_ be set if either are used.
			
 
				+         * They are supported only when the first argument is a `Buffer`, a `TypedArray`,
			
 
				+         * or a `DataView`.
			
 
				+         *
			
 
				+         * This method throws `ERR_SOCKET_BAD_PORT` if called on an unbound socket.
			
 
				+         *
			
 
				+         * Example of sending a UDP packet to a port on `localhost`;
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import dgram from 'dgram';
			
 
				+         * import { Buffer } from 'buffer';
			
 
				+         *
			
 
				+         * const message = Buffer.from('Some bytes');
			
 
				+         * const client = dgram.createSocket('udp4');
			
 
				+         * client.send(message, 41234, 'localhost', (err) => {
			
 
				+         *   client.close();
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Example of sending a UDP packet composed of multiple buffers to a port on`127.0.0.1`;
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import dgram from 'dgram';
			
 
				+         * import { Buffer } from 'buffer';
			
 
				+         *
			
 
				+         * const buf1 = Buffer.from('Some ');
			
 
				+         * const buf2 = Buffer.from('bytes');
			
 
				+         * const client = dgram.createSocket('udp4');
			
 
				+         * client.send([buf1, buf2], 41234, (err) => {
			
 
				+         *   client.close();
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Sending multiple buffers might be faster or slower depending on the
			
 
				+         * application and operating system. Run benchmarks to
			
 
				+         * determine the optimal strategy on a case-by-case basis. Generally speaking,
			
 
				+         * however, sending multiple buffers is faster.
			
 
				+         *
			
 
				+         * Example of sending a UDP packet using a socket connected to a port on`localhost`:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import dgram from 'dgram';
			
 
				+         * import { Buffer } from 'buffer';
			
 
				+         *
			
 
				+         * const message = Buffer.from('Some bytes');
			
 
				+         * const client = dgram.createSocket('udp4');
			
 
				+         * client.connect(41234, 'localhost', (err) => {
			
 
				+         *   client.send(message, (err) => {
			
 
				+         *     client.close();
			
 
				+         *   });
			
 
				+         * });
			
 
				+         * ```
			
 
				+         * @since v0.1.99
			
 
				+         * @param msg Message to be sent.
			
 
				+         * @param offset Offset in the buffer where the message starts.
			
 
				+         * @param length Number of bytes in the message.
			
 
				+         * @param port Destination port.
			
 
				+         * @param address Destination host name or IP address.
			
 
				+         * @param callback Called when the message has been sent.
			
 
				+         */
			
 
				+        send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
			
 
				+        send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
			
 
				+        send(msg: string | Uint8Array | ReadonlyArray<any>, callback?: (error: Error | null, bytes: number) => void): void;
			
 
				+        send(msg: string | Uint8Array, offset: number, length: number, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
			
 
				+        send(msg: string | Uint8Array, offset: number, length: number, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
			
 
				+        send(msg: string | Uint8Array, offset: number, length: number, callback?: (error: Error | null, bytes: number) => void): void;
			
 
				+        /**
			
 
				+         * Sets or clears the `SO_BROADCAST` socket option. When set to `true`, UDP
			
 
				+         * packets may be sent to a local interface's broadcast address.
			
 
				+         *
			
 
				+         * This method throws `EBADF` if called on an unbound socket.
			
 
				+         * @since v0.6.9
			
 
				+         */
			
 
				+        setBroadcast(flag: boolean): void;
			
 
				+        /**
			
 
				+         * _All references to scope in this section are referring to [IPv6 Zone Indices](https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses), which are defined by [RFC
			
 
				+         * 4007](https://tools.ietf.org/html/rfc4007). In string form, an IP_
			
 
				+         * _with a scope index is written as `'IP%scope'` where scope is an interface name_
			
 
				+         * _or interface number._
			
 
				+         *
			
 
				+         * Sets the default outgoing multicast interface of the socket to a chosen
			
 
				+         * interface or back to system interface selection. The `multicastInterface` must
			
 
				+         * be a valid string representation of an IP from the socket's family.
			
 
				+         *
			
 
				+         * For IPv4 sockets, this should be the IP configured for the desired physical
			
 
				+         * interface. All packets sent to multicast on the socket will be sent on the
			
 
				+         * interface determined by the most recent successful use of this call.
			
 
				+         *
			
 
				+         * For IPv6 sockets, `multicastInterface` should include a scope to indicate the
			
 
				+         * interface as in the examples that follow. In IPv6, individual `send` calls can
			
 
				+         * also use explicit scope in addresses, so only packets sent to a multicast
			
 
				+         * address without specifying an explicit scope are affected by the most recent
			
 
				+         * successful use of this call.
			
 
				+         *
			
 
				+         * This method throws `EBADF` if called on an unbound socket.
			
 
				+         *
			
 
				+         * #### Example: IPv6 outgoing multicast interface
			
 
				+         *
			
 
				+         * On most systems, where scope format uses the interface name:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const socket = dgram.createSocket('udp6');
			
 
				+         *
			
 
				+         * socket.bind(1234, () => {
			
 
				+         *   socket.setMulticastInterface('::%eth1');
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * On Windows, where scope format uses an interface number:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const socket = dgram.createSocket('udp6');
			
 
				+         *
			
 
				+         * socket.bind(1234, () => {
			
 
				+         *   socket.setMulticastInterface('::%2');
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * #### Example: IPv4 outgoing multicast interface
			
 
				+         *
			
 
				+         * All systems use an IP of the host on the desired physical interface:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const socket = dgram.createSocket('udp4');
			
 
				+         *
			
 
				+         * socket.bind(1234, () => {
			
 
				+         *   socket.setMulticastInterface('10.0.0.2');
			
 
				+         * });
			
 
				+         * ```
			
 
				+         * @since v8.6.0
			
 
				+         */
			
 
				+        setMulticastInterface(multicastInterface: string): void;
			
 
				+        /**
			
 
				+         * Sets or clears the `IP_MULTICAST_LOOP` socket option. When set to `true`,
			
 
				+         * multicast packets will also be received on the local interface.
			
 
				+         *
			
 
				+         * This method throws `EBADF` if called on an unbound socket.
			
 
				+         * @since v0.3.8
			
 
				+         */
			
 
				+        setMulticastLoopback(flag: boolean): boolean;
			
 
				+        /**
			
 
				+         * Sets the `IP_MULTICAST_TTL` socket option. While TTL generally stands for
			
 
				+         * "Time to Live", in this context it specifies the number of IP hops that a
			
 
				+         * packet is allowed to travel through, specifically for multicast traffic. Each
			
 
				+         * router or gateway that forwards a packet decrements the TTL. If the TTL is
			
 
				+         * decremented to 0 by a router, it will not be forwarded.
			
 
				+         *
			
 
				+         * The `ttl` argument may be between 0 and 255\. The default on most systems is `1`.
			
 
				+         *
			
 
				+         * This method throws `EBADF` if called on an unbound socket.
			
 
				+         * @since v0.3.8
			
 
				+         */
			
 
				+        setMulticastTTL(ttl: number): number;
			
 
				+        /**
			
 
				+         * Sets the `SO_RCVBUF` socket option. Sets the maximum socket receive buffer
			
 
				+         * in bytes.
			
 
				+         *
			
 
				+         * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
			
 
				+         * @since v8.7.0
			
 
				+         */
			
 
				+        setRecvBufferSize(size: number): void;
			
 
				+        /**
			
 
				+         * Sets the `SO_SNDBUF` socket option. Sets the maximum socket send buffer
			
 
				+         * in bytes.
			
 
				+         *
			
 
				+         * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
			
 
				+         * @since v8.7.0
			
 
				+         */
			
 
				+        setSendBufferSize(size: number): void;
			
 
				+        /**
			
 
				+         * Sets the `IP_TTL` socket option. While TTL generally stands for "Time to Live",
			
 
				+         * in this context it specifies the number of IP hops that a packet is allowed to
			
 
				+         * travel through. Each router or gateway that forwards a packet decrements the
			
 
				+         * TTL. If the TTL is decremented to 0 by a router, it will not be forwarded.
			
 
				+         * Changing TTL values is typically done for network probes or when multicasting.
			
 
				+         *
			
 
				+         * The `ttl` argument may be between 1 and 255\. The default on most systems
			
 
				+         * is 64.
			
 
				+         *
			
 
				+         * This method throws `EBADF` if called on an unbound socket.
			
 
				+         * @since v0.1.101
			
 
				+         */
			
 
				+        setTTL(ttl: number): number;
			
 
				+        /**
			
 
				+         * By default, binding a socket will cause it to block the Node.js process from
			
 
				+         * exiting as long as the socket is open. The `socket.unref()` method can be used
			
 
				+         * to exclude the socket from the reference counting that keeps the Node.js
			
 
				+         * process active, allowing the process to exit even if the socket is still
			
 
				+         * listening.
			
 
				+         *
			
 
				+         * Calling `socket.unref()` multiple times will have no addition effect.
			
 
				+         *
			
 
				+         * The `socket.unref()` method returns a reference to the socket so calls can be
			
 
				+         * chained.
			
 
				+         * @since v0.9.1
			
 
				+         */
			
 
				+        unref(): this;
			
 
				+        /**
			
 
				+         * Tells the kernel to join a source-specific multicast channel at the given`sourceAddress` and `groupAddress`, using the `multicastInterface` with the`IP_ADD_SOURCE_MEMBERSHIP` socket
			
 
				+         * option. If the `multicastInterface` argument
			
 
				+         * is not specified, the operating system will choose one interface and will add
			
 
				+         * membership to it. To add membership to every available interface, call`socket.addSourceSpecificMembership()` multiple times, once per interface.
			
 
				+         *
			
 
				+         * When called on an unbound socket, this method will implicitly bind to a random
			
 
				+         * port, listening on all interfaces.
			
 
				+         * @since v13.1.0, v12.16.0
			
 
				+         */
			
 
				+        addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
			
 
				+        /**
			
 
				+         * Instructs the kernel to leave a source-specific multicast channel at the given`sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP`socket option. This method is
			
 
				+         * automatically called by the kernel when the
			
 
				+         * socket is closed or the process terminates, so most apps will never have
			
 
				+         * reason to call this.
			
 
				+         *
			
 
				+         * If `multicastInterface` is not specified, the operating system will attempt to
			
 
				+         * drop membership on all valid interfaces.
			
 
				+         * @since v13.1.0, v12.16.0
			
 
				+         */
			
 
				+        dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
			
 
				+        /**
			
 
				+         * events.EventEmitter
			
 
				+         * 1. close
			
 
				+         * 2. connect
			
 
				+         * 3. error
			
 
				+         * 4. listening
			
 
				+         * 5. message
			
 
				+         */
			
 
				+        addListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        addListener(event: 'close', listener: () => void): this;
			
 
				+        addListener(event: 'connect', listener: () => void): this;
			
 
				+        addListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        addListener(event: 'listening', listener: () => void): this;
			
 
				+        addListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
			
 
				+        emit(event: string | symbol, ...args: any[]): boolean;
			
 
				+        emit(event: 'close'): boolean;
			
 
				+        emit(event: 'connect'): boolean;
			
 
				+        emit(event: 'error', err: Error): boolean;
			
 
				+        emit(event: 'listening'): boolean;
			
 
				+        emit(event: 'message', msg: Buffer, rinfo: RemoteInfo): boolean;
			
 
				+        on(event: string, listener: (...args: any[]) => void): this;
			
 
				+        on(event: 'close', listener: () => void): this;
			
 
				+        on(event: 'connect', listener: () => void): this;
			
 
				+        on(event: 'error', listener: (err: Error) => void): this;
			
 
				+        on(event: 'listening', listener: () => void): this;
			
 
				+        on(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
			
 
				+        once(event: string, listener: (...args: any[]) => void): this;
			
 
				+        once(event: 'close', listener: () => void): this;
			
 
				+        once(event: 'connect', listener: () => void): this;
			
 
				+        once(event: 'error', listener: (err: Error) => void): this;
			
 
				+        once(event: 'listening', listener: () => void): this;
			
 
				+        once(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
			
 
				+        prependListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependListener(event: 'close', listener: () => void): this;
			
 
				+        prependListener(event: 'connect', listener: () => void): this;
			
 
				+        prependListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        prependListener(event: 'listening', listener: () => void): this;
			
 
				+        prependListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
			
 
				+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependOnceListener(event: 'close', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'connect', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        prependOnceListener(event: 'listening', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
			
 
				+    }
			
 
				+}
			
 
				+declare module 'node:dgram' {
			
 
				+    export * from 'dgram';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/diagnostics_channel.d.ts
+++ b/Asistent/node_modules/@types/node/diagnostics_channel.d.ts
@@ -0,0 +1,153 @@
 
				+/**
			
 
				+ * The `diagnostics_channel` module provides an API to create named channels
			
 
				+ * to report arbitrary message data for diagnostics purposes.
			
 
				+ *
			
 
				+ * It can be accessed using:
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * import diagnostics_channel from 'diagnostics_channel';
			
 
				+ * ```
			
 
				+ *
			
 
				+ * It is intended that a module writer wanting to report diagnostics messages
			
 
				+ * will create one or many top-level channels to report messages through.
			
 
				+ * Channels may also be acquired at runtime but it is not encouraged
			
 
				+ * due to the additional overhead of doing so. Channels may be exported for
			
 
				+ * convenience, but as long as the name is known it can be acquired anywhere.
			
 
				+ *
			
 
				+ * If you intend for your module to produce diagnostics data for others to
			
 
				+ * consume it is recommended that you include documentation of what named
			
 
				+ * channels are used along with the shape of the message data. Channel names
			
 
				+ * should generally include the module name to avoid collisions with data from
			
 
				+ * other modules.
			
 
				+ * @experimental
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/diagnostics_channel.js)
			
 
				+ */
			
 
				+declare module 'diagnostics_channel' {
			
 
				+    /**
			
 
				+     * Check if there are active subscribers to the named channel. This is helpful if
			
 
				+     * the message you want to send might be expensive to prepare.
			
 
				+     *
			
 
				+     * This API is optional but helpful when trying to publish messages from very
			
 
				+     * performance-sensitive code.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import diagnostics_channel from 'diagnostics_channel';
			
 
				+     *
			
 
				+     * if (diagnostics_channel.hasSubscribers('my-channel')) {
			
 
				+     *   // There are subscribers, prepare and publish message
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v15.1.0, v14.17.0
			
 
				+     * @param name The channel name
			
 
				+     * @return If there are active subscribers
			
 
				+     */
			
 
				+    function hasSubscribers(name: string | symbol): boolean;
			
 
				+    /**
			
 
				+     * This is the primary entry-point for anyone wanting to interact with a named
			
 
				+     * channel. It produces a channel object which is optimized to reduce overhead at
			
 
				+     * publish time as much as possible.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import diagnostics_channel from 'diagnostics_channel';
			
 
				+     *
			
 
				+     * const channel = diagnostics_channel.channel('my-channel');
			
 
				+     * ```
			
 
				+     * @since v15.1.0, v14.17.0
			
 
				+     * @param name The channel name
			
 
				+     * @return The named channel object
			
 
				+     */
			
 
				+    function channel(name: string | symbol): Channel;
			
 
				+    type ChannelListener = (message: unknown, name: string | symbol) => void;
			
 
				+    /**
			
 
				+     * The class `Channel` represents an individual named channel within the data
			
 
				+     * pipeline. It is use to track subscribers and to publish messages when there
			
 
				+     * are subscribers present. It exists as a separate object to avoid channel
			
 
				+     * lookups at publish time, enabling very fast publish speeds and allowing
			
 
				+     * for heavy use while incurring very minimal cost. Channels are created with {@link channel}, constructing a channel directly
			
 
				+     * with `new Channel(name)` is not supported.
			
 
				+     * @since v15.1.0, v14.17.0
			
 
				+     */
			
 
				+    class Channel {
			
 
				+        readonly name: string | symbol;
			
 
				+        /**
			
 
				+         * Check if there are active subscribers to this channel. This is helpful if
			
 
				+         * the message you want to send might be expensive to prepare.
			
 
				+         *
			
 
				+         * This API is optional but helpful when trying to publish messages from very
			
 
				+         * performance-sensitive code.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import diagnostics_channel from 'diagnostics_channel';
			
 
				+         *
			
 
				+         * const channel = diagnostics_channel.channel('my-channel');
			
 
				+         *
			
 
				+         * if (channel.hasSubscribers) {
			
 
				+         *   // There are subscribers, prepare and publish message
			
 
				+         * }
			
 
				+         * ```
			
 
				+         * @since v15.1.0, v14.17.0
			
 
				+         */
			
 
				+        readonly hasSubscribers: boolean;
			
 
				+        private constructor(name: string | symbol);
			
 
				+        /**
			
 
				+         * Publish a message to any subscribers to the channel. This will
			
 
				+         * trigger message handlers synchronously so they will execute within
			
 
				+         * the same context.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import diagnostics_channel from 'diagnostics_channel';
			
 
				+         *
			
 
				+         * const channel = diagnostics_channel.channel('my-channel');
			
 
				+         *
			
 
				+         * channel.publish({
			
 
				+         *   some: 'message'
			
 
				+         * });
			
 
				+         * ```
			
 
				+         * @since v15.1.0, v14.17.0
			
 
				+         * @param message The message to send to the channel subscribers
			
 
				+         */
			
 
				+        publish(message: unknown): void;
			
 
				+        /**
			
 
				+         * Register a message handler to subscribe to this channel. This message handler
			
 
				+         * will be run synchronously whenever a message is published to the channel. Any
			
 
				+         * errors thrown in the message handler will trigger an `'uncaughtException'`.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import diagnostics_channel from 'diagnostics_channel';
			
 
				+         *
			
 
				+         * const channel = diagnostics_channel.channel('my-channel');
			
 
				+         *
			
 
				+         * channel.subscribe((message, name) => {
			
 
				+         *   // Received data
			
 
				+         * });
			
 
				+         * ```
			
 
				+         * @since v15.1.0, v14.17.0
			
 
				+         * @param onMessage The handler to receive channel messages
			
 
				+         */
			
 
				+        subscribe(onMessage: ChannelListener): void;
			
 
				+        /**
			
 
				+         * Remove a message handler previously registered to this channel with `channel.subscribe(onMessage)`.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import diagnostics_channel from 'diagnostics_channel';
			
 
				+         *
			
 
				+         * const channel = diagnostics_channel.channel('my-channel');
			
 
				+         *
			
 
				+         * function onMessage(message, name) {
			
 
				+         *   // Received data
			
 
				+         * }
			
 
				+         *
			
 
				+         * channel.subscribe(onMessage);
			
 
				+         *
			
 
				+         * channel.unsubscribe(onMessage);
			
 
				+         * ```
			
 
				+         * @since v15.1.0, v14.17.0
			
 
				+         * @param onMessage The previous subscribed handler to remove
			
 
				+         * @return `true` if the handler was found, `false` otherwise.
			
 
				+         */
			
 
				+        unsubscribe(onMessage: ChannelListener): void;
			
 
				+    }
			
 
				+}
			
 
				+declare module 'node:diagnostics_channel' {
			
 
				+    export * from 'diagnostics_channel';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/dns.d.ts
+++ b/Asistent/node_modules/@types/node/dns.d.ts
@@ -0,0 +1,659 @@
 
				+/**
			
 
				+ * The `dns` module enables name resolution. For example, use it to look up IP
			
 
				+ * addresses of host names.
			
 
				+ *
			
 
				+ * Although named for the [Domain Name System (DNS)](https://en.wikipedia.org/wiki/Domain_Name_System), it does not always use the
			
 
				+ * DNS protocol for lookups. {@link lookup} uses the operating system
			
 
				+ * facilities to perform name resolution. It may not need to perform any network
			
 
				+ * communication. To perform name resolution the way other applications on the same
			
 
				+ * system do, use {@link lookup}.
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * const dns = require('dns');
			
 
				+ *
			
 
				+ * dns.lookup('example.org', (err, address, family) => {
			
 
				+ *   console.log('address: %j family: IPv%s', address, family);
			
 
				+ * });
			
 
				+ * // address: "93.184.216.34" family: IPv4
			
 
				+ * ```
			
 
				+ *
			
 
				+ * All other functions in the `dns` module connect to an actual DNS server to
			
 
				+ * perform name resolution. They will always use the network to perform DNS
			
 
				+ * queries. These functions do not use the same set of configuration files used by {@link lookup} (e.g. `/etc/hosts`). Use these functions to always perform
			
 
				+ * DNS queries, bypassing other name-resolution facilities.
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * const dns = require('dns');
			
 
				+ *
			
 
				+ * dns.resolve4('archive.org', (err, addresses) => {
			
 
				+ *   if (err) throw err;
			
 
				+ *
			
 
				+ *   console.log(`addresses: ${JSON.stringify(addresses)}`);
			
 
				+ *
			
 
				+ *   addresses.forEach((a) => {
			
 
				+ *     dns.reverse(a, (err, hostnames) => {
			
 
				+ *       if (err) {
			
 
				+ *         throw err;
			
 
				+ *       }
			
 
				+ *       console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);
			
 
				+ *     });
			
 
				+ *   });
			
 
				+ * });
			
 
				+ * ```
			
 
				+ *
			
 
				+ * See the `Implementation considerations section` for more information.
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/dns.js)
			
 
				+ */
			
 
				+declare module 'dns' {
			
 
				+    import * as dnsPromises from 'node:dns/promises';
			
 
				+    // Supported getaddrinfo flags.
			
 
				+    export const ADDRCONFIG: number;
			
 
				+    export const V4MAPPED: number;
			
 
				+    /**
			
 
				+     * If `dns.V4MAPPED` is specified, return resolved IPv6 addresses as
			
 
				+     * well as IPv4 mapped IPv6 addresses.
			
 
				+     */
			
 
				+    export const ALL: number;
			
 
				+    export interface LookupOptions {
			
 
				+        family?: number | undefined;
			
 
				+        hints?: number | undefined;
			
 
				+        all?: boolean | undefined;
			
 
				+        /**
			
 
				+         * @default true
			
 
				+         */
			
 
				+        verbatim?: boolean | undefined;
			
 
				+    }
			
 
				+    export interface LookupOneOptions extends LookupOptions {
			
 
				+        all?: false | undefined;
			
 
				+    }
			
 
				+    export interface LookupAllOptions extends LookupOptions {
			
 
				+        all: true;
			
 
				+    }
			
 
				+    export interface LookupAddress {
			
 
				+        address: string;
			
 
				+        family: number;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Resolves a host name (e.g. `'nodejs.org'`) into the first found A (IPv4) or
			
 
				+     * AAAA (IPv6) record. All `option` properties are optional. If `options` is an
			
 
				+     * integer, then it must be `4` or `6` – if `options` is not provided, then IPv4
			
 
				+     * and IPv6 addresses are both returned if found.
			
 
				+     *
			
 
				+     * With the `all` option set to `true`, the arguments for `callback` change to`(err, addresses)`, with `addresses` being an array of objects with the
			
 
				+     * properties `address` and `family`.
			
 
				+     *
			
 
				+     * On error, `err` is an `Error` object, where `err.code` is the error code.
			
 
				+     * Keep in mind that `err.code` will be set to `'ENOTFOUND'` not only when
			
 
				+     * the host name does not exist but also when the lookup fails in other ways
			
 
				+     * such as no available file descriptors.
			
 
				+     *
			
 
				+     * `dns.lookup()` does not necessarily have anything to do with the DNS protocol.
			
 
				+     * The implementation uses an operating system facility that can associate names
			
 
				+     * with addresses, and vice versa. This implementation can have subtle but
			
 
				+     * important consequences on the behavior of any Node.js program. Please take some
			
 
				+     * time to consult the `Implementation considerations section` before using`dns.lookup()`.
			
 
				+     *
			
 
				+     * Example usage:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const dns = require('dns');
			
 
				+     * const options = {
			
 
				+     *   family: 6,
			
 
				+     *   hints: dns.ADDRCONFIG | dns.V4MAPPED,
			
 
				+     * };
			
 
				+     * dns.lookup('example.com', options, (err, address, family) =>
			
 
				+     *   console.log('address: %j family: IPv%s', address, family));
			
 
				+     * // address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6
			
 
				+     *
			
 
				+     * // When options.all is true, the result will be an Array.
			
 
				+     * options.all = true;
			
 
				+     * dns.lookup('example.com', options, (err, addresses) =>
			
 
				+     *   console.log('addresses: %j', addresses));
			
 
				+     * // addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If this method is invoked as its `util.promisify()` ed version, and `all`is not set to `true`, it returns a `Promise` for an `Object` with `address` and`family` properties.
			
 
				+     * @since v0.1.90
			
 
				+     */
			
 
				+    export function lookup(hostname: string, family: number, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
			
 
				+    export function lookup(hostname: string, options: LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
			
 
				+    export function lookup(hostname: string, options: LookupAllOptions, callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void): void;
			
 
				+    export function lookup(hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, address: string | LookupAddress[], family: number) => void): void;
			
 
				+    export function lookup(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
			
 
				+    export namespace lookup {
			
 
				+        function __promisify__(hostname: string, options: LookupAllOptions): Promise<LookupAddress[]>;
			
 
				+        function __promisify__(hostname: string, options?: LookupOneOptions | number): Promise<LookupAddress>;
			
 
				+        function __promisify__(hostname: string, options: LookupOptions): Promise<LookupAddress | LookupAddress[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Resolves the given `address` and `port` into a host name and service using
			
 
				+     * the operating system's underlying `getnameinfo` implementation.
			
 
				+     *
			
 
				+     * If `address` is not a valid IP address, a `TypeError` will be thrown.
			
 
				+     * The `port` will be coerced to a number. If it is not a legal port, a `TypeError`will be thrown.
			
 
				+     *
			
 
				+     * On an error, `err` is an `Error` object, where `err.code` is the error code.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const dns = require('dns');
			
 
				+     * dns.lookupService('127.0.0.1', 22, (err, hostname, service) => {
			
 
				+     *   console.log(hostname, service);
			
 
				+     *   // Prints: localhost ssh
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If this method is invoked as its `util.promisify()` ed version, it returns a`Promise` for an `Object` with `hostname` and `service` properties.
			
 
				+     * @since v0.11.14
			
 
				+     */
			
 
				+    export function lookupService(address: string, port: number, callback: (err: NodeJS.ErrnoException | null, hostname: string, service: string) => void): void;
			
 
				+    export namespace lookupService {
			
 
				+        function __promisify__(
			
 
				+            address: string,
			
 
				+            port: number
			
 
				+        ): Promise<{
			
 
				+            hostname: string;
			
 
				+            service: string;
			
 
				+        }>;
			
 
				+    }
			
 
				+    export interface ResolveOptions {
			
 
				+        ttl: boolean;
			
 
				+    }
			
 
				+    export interface ResolveWithTtlOptions extends ResolveOptions {
			
 
				+        ttl: true;
			
 
				+    }
			
 
				+    export interface RecordWithTtl {
			
 
				+        address: string;
			
 
				+        ttl: number;
			
 
				+    }
			
 
				+    /** @deprecated Use `AnyARecord` or `AnyAaaaRecord` instead. */
			
 
				+    export type AnyRecordWithTtl = AnyARecord | AnyAaaaRecord;
			
 
				+    export interface AnyARecord extends RecordWithTtl {
			
 
				+        type: 'A';
			
 
				+    }
			
 
				+    export interface AnyAaaaRecord extends RecordWithTtl {
			
 
				+        type: 'AAAA';
			
 
				+    }
			
 
				+    export interface CaaRecord {
			
 
				+        critial: number;
			
 
				+        issue?: string | undefined;
			
 
				+        issuewild?: string | undefined;
			
 
				+        iodef?: string | undefined;
			
 
				+        contactemail?: string | undefined;
			
 
				+        contactphone?: string | undefined;
			
 
				+    }
			
 
				+    export interface MxRecord {
			
 
				+        priority: number;
			
 
				+        exchange: string;
			
 
				+    }
			
 
				+    export interface AnyMxRecord extends MxRecord {
			
 
				+        type: 'MX';
			
 
				+    }
			
 
				+    export interface NaptrRecord {
			
 
				+        flags: string;
			
 
				+        service: string;
			
 
				+        regexp: string;
			
 
				+        replacement: string;
			
 
				+        order: number;
			
 
				+        preference: number;
			
 
				+    }
			
 
				+    export interface AnyNaptrRecord extends NaptrRecord {
			
 
				+        type: 'NAPTR';
			
 
				+    }
			
 
				+    export interface SoaRecord {
			
 
				+        nsname: string;
			
 
				+        hostmaster: string;
			
 
				+        serial: number;
			
 
				+        refresh: number;
			
 
				+        retry: number;
			
 
				+        expire: number;
			
 
				+        minttl: number;
			
 
				+    }
			
 
				+    export interface AnySoaRecord extends SoaRecord {
			
 
				+        type: 'SOA';
			
 
				+    }
			
 
				+    export interface SrvRecord {
			
 
				+        priority: number;
			
 
				+        weight: number;
			
 
				+        port: number;
			
 
				+        name: string;
			
 
				+    }
			
 
				+    export interface AnySrvRecord extends SrvRecord {
			
 
				+        type: 'SRV';
			
 
				+    }
			
 
				+    export interface AnyTxtRecord {
			
 
				+        type: 'TXT';
			
 
				+        entries: string[];
			
 
				+    }
			
 
				+    export interface AnyNsRecord {
			
 
				+        type: 'NS';
			
 
				+        value: string;
			
 
				+    }
			
 
				+    export interface AnyPtrRecord {
			
 
				+        type: 'PTR';
			
 
				+        value: string;
			
 
				+    }
			
 
				+    export interface AnyCnameRecord {
			
 
				+        type: 'CNAME';
			
 
				+        value: string;
			
 
				+    }
			
 
				+    export type AnyRecord = AnyARecord | AnyAaaaRecord | AnyCnameRecord | AnyMxRecord | AnyNaptrRecord | AnyNsRecord | AnyPtrRecord | AnySoaRecord | AnySrvRecord | AnyTxtRecord;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve a host name (e.g. `'nodejs.org'`) into an array
			
 
				+     * of the resource records. The `callback` function has arguments`(err, records)`. When successful, `records` will be an array of resource
			
 
				+     * records. The type and structure of individual results varies based on `rrtype`:
			
 
				+     *
			
 
				+     * <omitted>
			
 
				+     *
			
 
				+     * On error, `err` is an `Error` object, where `err.code` is one of the `DNS error codes`.
			
 
				+     * @since v0.1.27
			
 
				+     * @param hostname Host name to resolve.
			
 
				+     * @param [rrtype='A'] Resource record type.
			
 
				+     */
			
 
				+    export function resolve(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'A', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'AAAA', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'ANY', callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'CNAME', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'MX', callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'NAPTR', callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'NS', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'PTR', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'SOA', callback: (err: NodeJS.ErrnoException | null, addresses: SoaRecord) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'SRV', callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void;
			
 
				+    export function resolve(hostname: string, rrtype: 'TXT', callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void): void;
			
 
				+    export function resolve(
			
 
				+        hostname: string,
			
 
				+        rrtype: string,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, addresses: string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]) => void
			
 
				+    ): void;
			
 
				+    export namespace resolve {
			
 
				+        function __promisify__(hostname: string, rrtype?: 'A' | 'AAAA' | 'CNAME' | 'NS' | 'PTR'): Promise<string[]>;
			
 
				+        function __promisify__(hostname: string, rrtype: 'ANY'): Promise<AnyRecord[]>;
			
 
				+        function __promisify__(hostname: string, rrtype: 'MX'): Promise<MxRecord[]>;
			
 
				+        function __promisify__(hostname: string, rrtype: 'NAPTR'): Promise<NaptrRecord[]>;
			
 
				+        function __promisify__(hostname: string, rrtype: 'SOA'): Promise<SoaRecord>;
			
 
				+        function __promisify__(hostname: string, rrtype: 'SRV'): Promise<SrvRecord[]>;
			
 
				+        function __promisify__(hostname: string, rrtype: 'TXT'): Promise<string[][]>;
			
 
				+        function __promisify__(hostname: string, rrtype: string): Promise<string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve a IPv4 addresses (`A` records) for the`hostname`. The `addresses` argument passed to the `callback` function
			
 
				+     * will contain an array of IPv4 addresses (e.g.`['74.125.79.104', '74.125.79.105', '74.125.79.106']`).
			
 
				+     * @since v0.1.16
			
 
				+     * @param hostname Host name to resolve.
			
 
				+     */
			
 
				+    export function resolve4(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export function resolve4(hostname: string, options: ResolveWithTtlOptions, callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void): void;
			
 
				+    export function resolve4(hostname: string, options: ResolveOptions, callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void): void;
			
 
				+    export namespace resolve4 {
			
 
				+        function __promisify__(hostname: string): Promise<string[]>;
			
 
				+        function __promisify__(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
			
 
				+        function __promisify__(hostname: string, options?: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve a IPv6 addresses (`AAAA` records) for the`hostname`. The `addresses` argument passed to the `callback` function
			
 
				+     * will contain an array of IPv6 addresses.
			
 
				+     * @since v0.1.16
			
 
				+     * @param hostname Host name to resolve.
			
 
				+     */
			
 
				+    export function resolve6(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export function resolve6(hostname: string, options: ResolveWithTtlOptions, callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void): void;
			
 
				+    export function resolve6(hostname: string, options: ResolveOptions, callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void): void;
			
 
				+    export namespace resolve6 {
			
 
				+        function __promisify__(hostname: string): Promise<string[]>;
			
 
				+        function __promisify__(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
			
 
				+        function __promisify__(hostname: string, options?: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve `CNAME` records for the `hostname`. The`addresses` argument passed to the `callback` function
			
 
				+     * will contain an array of canonical name records available for the `hostname`(e.g. `['bar.example.com']`).
			
 
				+     * @since v0.3.2
			
 
				+     */
			
 
				+    export function resolveCname(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export namespace resolveCname {
			
 
				+        function __promisify__(hostname: string): Promise<string[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve `CAA` records for the `hostname`. The`addresses` argument passed to the `callback` function
			
 
				+     * will contain an array of certification authority authorization records
			
 
				+     * available for the `hostname` (e.g. `[{critical: 0, iodef: 'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]`).
			
 
				+     * @since v15.0.0, v14.17.0
			
 
				+     */
			
 
				+    export function resolveCaa(hostname: string, callback: (err: NodeJS.ErrnoException | null, records: CaaRecord[]) => void): void;
			
 
				+    export namespace resolveCaa {
			
 
				+        function __promisify__(hostname: string): Promise<CaaRecord[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve mail exchange records (`MX` records) for the`hostname`. The `addresses` argument passed to the `callback` function will
			
 
				+     * contain an array of objects containing both a `priority` and `exchange`property (e.g. `[{priority: 10, exchange: 'mx.example.com'}, ...]`).
			
 
				+     * @since v0.1.27
			
 
				+     */
			
 
				+    export function resolveMx(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void): void;
			
 
				+    export namespace resolveMx {
			
 
				+        function __promisify__(hostname: string): Promise<MxRecord[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve regular expression based records (`NAPTR`records) for the `hostname`. The `addresses` argument passed to the `callback`function will contain an array of
			
 
				+     * objects with the following properties:
			
 
				+     *
			
 
				+     * * `flags`
			
 
				+     * * `service`
			
 
				+     * * `regexp`
			
 
				+     * * `replacement`
			
 
				+     * * `order`
			
 
				+     * * `preference`
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * {
			
 
				+     *   flags: 's',
			
 
				+     *   service: 'SIP+D2U',
			
 
				+     *   regexp: '',
			
 
				+     *   replacement: '_sip._udp.example.com',
			
 
				+     *   order: 30,
			
 
				+     *   preference: 100
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v0.9.12
			
 
				+     */
			
 
				+    export function resolveNaptr(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void): void;
			
 
				+    export namespace resolveNaptr {
			
 
				+        function __promisify__(hostname: string): Promise<NaptrRecord[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve name server records (`NS` records) for the`hostname`. The `addresses` argument passed to the `callback` function will
			
 
				+     * contain an array of name server records available for `hostname`(e.g. `['ns1.example.com', 'ns2.example.com']`).
			
 
				+     * @since v0.1.90
			
 
				+     */
			
 
				+    export function resolveNs(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export namespace resolveNs {
			
 
				+        function __promisify__(hostname: string): Promise<string[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve pointer records (`PTR` records) for the`hostname`. The `addresses` argument passed to the `callback` function will
			
 
				+     * be an array of strings containing the reply records.
			
 
				+     * @since v6.0.0
			
 
				+     */
			
 
				+    export function resolvePtr(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
			
 
				+    export namespace resolvePtr {
			
 
				+        function __promisify__(hostname: string): Promise<string[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve a start of authority record (`SOA` record) for
			
 
				+     * the `hostname`. The `address` argument passed to the `callback` function will
			
 
				+     * be an object with the following properties:
			
 
				+     *
			
 
				+     * * `nsname`
			
 
				+     * * `hostmaster`
			
 
				+     * * `serial`
			
 
				+     * * `refresh`
			
 
				+     * * `retry`
			
 
				+     * * `expire`
			
 
				+     * * `minttl`
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * {
			
 
				+     *   nsname: 'ns.example.com',
			
 
				+     *   hostmaster: 'root.example.com',
			
 
				+     *   serial: 2013101809,
			
 
				+     *   refresh: 10000,
			
 
				+     *   retry: 2400,
			
 
				+     *   expire: 604800,
			
 
				+     *   minttl: 3600
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v0.11.10
			
 
				+     */
			
 
				+    export function resolveSoa(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: SoaRecord) => void): void;
			
 
				+    export namespace resolveSoa {
			
 
				+        function __promisify__(hostname: string): Promise<SoaRecord>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve service records (`SRV` records) for the`hostname`. The `addresses` argument passed to the `callback` function will
			
 
				+     * be an array of objects with the following properties:
			
 
				+     *
			
 
				+     * * `priority`
			
 
				+     * * `weight`
			
 
				+     * * `port`
			
 
				+     * * `name`
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * {
			
 
				+     *   priority: 10,
			
 
				+     *   weight: 5,
			
 
				+     *   port: 21223,
			
 
				+     *   name: 'service.example.com'
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v0.1.27
			
 
				+     */
			
 
				+    export function resolveSrv(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void;
			
 
				+    export namespace resolveSrv {
			
 
				+        function __promisify__(hostname: string): Promise<SrvRecord[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve text queries (`TXT` records) for the`hostname`. The `records` argument passed to the `callback` function is a
			
 
				+     * two-dimensional array of the text records available for `hostname` (e.g.`[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]`). Each sub-array contains TXT chunks of
			
 
				+     * one record. Depending on the use case, these could be either joined together or
			
 
				+     * treated separately.
			
 
				+     * @since v0.1.27
			
 
				+     */
			
 
				+    export function resolveTxt(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void): void;
			
 
				+    export namespace resolveTxt {
			
 
				+        function __promisify__(hostname: string): Promise<string[][]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve all records (also known as `ANY` or `*` query).
			
 
				+     * The `ret` argument passed to the `callback` function will be an array containing
			
 
				+     * various types of records. Each object has a property `type` that indicates the
			
 
				+     * type of the current record. And depending on the `type`, additional properties
			
 
				+     * will be present on the object:
			
 
				+     *
			
 
				+     * <omitted>
			
 
				+     *
			
 
				+     * Here is an example of the `ret` object passed to the callback:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * [ { type: 'A', address: '127.0.0.1', ttl: 299 },
			
 
				+     *   { type: 'CNAME', value: 'example.com' },
			
 
				+     *   { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
			
 
				+     *   { type: 'NS', value: 'ns1.example.com' },
			
 
				+     *   { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },
			
 
				+     *   { type: 'SOA',
			
 
				+     *     nsname: 'ns1.example.com',
			
 
				+     *     hostmaster: 'admin.example.com',
			
 
				+     *     serial: 156696742,
			
 
				+     *     refresh: 900,
			
 
				+     *     retry: 900,
			
 
				+     *     expire: 1800,
			
 
				+     *     minttl: 60 } ]
			
 
				+     * ```
			
 
				+     *
			
 
				+     * DNS server operators may choose not to respond to `ANY`queries. It may be better to call individual methods like {@link resolve4},{@link resolveMx}, and so on. For more details, see [RFC
			
 
				+     * 8482](https://tools.ietf.org/html/rfc8482).
			
 
				+     */
			
 
				+    export function resolveAny(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void;
			
 
				+    export namespace resolveAny {
			
 
				+        function __promisify__(hostname: string): Promise<AnyRecord[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an
			
 
				+     * array of host names.
			
 
				+     *
			
 
				+     * On error, `err` is an `Error` object, where `err.code` is
			
 
				+     * one of the `DNS error codes`.
			
 
				+     * @since v0.1.16
			
 
				+     */
			
 
				+    export function reverse(ip: string, callback: (err: NodeJS.ErrnoException | null, hostnames: string[]) => void): void;
			
 
				+    /**
			
 
				+     * Sets the IP address and port of servers to be used when performing DNS
			
 
				+     * resolution. The `servers` argument is an array of [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6) formatted
			
 
				+     * addresses. If the port is the IANA default DNS port (53) it can be omitted.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * dns.setServers([
			
 
				+     *   '4.4.4.4',
			
 
				+     *   '[2001:4860:4860::8888]',
			
 
				+     *   '4.4.4.4:1053',
			
 
				+     *   '[2001:4860:4860::8888]:1053',
			
 
				+     * ]);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * An error will be thrown if an invalid address is provided.
			
 
				+     *
			
 
				+     * The `dns.setServers()` method must not be called while a DNS query is in
			
 
				+     * progress.
			
 
				+     *
			
 
				+     * The {@link setServers} method affects only {@link resolve},`dns.resolve*()` and {@link reverse} (and specifically _not_ {@link lookup}).
			
 
				+     *
			
 
				+     * This method works much like [resolve.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
			
 
				+     * That is, if attempting to resolve with the first server provided results in a`NOTFOUND` error, the `resolve()` method will _not_ attempt to resolve with
			
 
				+     * subsequent servers provided. Fallback DNS servers will only be used if the
			
 
				+     * earlier ones time out or result in some other error.
			
 
				+     * @since v0.11.3
			
 
				+     * @param servers array of `RFC 5952` formatted addresses
			
 
				+     */
			
 
				+    export function setServers(servers: ReadonlyArray<string>): void;
			
 
				+    /**
			
 
				+     * Returns an array of IP address strings, formatted according to [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6),
			
 
				+     * that are currently configured for DNS resolution. A string will include a port
			
 
				+     * section if a custom port is used.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * [
			
 
				+     *   '4.4.4.4',
			
 
				+     *   '2001:4860:4860::8888',
			
 
				+     *   '4.4.4.4:1053',
			
 
				+     *   '[2001:4860:4860::8888]:1053',
			
 
				+     * ]
			
 
				+     * ```
			
 
				+     * @since v0.11.3
			
 
				+     */
			
 
				+    export function getServers(): string[];
			
 
				+    /**
			
 
				+     * Set the default value of `verbatim` in {@link lookup} and `dnsPromises.lookup()`. The value could be:
			
 
				+     *
			
 
				+     * * `ipv4first`: sets default `verbatim` `false`.
			
 
				+     * * `verbatim`: sets default `verbatim` `true`.
			
 
				+     *
			
 
				+     * The default is `ipv4first` and {@link setDefaultResultOrder} have higher
			
 
				+     * priority than `--dns-result-order`. When using `worker threads`,{@link setDefaultResultOrder} from the main thread won't affect the default
			
 
				+     * dns orders in workers.
			
 
				+     * @since v16.4.0, v14.18.0
			
 
				+     * @param order must be `'ipv4first'` or `'verbatim'`.
			
 
				+     */
			
 
				+    export function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
			
 
				+    // Error codes
			
 
				+    export const NODATA: string;
			
 
				+    export const FORMERR: string;
			
 
				+    export const SERVFAIL: string;
			
 
				+    export const NOTFOUND: string;
			
 
				+    export const NOTIMP: string;
			
 
				+    export const REFUSED: string;
			
 
				+    export const BADQUERY: string;
			
 
				+    export const BADNAME: string;
			
 
				+    export const BADFAMILY: string;
			
 
				+    export const BADRESP: string;
			
 
				+    export const CONNREFUSED: string;
			
 
				+    export const TIMEOUT: string;
			
 
				+    export const EOF: string;
			
 
				+    export const FILE: string;
			
 
				+    export const NOMEM: string;
			
 
				+    export const DESTRUCTION: string;
			
 
				+    export const BADSTR: string;
			
 
				+    export const BADFLAGS: string;
			
 
				+    export const NONAME: string;
			
 
				+    export const BADHINTS: string;
			
 
				+    export const NOTINITIALIZED: string;
			
 
				+    export const LOADIPHLPAPI: string;
			
 
				+    export const ADDRGETNETWORKPARAMS: string;
			
 
				+    export const CANCELLED: string;
			
 
				+    export interface ResolverOptions {
			
 
				+        timeout?: number | undefined;
			
 
				+        /**
			
 
				+         * @default 4
			
 
				+         */
			
 
				+        tries?: number;
			
 
				+    }
			
 
				+    /**
			
 
				+     * An independent resolver for DNS requests.
			
 
				+     *
			
 
				+     * Creating a new resolver uses the default server settings. Setting
			
 
				+     * the servers used for a resolver using `resolver.setServers()` does not affect
			
 
				+     * other resolvers:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { Resolver } = require('dns');
			
 
				+     * const resolver = new Resolver();
			
 
				+     * resolver.setServers(['4.4.4.4']);
			
 
				+     *
			
 
				+     * // This request will use the server at 4.4.4.4, independent of global settings.
			
 
				+     * resolver.resolve4('example.org', (err, addresses) => {
			
 
				+     *   // ...
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The following methods from the `dns` module are available:
			
 
				+     *
			
 
				+     * * `resolver.getServers()`
			
 
				+     * * `resolver.resolve()`
			
 
				+     * * `resolver.resolve4()`
			
 
				+     * * `resolver.resolve6()`
			
 
				+     * * `resolver.resolveAny()`
			
 
				+     * * `resolver.resolveCaa()`
			
 
				+     * * `resolver.resolveCname()`
			
 
				+     * * `resolver.resolveMx()`
			
 
				+     * * `resolver.resolveNaptr()`
			
 
				+     * * `resolver.resolveNs()`
			
 
				+     * * `resolver.resolvePtr()`
			
 
				+     * * `resolver.resolveSoa()`
			
 
				+     * * `resolver.resolveSrv()`
			
 
				+     * * `resolver.resolveTxt()`
			
 
				+     * * `resolver.reverse()`
			
 
				+     * * `resolver.setServers()`
			
 
				+     * @since v8.3.0
			
 
				+     */
			
 
				+    export class Resolver {
			
 
				+        constructor(options?: ResolverOptions);
			
 
				+        /**
			
 
				+         * Cancel all outstanding DNS queries made by this resolver. The corresponding
			
 
				+         * callbacks will be called with an error with code `ECANCELLED`.
			
 
				+         * @since v8.3.0
			
 
				+         */
			
 
				+        cancel(): void;
			
 
				+        getServers: typeof getServers;
			
 
				+        resolve: typeof resolve;
			
 
				+        resolve4: typeof resolve4;
			
 
				+        resolve6: typeof resolve6;
			
 
				+        resolveAny: typeof resolveAny;
			
 
				+        resolveCname: typeof resolveCname;
			
 
				+        resolveMx: typeof resolveMx;
			
 
				+        resolveNaptr: typeof resolveNaptr;
			
 
				+        resolveNs: typeof resolveNs;
			
 
				+        resolvePtr: typeof resolvePtr;
			
 
				+        resolveSoa: typeof resolveSoa;
			
 
				+        resolveSrv: typeof resolveSrv;
			
 
				+        resolveTxt: typeof resolveTxt;
			
 
				+        reverse: typeof reverse;
			
 
				+        /**
			
 
				+         * The resolver instance will send its requests from the specified IP address.
			
 
				+         * This allows programs to specify outbound interfaces when used on multi-homed
			
 
				+         * systems.
			
 
				+         *
			
 
				+         * If a v4 or v6 address is not specified, it is set to the default, and the
			
 
				+         * operating system will choose a local address automatically.
			
 
				+         *
			
 
				+         * The resolver will use the v4 local address when making requests to IPv4 DNS
			
 
				+         * servers, and the v6 local address when making requests to IPv6 DNS servers.
			
 
				+         * The `rrtype` of resolution requests has no impact on the local address used.
			
 
				+         * @since v15.1.0, v14.17.0
			
 
				+         * @param [ipv4='0.0.0.0'] A string representation of an IPv4 address.
			
 
				+         * @param [ipv6='::0'] A string representation of an IPv6 address.
			
 
				+         */
			
 
				+        setLocalAddress(ipv4?: string, ipv6?: string): void;
			
 
				+        setServers: typeof setServers;
			
 
				+    }
			
 
				+    export { dnsPromises as promises };
			
 
				+}
			
 
				+declare module 'node:dns' {
			
 
				+    export * from 'dns';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/dns/promises.d.ts
+++ b/Asistent/node_modules/@types/node/dns/promises.d.ts
@@ -0,0 +1,370 @@
 
				+/**
			
 
				+ * The `dns.promises` API provides an alternative set of asynchronous DNS methods
			
 
				+ * that return `Promise` objects rather than using callbacks. The API is accessible
			
 
				+ * via `require('dns').promises` or `require('dns/promises')`.
			
 
				+ * @since v10.6.0
			
 
				+ */
			
 
				+declare module 'dns/promises' {
			
 
				+    import {
			
 
				+        LookupAddress,
			
 
				+        LookupOneOptions,
			
 
				+        LookupAllOptions,
			
 
				+        LookupOptions,
			
 
				+        AnyRecord,
			
 
				+        CaaRecord,
			
 
				+        MxRecord,
			
 
				+        NaptrRecord,
			
 
				+        SoaRecord,
			
 
				+        SrvRecord,
			
 
				+        ResolveWithTtlOptions,
			
 
				+        RecordWithTtl,
			
 
				+        ResolveOptions,
			
 
				+        ResolverOptions,
			
 
				+    } from 'node:dns';
			
 
				+    /**
			
 
				+     * Returns an array of IP address strings, formatted according to [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6),
			
 
				+     * that are currently configured for DNS resolution. A string will include a port
			
 
				+     * section if a custom port is used.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * [
			
 
				+     *   '4.4.4.4',
			
 
				+     *   '2001:4860:4860::8888',
			
 
				+     *   '4.4.4.4:1053',
			
 
				+     *   '[2001:4860:4860::8888]:1053',
			
 
				+     * ]
			
 
				+     * ```
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function getServers(): string[];
			
 
				+    /**
			
 
				+     * Resolves a host name (e.g. `'nodejs.org'`) into the first found A (IPv4) or
			
 
				+     * AAAA (IPv6) record. All `option` properties are optional. If `options` is an
			
 
				+     * integer, then it must be `4` or `6` – if `options` is not provided, then IPv4
			
 
				+     * and IPv6 addresses are both returned if found.
			
 
				+     *
			
 
				+     * With the `all` option set to `true`, the `Promise` is resolved with `addresses`being an array of objects with the properties `address` and `family`.
			
 
				+     *
			
 
				+     * On error, the `Promise` is rejected with an `Error` object, where `err.code`is the error code.
			
 
				+     * Keep in mind that `err.code` will be set to `'ENOTFOUND'` not only when
			
 
				+     * the host name does not exist but also when the lookup fails in other ways
			
 
				+     * such as no available file descriptors.
			
 
				+     *
			
 
				+     * `dnsPromises.lookup()` does not necessarily have anything to do with the DNS
			
 
				+     * protocol. The implementation uses an operating system facility that can
			
 
				+     * associate names with addresses, and vice versa. This implementation can have
			
 
				+     * subtle but important consequences on the behavior of any Node.js program. Please
			
 
				+     * take some time to consult the `Implementation considerations section` before
			
 
				+     * using `dnsPromises.lookup()`.
			
 
				+     *
			
 
				+     * Example usage:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const dns = require('dns');
			
 
				+     * const dnsPromises = dns.promises;
			
 
				+     * const options = {
			
 
				+     *   family: 6,
			
 
				+     *   hints: dns.ADDRCONFIG | dns.V4MAPPED,
			
 
				+     * };
			
 
				+     *
			
 
				+     * dnsPromises.lookup('example.com', options).then((result) => {
			
 
				+     *   console.log('address: %j family: IPv%s', result.address, result.family);
			
 
				+     *   // address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6
			
 
				+     * });
			
 
				+     *
			
 
				+     * // When options.all is true, the result will be an Array.
			
 
				+     * options.all = true;
			
 
				+     * dnsPromises.lookup('example.com', options).then((result) => {
			
 
				+     *   console.log('addresses: %j', result);
			
 
				+     *   // addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function lookup(hostname: string, family: number): Promise<LookupAddress>;
			
 
				+    function lookup(hostname: string, options: LookupOneOptions): Promise<LookupAddress>;
			
 
				+    function lookup(hostname: string, options: LookupAllOptions): Promise<LookupAddress[]>;
			
 
				+    function lookup(hostname: string, options: LookupOptions): Promise<LookupAddress | LookupAddress[]>;
			
 
				+    function lookup(hostname: string): Promise<LookupAddress>;
			
 
				+    /**
			
 
				+     * Resolves the given `address` and `port` into a host name and service using
			
 
				+     * the operating system's underlying `getnameinfo` implementation.
			
 
				+     *
			
 
				+     * If `address` is not a valid IP address, a `TypeError` will be thrown.
			
 
				+     * The `port` will be coerced to a number. If it is not a legal port, a `TypeError`will be thrown.
			
 
				+     *
			
 
				+     * On error, the `Promise` is rejected with an `Error` object, where `err.code`is the error code.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const dnsPromises = require('dns').promises;
			
 
				+     * dnsPromises.lookupService('127.0.0.1', 22).then((result) => {
			
 
				+     *   console.log(result.hostname, result.service);
			
 
				+     *   // Prints: localhost ssh
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function lookupService(
			
 
				+        address: string,
			
 
				+        port: number
			
 
				+    ): Promise<{
			
 
				+        hostname: string;
			
 
				+        service: string;
			
 
				+    }>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve a host name (e.g. `'nodejs.org'`) into an array
			
 
				+     * of the resource records. When successful, the `Promise` is resolved with an
			
 
				+     * array of resource records. The type and structure of individual results vary
			
 
				+     * based on `rrtype`:
			
 
				+     *
			
 
				+     * <omitted>
			
 
				+     *
			
 
				+     * On error, the `Promise` is rejected with an `Error` object, where `err.code`is one of the `DNS error codes`.
			
 
				+     * @since v10.6.0
			
 
				+     * @param hostname Host name to resolve.
			
 
				+     * @param [rrtype='A'] Resource record type.
			
 
				+     */
			
 
				+    function resolve(hostname: string): Promise<string[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'A'): Promise<string[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'AAAA'): Promise<string[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'ANY'): Promise<AnyRecord[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'CAA'): Promise<CaaRecord[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'CNAME'): Promise<string[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'MX'): Promise<MxRecord[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'NAPTR'): Promise<NaptrRecord[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'NS'): Promise<string[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'PTR'): Promise<string[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'SOA'): Promise<SoaRecord>;
			
 
				+    function resolve(hostname: string, rrtype: 'SRV'): Promise<SrvRecord[]>;
			
 
				+    function resolve(hostname: string, rrtype: 'TXT'): Promise<string[][]>;
			
 
				+    function resolve(hostname: string, rrtype: string): Promise<string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve IPv4 addresses (`A` records) for the`hostname`. On success, the `Promise` is resolved with an array of IPv4
			
 
				+     * addresses (e.g. `['74.125.79.104', '74.125.79.105', '74.125.79.106']`).
			
 
				+     * @since v10.6.0
			
 
				+     * @param hostname Host name to resolve.
			
 
				+     */
			
 
				+    function resolve4(hostname: string): Promise<string[]>;
			
 
				+    function resolve4(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
			
 
				+    function resolve4(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve IPv6 addresses (`AAAA` records) for the`hostname`. On success, the `Promise` is resolved with an array of IPv6
			
 
				+     * addresses.
			
 
				+     * @since v10.6.0
			
 
				+     * @param hostname Host name to resolve.
			
 
				+     */
			
 
				+    function resolve6(hostname: string): Promise<string[]>;
			
 
				+    function resolve6(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
			
 
				+    function resolve6(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve all records (also known as `ANY` or `*` query).
			
 
				+     * On success, the `Promise` is resolved with an array containing various types of
			
 
				+     * records. Each object has a property `type` that indicates the type of the
			
 
				+     * current record. And depending on the `type`, additional properties will be
			
 
				+     * present on the object:
			
 
				+     *
			
 
				+     * <omitted>
			
 
				+     *
			
 
				+     * Here is an example of the result object:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * [ { type: 'A', address: '127.0.0.1', ttl: 299 },
			
 
				+     *   { type: 'CNAME', value: 'example.com' },
			
 
				+     *   { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
			
 
				+     *   { type: 'NS', value: 'ns1.example.com' },
			
 
				+     *   { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },
			
 
				+     *   { type: 'SOA',
			
 
				+     *     nsname: 'ns1.example.com',
			
 
				+     *     hostmaster: 'admin.example.com',
			
 
				+     *     serial: 156696742,
			
 
				+     *     refresh: 900,
			
 
				+     *     retry: 900,
			
 
				+     *     expire: 1800,
			
 
				+     *     minttl: 60 } ]
			
 
				+     * ```
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function resolveAny(hostname: string): Promise<AnyRecord[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve `CAA` records for the `hostname`. On success,
			
 
				+     * the `Promise` is resolved with an array of objects containing available
			
 
				+     * certification authority authorization records available for the `hostname`(e.g. `[{critical: 0, iodef: 'mailto:pki@example.com'},{critical: 128, issue: 'pki.example.com'}]`).
			
 
				+     * @since v15.0.0, v14.17.0
			
 
				+     */
			
 
				+    function resolveCaa(hostname: string): Promise<CaaRecord[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve `CNAME` records for the `hostname`. On success,
			
 
				+     * the `Promise` is resolved with an array of canonical name records available for
			
 
				+     * the `hostname` (e.g. `['bar.example.com']`).
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function resolveCname(hostname: string): Promise<string[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve mail exchange records (`MX` records) for the`hostname`. On success, the `Promise` is resolved with an array of objects
			
 
				+     * containing both a `priority` and `exchange` property (e.g.`[{priority: 10, exchange: 'mx.example.com'}, ...]`).
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function resolveMx(hostname: string): Promise<MxRecord[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve regular expression based records (`NAPTR`records) for the `hostname`. On success, the `Promise` is resolved with an array
			
 
				+     * of objects with the following properties:
			
 
				+     *
			
 
				+     * * `flags`
			
 
				+     * * `service`
			
 
				+     * * `regexp`
			
 
				+     * * `replacement`
			
 
				+     * * `order`
			
 
				+     * * `preference`
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * {
			
 
				+     *   flags: 's',
			
 
				+     *   service: 'SIP+D2U',
			
 
				+     *   regexp: '',
			
 
				+     *   replacement: '_sip._udp.example.com',
			
 
				+     *   order: 30,
			
 
				+     *   preference: 100
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function resolveNaptr(hostname: string): Promise<NaptrRecord[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve name server records (`NS` records) for the`hostname`. On success, the `Promise` is resolved with an array of name server
			
 
				+     * records available for `hostname` (e.g.`['ns1.example.com', 'ns2.example.com']`).
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function resolveNs(hostname: string): Promise<string[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve pointer records (`PTR` records) for the`hostname`. On success, the `Promise` is resolved with an array of strings
			
 
				+     * containing the reply records.
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function resolvePtr(hostname: string): Promise<string[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve a start of authority record (`SOA` record) for
			
 
				+     * the `hostname`. On success, the `Promise` is resolved with an object with the
			
 
				+     * following properties:
			
 
				+     *
			
 
				+     * * `nsname`
			
 
				+     * * `hostmaster`
			
 
				+     * * `serial`
			
 
				+     * * `refresh`
			
 
				+     * * `retry`
			
 
				+     * * `expire`
			
 
				+     * * `minttl`
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * {
			
 
				+     *   nsname: 'ns.example.com',
			
 
				+     *   hostmaster: 'root.example.com',
			
 
				+     *   serial: 2013101809,
			
 
				+     *   refresh: 10000,
			
 
				+     *   retry: 2400,
			
 
				+     *   expire: 604800,
			
 
				+     *   minttl: 3600
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function resolveSoa(hostname: string): Promise<SoaRecord>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve service records (`SRV` records) for the`hostname`. On success, the `Promise` is resolved with an array of objects with
			
 
				+     * the following properties:
			
 
				+     *
			
 
				+     * * `priority`
			
 
				+     * * `weight`
			
 
				+     * * `port`
			
 
				+     * * `name`
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * {
			
 
				+     *   priority: 10,
			
 
				+     *   weight: 5,
			
 
				+     *   port: 21223,
			
 
				+     *   name: 'service.example.com'
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function resolveSrv(hostname: string): Promise<SrvRecord[]>;
			
 
				+    /**
			
 
				+     * Uses the DNS protocol to resolve text queries (`TXT` records) for the`hostname`. On success, the `Promise` is resolved with a two-dimensional array
			
 
				+     * of the text records available for `hostname` (e.g.`[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]`). Each sub-array contains TXT chunks of
			
 
				+     * one record. Depending on the use case, these could be either joined together or
			
 
				+     * treated separately.
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function resolveTxt(hostname: string): Promise<string[][]>;
			
 
				+    /**
			
 
				+     * Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an
			
 
				+     * array of host names.
			
 
				+     *
			
 
				+     * On error, the `Promise` is rejected with an `Error` object, where `err.code`is one of the `DNS error codes`.
			
 
				+     * @since v10.6.0
			
 
				+     */
			
 
				+    function reverse(ip: string): Promise<string[]>;
			
 
				+    /**
			
 
				+     * Sets the IP address and port of servers to be used when performing DNS
			
 
				+     * resolution. The `servers` argument is an array of [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6) formatted
			
 
				+     * addresses. If the port is the IANA default DNS port (53) it can be omitted.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * dnsPromises.setServers([
			
 
				+     *   '4.4.4.4',
			
 
				+     *   '[2001:4860:4860::8888]',
			
 
				+     *   '4.4.4.4:1053',
			
 
				+     *   '[2001:4860:4860::8888]:1053',
			
 
				+     * ]);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * An error will be thrown if an invalid address is provided.
			
 
				+     *
			
 
				+     * The `dnsPromises.setServers()` method must not be called while a DNS query is in
			
 
				+     * progress.
			
 
				+     *
			
 
				+     * This method works much like [resolve.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
			
 
				+     * That is, if attempting to resolve with the first server provided results in a`NOTFOUND` error, the `resolve()` method will _not_ attempt to resolve with
			
 
				+     * subsequent servers provided. Fallback DNS servers will only be used if the
			
 
				+     * earlier ones time out or result in some other error.
			
 
				+     * @since v10.6.0
			
 
				+     * @param servers array of `RFC 5952` formatted addresses
			
 
				+     */
			
 
				+    function setServers(servers: ReadonlyArray<string>): void;
			
 
				+    /**
			
 
				+     * Set the default value of `verbatim` in `dns.lookup()` and `dnsPromises.lookup()`. The value could be:
			
 
				+     *
			
 
				+     * * `ipv4first`: sets default `verbatim` `false`.
			
 
				+     * * `verbatim`: sets default `verbatim` `true`.
			
 
				+     *
			
 
				+     * The default is `ipv4first` and `dnsPromises.setDefaultResultOrder()` have
			
 
				+     * higher priority than `--dns-result-order`. When using `worker threads`,`dnsPromises.setDefaultResultOrder()` from the main thread won't affect the
			
 
				+     * default dns orders in workers.
			
 
				+     * @since v16.4.0, v14.18.0
			
 
				+     * @param order must be `'ipv4first'` or `'verbatim'`.
			
 
				+     */
			
 
				+    function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
			
 
				+    class Resolver {
			
 
				+        constructor(options?: ResolverOptions);
			
 
				+        cancel(): void;
			
 
				+        getServers: typeof getServers;
			
 
				+        resolve: typeof resolve;
			
 
				+        resolve4: typeof resolve4;
			
 
				+        resolve6: typeof resolve6;
			
 
				+        resolveAny: typeof resolveAny;
			
 
				+        resolveCname: typeof resolveCname;
			
 
				+        resolveMx: typeof resolveMx;
			
 
				+        resolveNaptr: typeof resolveNaptr;
			
 
				+        resolveNs: typeof resolveNs;
			
 
				+        resolvePtr: typeof resolvePtr;
			
 
				+        resolveSoa: typeof resolveSoa;
			
 
				+        resolveSrv: typeof resolveSrv;
			
 
				+        resolveTxt: typeof resolveTxt;
			
 
				+        reverse: typeof reverse;
			
 
				+        setLocalAddress(ipv4?: string, ipv6?: string): void;
			
 
				+        setServers: typeof setServers;
			
 
				+    }
			
 
				+}
			
 
				+declare module 'node:dns/promises' {
			
 
				+    export * from 'dns/promises';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/dom-events.d.ts
+++ b/Asistent/node_modules/@types/node/dom-events.d.ts
@@ -0,0 +1,126 @@
 
				+export {}; // Don't export anything!
			
 
				+
			
 
				+//// DOM-like Events
			
 
				+// NB: The Event / EventTarget / EventListener implementations below were copied
			
 
				+// from lib.dom.d.ts, then edited to reflect Node's documentation at
			
 
				+// https://nodejs.org/api/events.html#class-eventtarget.
			
 
				+// Please read that link to understand important implementation differences.
			
 
				+
			
 
				+// This conditional type will be the existing global Event in a browser, or
			
 
				+// the copy below in a Node environment.
			
 
				+type __Event = typeof globalThis extends { onmessage: any, Event: any }
			
 
				+? {}
			
 
				+: {
			
 
				+    /** This is not used in Node.js and is provided purely for completeness. */
			
 
				+    readonly bubbles: boolean;
			
 
				+    /** Alias for event.stopPropagation(). This is not used in Node.js and is provided purely for completeness. */
			
 
				+    cancelBubble: () => void;
			
 
				+    /** True if the event was created with the cancelable option */
			
 
				+    readonly cancelable: boolean;
			
 
				+    /** This is not used in Node.js and is provided purely for completeness. */
			
 
				+    readonly composed: boolean;
			
 
				+    /** Returns an array containing the current EventTarget as the only entry or empty if the event is not being dispatched. This is not used in Node.js and is provided purely for completeness. */
			
 
				+    composedPath(): [EventTarget?]
			
 
				+    /** Alias for event.target. */
			
 
				+    readonly currentTarget: EventTarget | null;
			
 
				+    /** Is true if cancelable is true and event.preventDefault() has been called. */
			
 
				+    readonly defaultPrevented: boolean;
			
 
				+    /** This is not used in Node.js and is provided purely for completeness. */
			
 
				+    readonly eventPhase: 0 | 2;
			
 
				+    /** The `AbortSignal` "abort" event is emitted with `isTrusted` set to `true`. The value is `false` in all other cases. */
			
 
				+    readonly isTrusted: boolean;
			
 
				+    /** Sets the `defaultPrevented` property to `true` if `cancelable` is `true`. */
			
 
				+    preventDefault(): void;
			
 
				+    /** This is not used in Node.js and is provided purely for completeness. */
			
 
				+    returnValue: boolean;
			
 
				+    /** Alias for event.target. */
			
 
				+    readonly srcElement: EventTarget | null;
			
 
				+    /** Stops the invocation of event listeners after the current one completes. */
			
 
				+    stopImmediatePropagation(): void;
			
 
				+    /** This is not used in Node.js and is provided purely for completeness. */
			
 
				+    stopPropagation(): void;
			
 
				+    /** The `EventTarget` dispatching the event */
			
 
				+    readonly target: EventTarget | null;
			
 
				+    /** The millisecond timestamp when the Event object was created. */
			
 
				+    readonly timeStamp: number;
			
 
				+    /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
			
 
				+    readonly type: string;
			
 
				+};
			
 
				+
			
 
				+// See comment above explaining conditional type
			
 
				+type __EventTarget = typeof globalThis extends { onmessage: any, EventTarget: any }
			
 
				+? {}
			
 
				+: {
			
 
				+    /**
			
 
				+     * Adds a new handler for the `type` event. Any given `listener` is added only once per `type` and per `capture` option value.
			
 
				+     *
			
 
				+     * If the `once` option is true, the `listener` is removed after the next time a `type` event is dispatched.
			
 
				+     *
			
 
				+     * The `capture` option is not used by Node.js in any functional way other than tracking registered event listeners per the `EventTarget` specification.
			
 
				+     * Specifically, the `capture` option is used as part of the key when registering a `listener`.
			
 
				+     * Any individual `listener` may be added once with `capture = false`, and once with `capture = true`.
			
 
				+     */
			
 
				+    addEventListener(
			
 
				+        type: string,
			
 
				+        listener: EventListener | EventListenerObject,
			
 
				+        options?: AddEventListenerOptions | boolean,
			
 
				+    ): void;
			
 
				+    /** Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise. */
			
 
				+    dispatchEvent(event: Event): boolean;
			
 
				+    /** Removes the event listener in target's event listener list with the same type, callback, and options. */
			
 
				+    removeEventListener(
			
 
				+        type: string,
			
 
				+        listener: EventListener | EventListenerObject,
			
 
				+        options?: EventListenerOptions | boolean,
			
 
				+    ): void;
			
 
				+};
			
 
				+
			
 
				+interface EventInit {
			
 
				+    bubbles?: boolean;
			
 
				+    cancelable?: boolean;
			
 
				+    composed?: boolean;
			
 
				+}
			
 
				+
			
 
				+interface EventListenerOptions {
			
 
				+    /** Not directly used by Node.js. Added for API completeness. Default: `false`. */
			
 
				+    capture?: boolean;
			
 
				+}
			
 
				+
			
 
				+interface AddEventListenerOptions extends EventListenerOptions {
			
 
				+    /** When `true`, the listener is automatically removed when it is first invoked. Default: `false`. */
			
 
				+    once?: boolean;
			
 
				+    /** When `true`, serves as a hint that the listener will not call the `Event` object's `preventDefault()` method. Default: false. */
			
 
				+    passive?: boolean;
			
 
				+}
			
 
				+
			
 
				+interface EventListener {
			
 
				+    (evt: Event): void;
			
 
				+}
			
 
				+
			
 
				+interface EventListenerObject {
			
 
				+    handleEvent(object: Event): void;
			
 
				+}
			
 
				+
			
 
				+import {} from 'events';    // Make this an ambient declaration
			
 
				+declare global {
			
 
				+    /** An event which takes place in the DOM. */
			
 
				+    interface Event extends __Event {}
			
 
				+    var Event: typeof globalThis extends { onmessage: any, Event: infer T }
			
 
				+        ? T
			
 
				+        : {
			
 
				+            prototype: __Event;
			
 
				+            new (type: string, eventInitDict?: EventInit): __Event;
			
 
				+        };
			
 
				+
			
 
				+    /**
			
 
				+     * EventTarget is a DOM interface implemented by objects that can
			
 
				+     * receive events and may have listeners for them.
			
 
				+     */
			
 
				+    interface EventTarget extends __EventTarget {}
			
 
				+    var EventTarget: typeof globalThis extends { onmessage: any, EventTarget: infer T }
			
 
				+        ? T
			
 
				+        : {
			
 
				+            prototype: __EventTarget;
			
 
				+            new (): __EventTarget;
			
 
				+        };
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/domain.d.ts
+++ b/Asistent/node_modules/@types/node/domain.d.ts
@@ -0,0 +1,170 @@
 
				+/**
			
 
				+ * **This module is pending deprecation.** Once a replacement API has been
			
 
				+ * finalized, this module will be fully deprecated. Most developers should
			
 
				+ * **not** have cause to use this module. Users who absolutely must have
			
 
				+ * the functionality that domains provide may rely on it for the time being
			
 
				+ * but should expect to have to migrate to a different solution
			
 
				+ * in the future.
			
 
				+ *
			
 
				+ * Domains provide a way to handle multiple different IO operations as a
			
 
				+ * single group. If any of the event emitters or callbacks registered to a
			
 
				+ * domain emit an `'error'` event, or throw an error, then the domain object
			
 
				+ * will be notified, rather than losing the context of the error in the`process.on('uncaughtException')` handler, or causing the program to
			
 
				+ * exit immediately with an error code.
			
 
				+ * @deprecated Since v1.4.2 - Deprecated
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/domain.js)
			
 
				+ */
			
 
				+declare module 'domain' {
			
 
				+    import EventEmitter = require('node:events');
			
 
				+    /**
			
 
				+     * The `Domain` class encapsulates the functionality of routing errors and
			
 
				+     * uncaught exceptions to the active `Domain` object.
			
 
				+     *
			
 
				+     * To handle the errors that it catches, listen to its `'error'` event.
			
 
				+     */
			
 
				+    class Domain extends EventEmitter {
			
 
				+        /**
			
 
				+         * An array of timers and event emitters that have been explicitly added
			
 
				+         * to the domain.
			
 
				+         */
			
 
				+        members: Array<EventEmitter | NodeJS.Timer>;
			
 
				+        /**
			
 
				+         * The `enter()` method is plumbing used by the `run()`, `bind()`, and`intercept()` methods to set the active domain. It sets `domain.active` and`process.domain` to the domain, and implicitly
			
 
				+         * pushes the domain onto the domain
			
 
				+         * stack managed by the domain module (see {@link exit} for details on the
			
 
				+         * domain stack). The call to `enter()` delimits the beginning of a chain of
			
 
				+         * asynchronous calls and I/O operations bound to a domain.
			
 
				+         *
			
 
				+         * Calling `enter()` changes only the active domain, and does not alter the domain
			
 
				+         * itself. `enter()` and `exit()` can be called an arbitrary number of times on a
			
 
				+         * single domain.
			
 
				+         */
			
 
				+        enter(): void;
			
 
				+        /**
			
 
				+         * The `exit()` method exits the current domain, popping it off the domain stack.
			
 
				+         * Any time execution is going to switch to the context of a different chain of
			
 
				+         * asynchronous calls, it's important to ensure that the current domain is exited.
			
 
				+         * The call to `exit()` delimits either the end of or an interruption to the chain
			
 
				+         * of asynchronous calls and I/O operations bound to a domain.
			
 
				+         *
			
 
				+         * If there are multiple, nested domains bound to the current execution context,`exit()` will exit any domains nested within this domain.
			
 
				+         *
			
 
				+         * Calling `exit()` changes only the active domain, and does not alter the domain
			
 
				+         * itself. `enter()` and `exit()` can be called an arbitrary number of times on a
			
 
				+         * single domain.
			
 
				+         */
			
 
				+        exit(): void;
			
 
				+        /**
			
 
				+         * Run the supplied function in the context of the domain, implicitly
			
 
				+         * binding all event emitters, timers, and lowlevel requests that are
			
 
				+         * created in that context. Optionally, arguments can be passed to
			
 
				+         * the function.
			
 
				+         *
			
 
				+         * This is the most basic way to use a domain.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const domain = require('domain');
			
 
				+         * const fs = require('fs');
			
 
				+         * const d = domain.create();
			
 
				+         * d.on('error', (er) => {
			
 
				+         *   console.error('Caught error!', er);
			
 
				+         * });
			
 
				+         * d.run(() => {
			
 
				+         *   process.nextTick(() => {
			
 
				+         *     setTimeout(() => { // Simulating some various async stuff
			
 
				+         *       fs.open('non-existent file', 'r', (er, fd) => {
			
 
				+         *         if (er) throw er;
			
 
				+         *         // proceed...
			
 
				+         *       });
			
 
				+         *     }, 100);
			
 
				+         *   });
			
 
				+         * });
			
 
				+         * ```
			
 
				+         *
			
 
				+         * In this example, the `d.on('error')` handler will be triggered, rather
			
 
				+         * than crashing the program.
			
 
				+         */
			
 
				+        run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
			
 
				+        /**
			
 
				+         * Explicitly adds an emitter to the domain. If any event handlers called by
			
 
				+         * the emitter throw an error, or if the emitter emits an `'error'` event, it
			
 
				+         * will be routed to the domain's `'error'` event, just like with implicit
			
 
				+         * binding.
			
 
				+         *
			
 
				+         * This also works with timers that are returned from `setInterval()` and `setTimeout()`. If their callback function throws, it will be caught by
			
 
				+         * the domain `'error'` handler.
			
 
				+         *
			
 
				+         * If the Timer or `EventEmitter` was already bound to a domain, it is removed
			
 
				+         * from that one, and bound to this one instead.
			
 
				+         * @param emitter emitter or timer to be added to the domain
			
 
				+         */
			
 
				+        add(emitter: EventEmitter | NodeJS.Timer): void;
			
 
				+        /**
			
 
				+         * The opposite of {@link add}. Removes domain handling from the
			
 
				+         * specified emitter.
			
 
				+         * @param emitter emitter or timer to be removed from the domain
			
 
				+         */
			
 
				+        remove(emitter: EventEmitter | NodeJS.Timer): void;
			
 
				+        /**
			
 
				+         * The returned function will be a wrapper around the supplied callback
			
 
				+         * function. When the returned function is called, any errors that are
			
 
				+         * thrown will be routed to the domain's `'error'` event.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const d = domain.create();
			
 
				+         *
			
 
				+         * function readSomeFile(filename, cb) {
			
 
				+         *   fs.readFile(filename, 'utf8', d.bind((er, data) => {
			
 
				+         *     // If this throws, it will also be passed to the domain.
			
 
				+         *     return cb(er, data ? JSON.parse(data) : null);
			
 
				+         *   }));
			
 
				+         * }
			
 
				+         *
			
 
				+         * d.on('error', (er) => {
			
 
				+         *   // An error occurred somewhere. If we throw it now, it will crash the program
			
 
				+         *   // with the normal line number and stack message.
			
 
				+         * });
			
 
				+         * ```
			
 
				+         * @param callback The callback function
			
 
				+         * @return The bound function
			
 
				+         */
			
 
				+        bind<T extends Function>(callback: T): T;
			
 
				+        /**
			
 
				+         * This method is almost identical to {@link bind}. However, in
			
 
				+         * addition to catching thrown errors, it will also intercept `Error` objects sent as the first argument to the function.
			
 
				+         *
			
 
				+         * In this way, the common `if (err) return callback(err);` pattern can be replaced
			
 
				+         * with a single error handler in a single place.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const d = domain.create();
			
 
				+         *
			
 
				+         * function readSomeFile(filename, cb) {
			
 
				+         *   fs.readFile(filename, 'utf8', d.intercept((data) => {
			
 
				+         *     // Note, the first argument is never passed to the
			
 
				+         *     // callback since it is assumed to be the 'Error' argument
			
 
				+         *     // and thus intercepted by the domain.
			
 
				+         *
			
 
				+         *     // If this throws, it will also be passed to the domain
			
 
				+         *     // so the error-handling logic can be moved to the 'error'
			
 
				+         *     // event on the domain instead of being repeated throughout
			
 
				+         *     // the program.
			
 
				+         *     return cb(null, JSON.parse(data));
			
 
				+         *   }));
			
 
				+         * }
			
 
				+         *
			
 
				+         * d.on('error', (er) => {
			
 
				+         *   // An error occurred somewhere. If we throw it now, it will crash the program
			
 
				+         *   // with the normal line number and stack message.
			
 
				+         * });
			
 
				+         * ```
			
 
				+         * @param callback The callback function
			
 
				+         * @return The intercepted function
			
 
				+         */
			
 
				+        intercept<T extends Function>(callback: T): T;
			
 
				+    }
			
 
				+    function create(): Domain;
			
 
				+}
			
 
				+declare module 'node:domain' {
			
 
				+    export * from 'domain';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/events.d.ts
+++ b/Asistent/node_modules/@types/node/events.d.ts
@@ -0,0 +1,678 @@
 
				+/**
			
 
				+ * Much of the Node.js core API is built around an idiomatic asynchronous
			
 
				+ * event-driven architecture in which certain kinds of objects (called "emitters")
			
 
				+ * emit named events that cause `Function` objects ("listeners") to be called.
			
 
				+ *
			
 
				+ * For instance: a `net.Server` object emits an event each time a peer
			
 
				+ * connects to it; a `fs.ReadStream` emits an event when the file is opened;
			
 
				+ * a `stream` emits an event whenever data is available to be read.
			
 
				+ *
			
 
				+ * All objects that emit events are instances of the `EventEmitter` class. These
			
 
				+ * objects expose an `eventEmitter.on()` function that allows one or more
			
 
				+ * functions to be attached to named events emitted by the object. Typically,
			
 
				+ * event names are camel-cased strings but any valid JavaScript property key
			
 
				+ * can be used.
			
 
				+ *
			
 
				+ * When the `EventEmitter` object emits an event, all of the functions attached
			
 
				+ * to that specific event are called _synchronously_. Any values returned by the
			
 
				+ * called listeners are _ignored_ and discarded.
			
 
				+ *
			
 
				+ * The following example shows a simple `EventEmitter` instance with a single
			
 
				+ * listener. The `eventEmitter.on()` method is used to register listeners, while
			
 
				+ * the `eventEmitter.emit()` method is used to trigger the event.
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * const EventEmitter = require('events');
			
 
				+ *
			
 
				+ * class MyEmitter extends EventEmitter {}
			
 
				+ *
			
 
				+ * const myEmitter = new MyEmitter();
			
 
				+ * myEmitter.on('event', () => {
			
 
				+ *   console.log('an event occurred!');
			
 
				+ * });
			
 
				+ * myEmitter.emit('event');
			
 
				+ * ```
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/events.js)
			
 
				+ */
			
 
				+declare module 'events' {
			
 
				+    // NOTE: This class is in the docs but is **not actually exported** by Node.
			
 
				+    // If https://github.com/nodejs/node/issues/39903 gets resolved and Node
			
 
				+    // actually starts exporting the class, uncomment below.
			
 
				+
			
 
				+    // import { EventListener, EventListenerObject } from '__dom-events';
			
 
				+    // /** The NodeEventTarget is a Node.js-specific extension to EventTarget that emulates a subset of the EventEmitter API. */
			
 
				+    // interface NodeEventTarget extends EventTarget {
			
 
				+    //     /**
			
 
				+    //      * Node.js-specific extension to the `EventTarget` class that emulates the equivalent `EventEmitter` API.
			
 
				+    //      * The only difference between `addListener()` and `addEventListener()` is that addListener() will return a reference to the EventTarget.
			
 
				+    //      */
			
 
				+    //     addListener(type: string, listener: EventListener | EventListenerObject, options?: { once: boolean }): this;
			
 
				+    //     /** Node.js-specific extension to the `EventTarget` class that returns an array of event `type` names for which event listeners are registered. */
			
 
				+    //     eventNames(): string[];
			
 
				+    //     /** Node.js-specific extension to the `EventTarget` class that returns the number of event listeners registered for the `type`. */
			
 
				+    //     listenerCount(type: string): number;
			
 
				+    //     /** Node.js-specific alias for `eventTarget.removeListener()`. */
			
 
				+    //     off(type: string, listener: EventListener | EventListenerObject): this;
			
 
				+    //     /** Node.js-specific alias for `eventTarget.addListener()`. */
			
 
				+    //     on(type: string, listener: EventListener | EventListenerObject, options?: { once: boolean }): this;
			
 
				+    //     /** Node.js-specific extension to the `EventTarget` class that adds a `once` listener for the given event `type`. This is equivalent to calling `on` with the `once` option set to `true`. */
			
 
				+    //     once(type: string, listener: EventListener | EventListenerObject): this;
			
 
				+    //     /**
			
 
				+    //      * Node.js-specific extension to the `EventTarget` class.
			
 
				+    //      * If `type` is specified, removes all registered listeners for `type`,
			
 
				+    //      * otherwise removes all registered listeners.
			
 
				+    //      */
			
 
				+    //     removeAllListeners(type: string): this;
			
 
				+    //     /**
			
 
				+    //      * Node.js-specific extension to the `EventTarget` class that removes the listener for the given `type`.
			
 
				+    //      * The only difference between `removeListener()` and `removeEventListener()` is that `removeListener()` will return a reference to the `EventTarget`.
			
 
				+    //      */
			
 
				+    //     removeListener(type: string, listener: EventListener | EventListenerObject): this;
			
 
				+    // }
			
 
				+
			
 
				+    interface EventEmitterOptions {
			
 
				+        /**
			
 
				+         * Enables automatic capturing of promise rejection.
			
 
				+         */
			
 
				+        captureRejections?: boolean | undefined;
			
 
				+    }
			
 
				+    // Any EventTarget with a Node-style `once` function
			
 
				+    interface _NodeEventTarget {
			
 
				+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+    }
			
 
				+    // Any EventTarget with a DOM-style `addEventListener`
			
 
				+    interface _DOMEventTarget {
			
 
				+        addEventListener(
			
 
				+            eventName: string,
			
 
				+            listener: (...args: any[]) => void,
			
 
				+            opts?: {
			
 
				+                once: boolean;
			
 
				+            }
			
 
				+        ): any;
			
 
				+    }
			
 
				+    interface StaticEventEmitterOptions {
			
 
				+        signal?: AbortSignal | undefined;
			
 
				+    }
			
 
				+    interface EventEmitter extends NodeJS.EventEmitter {}
			
 
				+    /**
			
 
				+     * The `EventEmitter` class is defined and exposed by the `events` module:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const EventEmitter = require('events');
			
 
				+     * ```
			
 
				+     *
			
 
				+     * All `EventEmitter`s emit the event `'newListener'` when new listeners are
			
 
				+     * added and `'removeListener'` when existing listeners are removed.
			
 
				+     *
			
 
				+     * It supports the following option:
			
 
				+     * @since v0.1.26
			
 
				+     */
			
 
				+    class EventEmitter {
			
 
				+        constructor(options?: EventEmitterOptions);
			
 
				+        /**
			
 
				+         * Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
			
 
				+         * event or that is rejected if the `EventEmitter` emits `'error'` while waiting.
			
 
				+         * The `Promise` will resolve with an array of all the arguments emitted to the
			
 
				+         * given event.
			
 
				+         *
			
 
				+         * This method is intentionally generic and works with the web platform [EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget) interface, which has no special`'error'` event
			
 
				+         * semantics and does not listen to the `'error'` event.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { once, EventEmitter } = require('events');
			
 
				+         *
			
 
				+         * async function run() {
			
 
				+         *   const ee = new EventEmitter();
			
 
				+         *
			
 
				+         *   process.nextTick(() => {
			
 
				+         *     ee.emit('myevent', 42);
			
 
				+         *   });
			
 
				+         *
			
 
				+         *   const [value] = await once(ee, 'myevent');
			
 
				+         *   console.log(value);
			
 
				+         *
			
 
				+         *   const err = new Error('kaboom');
			
 
				+         *   process.nextTick(() => {
			
 
				+         *     ee.emit('error', err);
			
 
				+         *   });
			
 
				+         *
			
 
				+         *   try {
			
 
				+         *     await once(ee, 'myevent');
			
 
				+         *   } catch (err) {
			
 
				+         *     console.log('error happened', err);
			
 
				+         *   }
			
 
				+         * }
			
 
				+         *
			
 
				+         * run();
			
 
				+         * ```
			
 
				+         *
			
 
				+         * The special handling of the `'error'` event is only used when `events.once()`is used to wait for another event. If `events.once()` is used to wait for the
			
 
				+         * '`error'` event itself, then it is treated as any other kind of event without
			
 
				+         * special handling:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { EventEmitter, once } = require('events');
			
 
				+         *
			
 
				+         * const ee = new EventEmitter();
			
 
				+         *
			
 
				+         * once(ee, 'error')
			
 
				+         *   .then(([err]) => console.log('ok', err.message))
			
 
				+         *   .catch((err) => console.log('error', err.message));
			
 
				+         *
			
 
				+         * ee.emit('error', new Error('boom'));
			
 
				+         *
			
 
				+         * // Prints: ok boom
			
 
				+         * ```
			
 
				+         *
			
 
				+         * An `AbortSignal` can be used to cancel waiting for the event:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { EventEmitter, once } = require('events');
			
 
				+         *
			
 
				+         * const ee = new EventEmitter();
			
 
				+         * const ac = new AbortController();
			
 
				+         *
			
 
				+         * async function foo(emitter, event, signal) {
			
 
				+         *   try {
			
 
				+         *     await once(emitter, event, { signal });
			
 
				+         *     console.log('event emitted!');
			
 
				+         *   } catch (error) {
			
 
				+         *     if (error.name === 'AbortError') {
			
 
				+         *       console.error('Waiting for the event was canceled!');
			
 
				+         *     } else {
			
 
				+         *       console.error('There was an error', error.message);
			
 
				+         *     }
			
 
				+         *   }
			
 
				+         * }
			
 
				+         *
			
 
				+         * foo(ee, 'foo', ac.signal);
			
 
				+         * ac.abort(); // Abort waiting for the event
			
 
				+         * ee.emit('foo'); // Prints: Waiting for the event was canceled!
			
 
				+         * ```
			
 
				+         * @since v11.13.0, v10.16.0
			
 
				+         */
			
 
				+        static once(emitter: _NodeEventTarget, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>;
			
 
				+        static once(emitter: _DOMEventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>;
			
 
				+        /**
			
 
				+         * ```js
			
 
				+         * const { on, EventEmitter } = require('events');
			
 
				+         *
			
 
				+         * (async () => {
			
 
				+         *   const ee = new EventEmitter();
			
 
				+         *
			
 
				+         *   // Emit later on
			
 
				+         *   process.nextTick(() => {
			
 
				+         *     ee.emit('foo', 'bar');
			
 
				+         *     ee.emit('foo', 42);
			
 
				+         *   });
			
 
				+         *
			
 
				+         *   for await (const event of on(ee, 'foo')) {
			
 
				+         *     // The execution of this inner block is synchronous and it
			
 
				+         *     // processes one event at a time (even with await). Do not use
			
 
				+         *     // if concurrent execution is required.
			
 
				+         *     console.log(event); // prints ['bar'] [42]
			
 
				+         *   }
			
 
				+         *   // Unreachable here
			
 
				+         * })();
			
 
				+         * ```
			
 
				+         *
			
 
				+         * Returns an `AsyncIterator` that iterates `eventName` events. It will throw
			
 
				+         * if the `EventEmitter` emits `'error'`. It removes all listeners when
			
 
				+         * exiting the loop. The `value` returned by each iteration is an array
			
 
				+         * composed of the emitted event arguments.
			
 
				+         *
			
 
				+         * An `AbortSignal` can be used to cancel waiting on events:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { on, EventEmitter } = require('events');
			
 
				+         * const ac = new AbortController();
			
 
				+         *
			
 
				+         * (async () => {
			
 
				+         *   const ee = new EventEmitter();
			
 
				+         *
			
 
				+         *   // Emit later on
			
 
				+         *   process.nextTick(() => {
			
 
				+         *     ee.emit('foo', 'bar');
			
 
				+         *     ee.emit('foo', 42);
			
 
				+         *   });
			
 
				+         *
			
 
				+         *   for await (const event of on(ee, 'foo', { signal: ac.signal })) {
			
 
				+         *     // The execution of this inner block is synchronous and it
			
 
				+         *     // processes one event at a time (even with await). Do not use
			
 
				+         *     // if concurrent execution is required.
			
 
				+         *     console.log(event); // prints ['bar'] [42]
			
 
				+         *   }
			
 
				+         *   // Unreachable here
			
 
				+         * })();
			
 
				+         *
			
 
				+         * process.nextTick(() => ac.abort());
			
 
				+         * ```
			
 
				+         * @since v13.6.0, v12.16.0
			
 
				+         * @param eventName The name of the event being listened for
			
 
				+         * @return that iterates `eventName` events emitted by the `emitter`
			
 
				+         */
			
 
				+        static on(emitter: NodeJS.EventEmitter, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>;
			
 
				+        /**
			
 
				+         * A class method that returns the number of listeners for the given `eventName`registered on the given `emitter`.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { EventEmitter, listenerCount } = require('events');
			
 
				+         * const myEmitter = new EventEmitter();
			
 
				+         * myEmitter.on('event', () => {});
			
 
				+         * myEmitter.on('event', () => {});
			
 
				+         * console.log(listenerCount(myEmitter, 'event'));
			
 
				+         * // Prints: 2
			
 
				+         * ```
			
 
				+         * @since v0.9.12
			
 
				+         * @deprecated Since v3.2.0 - Use `listenerCount` instead.
			
 
				+         * @param emitter The emitter to query
			
 
				+         * @param eventName The event name
			
 
				+         */
			
 
				+        static listenerCount(emitter: NodeJS.EventEmitter, eventName: string | symbol): number;
			
 
				+        /**
			
 
				+         * Returns a copy of the array of listeners for the event named `eventName`.
			
 
				+         *
			
 
				+         * For `EventEmitter`s this behaves exactly the same as calling `.listeners` on
			
 
				+         * the emitter.
			
 
				+         *
			
 
				+         * For `EventTarget`s this is the only way to get the event listeners for the
			
 
				+         * event target. This is useful for debugging and diagnostic purposes.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * const { getEventListeners, EventEmitter } = require('events');
			
 
				+         *
			
 
				+         * {
			
 
				+         *   const ee = new EventEmitter();
			
 
				+         *   const listener = () => console.log('Events are fun');
			
 
				+         *   ee.on('foo', listener);
			
 
				+         *   getEventListeners(ee, 'foo'); // [listener]
			
 
				+         * }
			
 
				+         * {
			
 
				+         *   const et = new EventTarget();
			
 
				+         *   const listener = () => console.log('Events are fun');
			
 
				+         *   et.addEventListener('foo', listener);
			
 
				+         *   getEventListeners(et, 'foo'); // [listener]
			
 
				+         * }
			
 
				+         * ```
			
 
				+         * @since v15.2.0, v14.17.0
			
 
				+         */
			
 
				+        static getEventListeners(emitter: _DOMEventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
			
 
				+        /**
			
 
				+         * ```js
			
 
				+         * const {
			
 
				+         *   setMaxListeners,
			
 
				+         *   EventEmitter
			
 
				+         * } = require('events');
			
 
				+         *
			
 
				+         * const target = new EventTarget();
			
 
				+         * const emitter = new EventEmitter();
			
 
				+         *
			
 
				+         * setMaxListeners(5, target, emitter);
			
 
				+         * ```
			
 
				+         * @since v15.4.0
			
 
				+         * @param n A non-negative number. The maximum number of listeners per `EventTarget` event.
			
 
				+         * @param eventsTargets Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter}
			
 
				+         * objects.
			
 
				+         */
			
 
				+        static setMaxListeners(n?: number, ...eventTargets: Array<_DOMEventTarget | NodeJS.EventEmitter>): void;
			
 
				+        /**
			
 
				+         * This symbol shall be used to install a listener for only monitoring `'error'`
			
 
				+         * events. Listeners installed using this symbol are called before the regular
			
 
				+         * `'error'` listeners are called.
			
 
				+         *
			
 
				+         * Installing a listener using this symbol does not change the behavior once an
			
 
				+         * `'error'` event is emitted, therefore the process will still crash if no
			
 
				+         * regular `'error'` listener is installed.
			
 
				+         */
			
 
				+        static readonly errorMonitor: unique symbol;
			
 
				+        static readonly captureRejectionSymbol: unique symbol;
			
 
				+        /**
			
 
				+         * Sets or gets the default captureRejection value for all emitters.
			
 
				+         */
			
 
				+        // TODO: These should be described using static getter/setter pairs:
			
 
				+        static captureRejections: boolean;
			
 
				+        static defaultMaxListeners: number;
			
 
				+    }
			
 
				+    import internal = require('node:events');
			
 
				+    namespace EventEmitter {
			
 
				+        // Should just be `export { EventEmitter }`, but that doesn't work in TypeScript 3.4
			
 
				+        export { internal as EventEmitter };
			
 
				+        export interface Abortable {
			
 
				+            /**
			
 
				+             * When provided the corresponding `AbortController` can be used to cancel an asynchronous action.
			
 
				+             */
			
 
				+            signal?: AbortSignal | undefined;
			
 
				+        }
			
 
				+    }
			
 
				+    global {
			
 
				+        namespace NodeJS {
			
 
				+            interface EventEmitter {
			
 
				+                /**
			
 
				+                 * Alias for `emitter.on(eventName, listener)`.
			
 
				+                 * @since v0.1.26
			
 
				+                 */
			
 
				+                addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+                /**
			
 
				+                 * Adds the `listener` function to the end of the listeners array for the
			
 
				+                 * event named `eventName`. No checks are made to see if the `listener` has
			
 
				+                 * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
			
 
				+                 * times.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * server.on('connection', (stream) => {
			
 
				+                 *   console.log('someone connected!');
			
 
				+                 * });
			
 
				+                 * ```
			
 
				+                 *
			
 
				+                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
			
 
				+                 *
			
 
				+                 * By default, event listeners are invoked in the order they are added. The`emitter.prependListener()` method can be used as an alternative to add the
			
 
				+                 * event listener to the beginning of the listeners array.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * const myEE = new EventEmitter();
			
 
				+                 * myEE.on('foo', () => console.log('a'));
			
 
				+                 * myEE.prependListener('foo', () => console.log('b'));
			
 
				+                 * myEE.emit('foo');
			
 
				+                 * // Prints:
			
 
				+                 * //   b
			
 
				+                 * //   a
			
 
				+                 * ```
			
 
				+                 * @since v0.1.101
			
 
				+                 * @param eventName The name of the event.
			
 
				+                 * @param listener The callback function
			
 
				+                 */
			
 
				+                on(eventName: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+                /**
			
 
				+                 * Adds a **one-time**`listener` function for the event named `eventName`. The
			
 
				+                 * next time `eventName` is triggered, this listener is removed and then invoked.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * server.once('connection', (stream) => {
			
 
				+                 *   console.log('Ah, we have our first user!');
			
 
				+                 * });
			
 
				+                 * ```
			
 
				+                 *
			
 
				+                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
			
 
				+                 *
			
 
				+                 * By default, event listeners are invoked in the order they are added. The`emitter.prependOnceListener()` method can be used as an alternative to add the
			
 
				+                 * event listener to the beginning of the listeners array.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * const myEE = new EventEmitter();
			
 
				+                 * myEE.once('foo', () => console.log('a'));
			
 
				+                 * myEE.prependOnceListener('foo', () => console.log('b'));
			
 
				+                 * myEE.emit('foo');
			
 
				+                 * // Prints:
			
 
				+                 * //   b
			
 
				+                 * //   a
			
 
				+                 * ```
			
 
				+                 * @since v0.3.0
			
 
				+                 * @param eventName The name of the event.
			
 
				+                 * @param listener The callback function
			
 
				+                 */
			
 
				+                once(eventName: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+                /**
			
 
				+                 * Removes the specified `listener` from the listener array for the event named`eventName`.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * const callback = (stream) => {
			
 
				+                 *   console.log('someone connected!');
			
 
				+                 * };
			
 
				+                 * server.on('connection', callback);
			
 
				+                 * // ...
			
 
				+                 * server.removeListener('connection', callback);
			
 
				+                 * ```
			
 
				+                 *
			
 
				+                 * `removeListener()` will remove, at most, one instance of a listener from the
			
 
				+                 * listener array. If any single listener has been added multiple times to the
			
 
				+                 * listener array for the specified `eventName`, then `removeListener()` must be
			
 
				+                 * called multiple times to remove each instance.
			
 
				+                 *
			
 
				+                 * Once an event is emitted, all listeners attached to it at the
			
 
				+                 * time of emitting are called in order. This implies that any`removeListener()` or `removeAllListeners()` calls _after_ emitting and _before_ the last listener finishes execution
			
 
				+                 * will not remove them from`emit()` in progress. Subsequent events behave as expected.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * const myEmitter = new MyEmitter();
			
 
				+                 *
			
 
				+                 * const callbackA = () => {
			
 
				+                 *   console.log('A');
			
 
				+                 *   myEmitter.removeListener('event', callbackB);
			
 
				+                 * };
			
 
				+                 *
			
 
				+                 * const callbackB = () => {
			
 
				+                 *   console.log('B');
			
 
				+                 * };
			
 
				+                 *
			
 
				+                 * myEmitter.on('event', callbackA);
			
 
				+                 *
			
 
				+                 * myEmitter.on('event', callbackB);
			
 
				+                 *
			
 
				+                 * // callbackA removes listener callbackB but it will still be called.
			
 
				+                 * // Internal listener array at time of emit [callbackA, callbackB]
			
 
				+                 * myEmitter.emit('event');
			
 
				+                 * // Prints:
			
 
				+                 * //   A
			
 
				+                 * //   B
			
 
				+                 *
			
 
				+                 * // callbackB is now removed.
			
 
				+                 * // Internal listener array [callbackA]
			
 
				+                 * myEmitter.emit('event');
			
 
				+                 * // Prints:
			
 
				+                 * //   A
			
 
				+                 * ```
			
 
				+                 *
			
 
				+                 * Because listeners are managed using an internal array, calling this will
			
 
				+                 * change the position indices of any listener registered _after_ the listener
			
 
				+                 * being removed. This will not impact the order in which listeners are called,
			
 
				+                 * but it means that any copies of the listener array as returned by
			
 
				+                 * the `emitter.listeners()` method will need to be recreated.
			
 
				+                 *
			
 
				+                 * When a single function has been added as a handler multiple times for a single
			
 
				+                 * event (as in the example below), `removeListener()` will remove the most
			
 
				+                 * recently added instance. In the example the `once('ping')`listener is removed:
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * const ee = new EventEmitter();
			
 
				+                 *
			
 
				+                 * function pong() {
			
 
				+                 *   console.log('pong');
			
 
				+                 * }
			
 
				+                 *
			
 
				+                 * ee.on('ping', pong);
			
 
				+                 * ee.once('ping', pong);
			
 
				+                 * ee.removeListener('ping', pong);
			
 
				+                 *
			
 
				+                 * ee.emit('ping');
			
 
				+                 * ee.emit('ping');
			
 
				+                 * ```
			
 
				+                 *
			
 
				+                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
			
 
				+                 * @since v0.1.26
			
 
				+                 */
			
 
				+                removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+                /**
			
 
				+                 * Alias for `emitter.removeListener()`.
			
 
				+                 * @since v10.0.0
			
 
				+                 */
			
 
				+                off(eventName: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+                /**
			
 
				+                 * Removes all listeners, or those of the specified `eventName`.
			
 
				+                 *
			
 
				+                 * It is bad practice to remove listeners added elsewhere in the code,
			
 
				+                 * particularly when the `EventEmitter` instance was created by some other
			
 
				+                 * component or module (e.g. sockets or file streams).
			
 
				+                 *
			
 
				+                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
			
 
				+                 * @since v0.1.26
			
 
				+                 */
			
 
				+                removeAllListeners(event?: string | symbol): this;
			
 
				+                /**
			
 
				+                 * By default `EventEmitter`s will print a warning if more than `10` listeners are
			
 
				+                 * added for a particular event. This is a useful default that helps finding
			
 
				+                 * memory leaks. The `emitter.setMaxListeners()` method allows the limit to be
			
 
				+                 * modified for this specific `EventEmitter` instance. The value can be set to`Infinity` (or `0`) to indicate an unlimited number of listeners.
			
 
				+                 *
			
 
				+                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
			
 
				+                 * @since v0.3.5
			
 
				+                 */
			
 
				+                setMaxListeners(n: number): this;
			
 
				+                /**
			
 
				+                 * Returns the current max listener value for the `EventEmitter` which is either
			
 
				+                 * set by `emitter.setMaxListeners(n)` or defaults to {@link defaultMaxListeners}.
			
 
				+                 * @since v1.0.0
			
 
				+                 */
			
 
				+                getMaxListeners(): number;
			
 
				+                /**
			
 
				+                 * Returns a copy of the array of listeners for the event named `eventName`.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * server.on('connection', (stream) => {
			
 
				+                 *   console.log('someone connected!');
			
 
				+                 * });
			
 
				+                 * console.log(util.inspect(server.listeners('connection')));
			
 
				+                 * // Prints: [ [Function] ]
			
 
				+                 * ```
			
 
				+                 * @since v0.1.26
			
 
				+                 */
			
 
				+                listeners(eventName: string | symbol): Function[];
			
 
				+                /**
			
 
				+                 * Returns a copy of the array of listeners for the event named `eventName`,
			
 
				+                 * including any wrappers (such as those created by `.once()`).
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * const emitter = new EventEmitter();
			
 
				+                 * emitter.once('log', () => console.log('log once'));
			
 
				+                 *
			
 
				+                 * // Returns a new Array with a function `onceWrapper` which has a property
			
 
				+                 * // `listener` which contains the original listener bound above
			
 
				+                 * const listeners = emitter.rawListeners('log');
			
 
				+                 * const logFnWrapper = listeners[0];
			
 
				+                 *
			
 
				+                 * // Logs "log once" to the console and does not unbind the `once` event
			
 
				+                 * logFnWrapper.listener();
			
 
				+                 *
			
 
				+                 * // Logs "log once" to the console and removes the listener
			
 
				+                 * logFnWrapper();
			
 
				+                 *
			
 
				+                 * emitter.on('log', () => console.log('log persistently'));
			
 
				+                 * // Will return a new Array with a single function bound by `.on()` above
			
 
				+                 * const newListeners = emitter.rawListeners('log');
			
 
				+                 *
			
 
				+                 * // Logs "log persistently" twice
			
 
				+                 * newListeners[0]();
			
 
				+                 * emitter.emit('log');
			
 
				+                 * ```
			
 
				+                 * @since v9.4.0
			
 
				+                 */
			
 
				+                rawListeners(eventName: string | symbol): Function[];
			
 
				+                /**
			
 
				+                 * Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments
			
 
				+                 * to each.
			
 
				+                 *
			
 
				+                 * Returns `true` if the event had listeners, `false` otherwise.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * const EventEmitter = require('events');
			
 
				+                 * const myEmitter = new EventEmitter();
			
 
				+                 *
			
 
				+                 * // First listener
			
 
				+                 * myEmitter.on('event', function firstListener() {
			
 
				+                 *   console.log('Helloooo! first listener');
			
 
				+                 * });
			
 
				+                 * // Second listener
			
 
				+                 * myEmitter.on('event', function secondListener(arg1, arg2) {
			
 
				+                 *   console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
			
 
				+                 * });
			
 
				+                 * // Third listener
			
 
				+                 * myEmitter.on('event', function thirdListener(...args) {
			
 
				+                 *   const parameters = args.join(', ');
			
 
				+                 *   console.log(`event with parameters ${parameters} in third listener`);
			
 
				+                 * });
			
 
				+                 *
			
 
				+                 * console.log(myEmitter.listeners('event'));
			
 
				+                 *
			
 
				+                 * myEmitter.emit('event', 1, 2, 3, 4, 5);
			
 
				+                 *
			
 
				+                 * // Prints:
			
 
				+                 * // [
			
 
				+                 * //   [Function: firstListener],
			
 
				+                 * //   [Function: secondListener],
			
 
				+                 * //   [Function: thirdListener]
			
 
				+                 * // ]
			
 
				+                 * // Helloooo! first listener
			
 
				+                 * // event with parameters 1, 2 in second listener
			
 
				+                 * // event with parameters 1, 2, 3, 4, 5 in third listener
			
 
				+                 * ```
			
 
				+                 * @since v0.1.26
			
 
				+                 */
			
 
				+                emit(eventName: string | symbol, ...args: any[]): boolean;
			
 
				+                /**
			
 
				+                 * Returns the number of listeners listening to the event named `eventName`.
			
 
				+                 * @since v3.2.0
			
 
				+                 * @param eventName The name of the event being listened for
			
 
				+                 */
			
 
				+                listenerCount(eventName: string | symbol): number;
			
 
				+                /**
			
 
				+                 * Adds the `listener` function to the _beginning_ of the listeners array for the
			
 
				+                 * event named `eventName`. No checks are made to see if the `listener` has
			
 
				+                 * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
			
 
				+                 * times.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * server.prependListener('connection', (stream) => {
			
 
				+                 *   console.log('someone connected!');
			
 
				+                 * });
			
 
				+                 * ```
			
 
				+                 *
			
 
				+                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
			
 
				+                 * @since v6.0.0
			
 
				+                 * @param eventName The name of the event.
			
 
				+                 * @param listener The callback function
			
 
				+                 */
			
 
				+                prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+                /**
			
 
				+                 * Adds a **one-time**`listener` function for the event named `eventName` to the _beginning_ of the listeners array. The next time `eventName` is triggered, this
			
 
				+                 * listener is removed, and then invoked.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * server.prependOnceListener('connection', (stream) => {
			
 
				+                 *   console.log('Ah, we have our first user!');
			
 
				+                 * });
			
 
				+                 * ```
			
 
				+                 *
			
 
				+                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
			
 
				+                 * @since v6.0.0
			
 
				+                 * @param eventName The name of the event.
			
 
				+                 * @param listener The callback function
			
 
				+                 */
			
 
				+                prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+                /**
			
 
				+                 * Returns an array listing the events for which the emitter has registered
			
 
				+                 * listeners. The values in the array are strings or `Symbol`s.
			
 
				+                 *
			
 
				+                 * ```js
			
 
				+                 * const EventEmitter = require('events');
			
 
				+                 * const myEE = new EventEmitter();
			
 
				+                 * myEE.on('foo', () => {});
			
 
				+                 * myEE.on('bar', () => {});
			
 
				+                 *
			
 
				+                 * const sym = Symbol('symbol');
			
 
				+                 * myEE.on(sym, () => {});
			
 
				+                 *
			
 
				+                 * console.log(myEE.eventNames());
			
 
				+                 * // Prints: [ 'foo', 'bar', Symbol(symbol) ]
			
 
				+                 * ```
			
 
				+                 * @since v6.0.0
			
 
				+                 */
			
 
				+                eventNames(): Array<string | symbol>;
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    export = EventEmitter;
			
 
				+}
			
 
				+declare module 'node:events' {
			
 
				+    import events = require('events');
			
 
				+    export = events;
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/fs.d.ts
+++ b/Asistent/node_modules/@types/node/fs.d.ts
@@ -0,0 +1,3972 @@
 
				+/**
			
 
				+ * The `fs` module enables interacting with the file system in a
			
 
				+ * way modeled on standard POSIX functions.
			
 
				+ *
			
 
				+ * To use the promise-based APIs:
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * import * as fs from 'fs/promises';
			
 
				+ * ```
			
 
				+ *
			
 
				+ * To use the callback and sync APIs:
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * import * as fs from 'fs';
			
 
				+ * ```
			
 
				+ *
			
 
				+ * All file system operations have synchronous, callback, and promise-based
			
 
				+ * forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).
			
 
				+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/fs.js)
			
 
				+ */
			
 
				+declare module 'fs' {
			
 
				+    import * as stream from 'node:stream';
			
 
				+    import { Abortable, EventEmitter } from 'node:events';
			
 
				+    import { URL } from 'node:url';
			
 
				+    import * as promises from 'node:fs/promises';
			
 
				+    export { promises };
			
 
				+    /**
			
 
				+     * Valid types for path values in "fs".
			
 
				+     */
			
 
				+    export type PathLike = string | Buffer | URL;
			
 
				+    export type PathOrFileDescriptor = PathLike | number;
			
 
				+    export type TimeLike = string | number | Date;
			
 
				+    export type NoParamCallback = (err: NodeJS.ErrnoException | null) => void;
			
 
				+    export type BufferEncodingOption =
			
 
				+        | 'buffer'
			
 
				+        | {
			
 
				+              encoding: 'buffer';
			
 
				+          };
			
 
				+    export interface ObjectEncodingOptions {
			
 
				+        encoding?: BufferEncoding | null | undefined;
			
 
				+    }
			
 
				+    export type EncodingOption = ObjectEncodingOptions | BufferEncoding | undefined | null;
			
 
				+    export type OpenMode = number | string;
			
 
				+    export type Mode = number | string;
			
 
				+    export interface StatsBase<T> {
			
 
				+        isFile(): boolean;
			
 
				+        isDirectory(): boolean;
			
 
				+        isBlockDevice(): boolean;
			
 
				+        isCharacterDevice(): boolean;
			
 
				+        isSymbolicLink(): boolean;
			
 
				+        isFIFO(): boolean;
			
 
				+        isSocket(): boolean;
			
 
				+        dev: T;
			
 
				+        ino: T;
			
 
				+        mode: T;
			
 
				+        nlink: T;
			
 
				+        uid: T;
			
 
				+        gid: T;
			
 
				+        rdev: T;
			
 
				+        size: T;
			
 
				+        blksize: T;
			
 
				+        blocks: T;
			
 
				+        atimeMs: T;
			
 
				+        mtimeMs: T;
			
 
				+        ctimeMs: T;
			
 
				+        birthtimeMs: T;
			
 
				+        atime: Date;
			
 
				+        mtime: Date;
			
 
				+        ctime: Date;
			
 
				+        birthtime: Date;
			
 
				+    }
			
 
				+    export interface Stats extends StatsBase<number> {}
			
 
				+    /**
			
 
				+     * A `fs.Stats` object provides information about a file.
			
 
				+     *
			
 
				+     * Objects returned from {@link stat}, {@link lstat} and {@link fstat} and
			
 
				+     * their synchronous counterparts are of this type.
			
 
				+     * If `bigint` in the `options` passed to those methods is true, the numeric values
			
 
				+     * will be `bigint` instead of `number`, and the object will contain additional
			
 
				+     * nanosecond-precision properties suffixed with `Ns`.
			
 
				+     *
			
 
				+     * ```console
			
 
				+     * Stats {
			
 
				+     *   dev: 2114,
			
 
				+     *   ino: 48064969,
			
 
				+     *   mode: 33188,
			
 
				+     *   nlink: 1,
			
 
				+     *   uid: 85,
			
 
				+     *   gid: 100,
			
 
				+     *   rdev: 0,
			
 
				+     *   size: 527,
			
 
				+     *   blksize: 4096,
			
 
				+     *   blocks: 8,
			
 
				+     *   atimeMs: 1318289051000.1,
			
 
				+     *   mtimeMs: 1318289051000.1,
			
 
				+     *   ctimeMs: 1318289051000.1,
			
 
				+     *   birthtimeMs: 1318289051000.1,
			
 
				+     *   atime: Mon, 10 Oct 2011 23:24:11 GMT,
			
 
				+     *   mtime: Mon, 10 Oct 2011 23:24:11 GMT,
			
 
				+     *   ctime: Mon, 10 Oct 2011 23:24:11 GMT,
			
 
				+     *   birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
			
 
				+     * ```
			
 
				+     *
			
 
				+     * `bigint` version:
			
 
				+     *
			
 
				+     * ```console
			
 
				+     * BigIntStats {
			
 
				+     *   dev: 2114n,
			
 
				+     *   ino: 48064969n,
			
 
				+     *   mode: 33188n,
			
 
				+     *   nlink: 1n,
			
 
				+     *   uid: 85n,
			
 
				+     *   gid: 100n,
			
 
				+     *   rdev: 0n,
			
 
				+     *   size: 527n,
			
 
				+     *   blksize: 4096n,
			
 
				+     *   blocks: 8n,
			
 
				+     *   atimeMs: 1318289051000n,
			
 
				+     *   mtimeMs: 1318289051000n,
			
 
				+     *   ctimeMs: 1318289051000n,
			
 
				+     *   birthtimeMs: 1318289051000n,
			
 
				+     *   atimeNs: 1318289051000000000n,
			
 
				+     *   mtimeNs: 1318289051000000000n,
			
 
				+     *   ctimeNs: 1318289051000000000n,
			
 
				+     *   birthtimeNs: 1318289051000000000n,
			
 
				+     *   atime: Mon, 10 Oct 2011 23:24:11 GMT,
			
 
				+     *   mtime: Mon, 10 Oct 2011 23:24:11 GMT,
			
 
				+     *   ctime: Mon, 10 Oct 2011 23:24:11 GMT,
			
 
				+     *   birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
			
 
				+     * ```
			
 
				+     * @since v0.1.21
			
 
				+     */
			
 
				+    export class Stats {}
			
 
				+
			
 
				+    export interface StatsFsBase<T> {
			
 
				+        /** Type of file system. */
			
 
				+        type: T;
			
 
				+        /**  Optimal transfer block size. */
			
 
				+        bsize: T;
			
 
				+        /**  Total data blocks in file system. */
			
 
				+        blocks: T;
			
 
				+        /** Free blocks in file system. */
			
 
				+        bfree: T;
			
 
				+        /** Available blocks for unprivileged users */
			
 
				+        bavail: T;
			
 
				+        /** Total file nodes in file system. */
			
 
				+        files: T;
			
 
				+        /** Free file nodes in file system. */
			
 
				+        ffree: T;
			
 
				+    }
			
 
				+
			
 
				+    export interface StatsFs extends StatsFsBase<number> {}
			
 
				+
			
 
				+    /**
			
 
				+     * Provides information about a mounted file system
			
 
				+     *
			
 
				+     * Objects returned from {@link statfs} and {@link statfsSync} are of this type.
			
 
				+     * If `bigint` in the `options` passed to those methods is true, the numeric values
			
 
				+     * will be `bigint` instead of `number`.
			
 
				+     * @since  v18.15.0
			
 
				+     */
			
 
				+    export class StatsFs {}
			
 
				+
			
 
				+    export interface BigIntStatsFs extends StatsFsBase<bigint> {}
			
 
				+
			
 
				+    export interface StatFsOptions {
			
 
				+        bigint?: boolean | undefined;
			
 
				+    }
			
 
				+
			
 
				+    /**
			
 
				+     * A representation of a directory entry, which can be a file or a subdirectory
			
 
				+     * within the directory, as returned by reading from an `fs.Dir`. The
			
 
				+     * directory entry is a combination of the file name and file type pairs.
			
 
				+     *
			
 
				+     * Additionally, when {@link readdir} or {@link readdirSync} is called with
			
 
				+     * the `withFileTypes` option set to `true`, the resulting array is filled with `fs.Dirent` objects, rather than strings or `Buffer` s.
			
 
				+     * @since v10.10.0
			
 
				+     */
			
 
				+    export class Dirent {
			
 
				+        /**
			
 
				+         * Returns `true` if the `fs.Dirent` object describes a regular file.
			
 
				+         * @since v10.10.0
			
 
				+         */
			
 
				+        isFile(): boolean;
			
 
				+        /**
			
 
				+         * Returns `true` if the `fs.Dirent` object describes a file system
			
 
				+         * directory.
			
 
				+         * @since v10.10.0
			
 
				+         */
			
 
				+        isDirectory(): boolean;
			
 
				+        /**
			
 
				+         * Returns `true` if the `fs.Dirent` object describes a block device.
			
 
				+         * @since v10.10.0
			
 
				+         */
			
 
				+        isBlockDevice(): boolean;
			
 
				+        /**
			
 
				+         * Returns `true` if the `fs.Dirent` object describes a character device.
			
 
				+         * @since v10.10.0
			
 
				+         */
			
 
				+        isCharacterDevice(): boolean;
			
 
				+        /**
			
 
				+         * Returns `true` if the `fs.Dirent` object describes a symbolic link.
			
 
				+         * @since v10.10.0
			
 
				+         */
			
 
				+        isSymbolicLink(): boolean;
			
 
				+        /**
			
 
				+         * Returns `true` if the `fs.Dirent` object describes a first-in-first-out
			
 
				+         * (FIFO) pipe.
			
 
				+         * @since v10.10.0
			
 
				+         */
			
 
				+        isFIFO(): boolean;
			
 
				+        /**
			
 
				+         * Returns `true` if the `fs.Dirent` object describes a socket.
			
 
				+         * @since v10.10.0
			
 
				+         */
			
 
				+        isSocket(): boolean;
			
 
				+        /**
			
 
				+         * The file name that this `fs.Dirent` object refers to. The type of this
			
 
				+         * value is determined by the `options.encoding` passed to {@link readdir} or {@link readdirSync}.
			
 
				+         * @since v10.10.0
			
 
				+         */
			
 
				+        name: string;
			
 
				+    }
			
 
				+    /**
			
 
				+     * A class representing a directory stream.
			
 
				+     *
			
 
				+     * Created by {@link opendir}, {@link opendirSync}, or `fsPromises.opendir()`.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { opendir } from 'fs/promises';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   const dir = await opendir('./');
			
 
				+     *   for await (const dirent of dir)
			
 
				+     *     console.log(dirent.name);
			
 
				+     * } catch (err) {
			
 
				+     *   console.error(err);
			
 
				+     * }
			
 
				+     * ```
			
 
				+     *
			
 
				+     * When using the async iterator, the `fs.Dir` object will be automatically
			
 
				+     * closed after the iterator exits.
			
 
				+     * @since v12.12.0
			
 
				+     */
			
 
				+    export class Dir implements AsyncIterable<Dirent> {
			
 
				+        /**
			
 
				+         * The read-only path of this directory as was provided to {@link opendir},{@link opendirSync}, or `fsPromises.opendir()`.
			
 
				+         * @since v12.12.0
			
 
				+         */
			
 
				+        readonly path: string;
			
 
				+        /**
			
 
				+         * Asynchronously iterates over the directory via `readdir(3)` until all entries have been read.
			
 
				+         */
			
 
				+        [Symbol.asyncIterator](): AsyncIterableIterator<Dirent>;
			
 
				+        /**
			
 
				+         * Asynchronously close the directory's underlying resource handle.
			
 
				+         * Subsequent reads will result in errors.
			
 
				+         *
			
 
				+         * A promise is returned that will be resolved after the resource has been
			
 
				+         * closed.
			
 
				+         * @since v12.12.0
			
 
				+         */
			
 
				+        close(): Promise<void>;
			
 
				+        close(cb: NoParamCallback): void;
			
 
				+        /**
			
 
				+         * Synchronously close the directory's underlying resource handle.
			
 
				+         * Subsequent reads will result in errors.
			
 
				+         * @since v12.12.0
			
 
				+         */
			
 
				+        closeSync(): void;
			
 
				+        /**
			
 
				+         * Asynchronously read the next directory entry via [`readdir(3)`](http://man7.org/linux/man-pages/man3/readdir.3.html) as an `fs.Dirent`.
			
 
				+         *
			
 
				+         * A promise is returned that will be resolved with an `fs.Dirent`, or `null`if there are no more directory entries to read.
			
 
				+         *
			
 
				+         * Directory entries returned by this function are in no particular order as
			
 
				+         * provided by the operating system's underlying directory mechanisms.
			
 
				+         * Entries added or removed while iterating over the directory might not be
			
 
				+         * included in the iteration results.
			
 
				+         * @since v12.12.0
			
 
				+         * @return containing {fs.Dirent|null}
			
 
				+         */
			
 
				+        read(): Promise<Dirent | null>;
			
 
				+        read(cb: (err: NodeJS.ErrnoException | null, dirEnt: Dirent | null) => void): void;
			
 
				+        /**
			
 
				+         * Synchronously read the next directory entry as an `fs.Dirent`. See the
			
 
				+         * POSIX [`readdir(3)`](http://man7.org/linux/man-pages/man3/readdir.3.html) documentation for more detail.
			
 
				+         *
			
 
				+         * If there are no more directory entries to read, `null` will be returned.
			
 
				+         *
			
 
				+         * Directory entries returned by this function are in no particular order as
			
 
				+         * provided by the operating system's underlying directory mechanisms.
			
 
				+         * Entries added or removed while iterating over the directory might not be
			
 
				+         * included in the iteration results.
			
 
				+         * @since v12.12.0
			
 
				+         */
			
 
				+        readSync(): Dirent | null;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Class: fs.StatWatcher
			
 
				+     * @since v14.3.0, v12.20.0
			
 
				+     * Extends `EventEmitter`
			
 
				+     * A successful call to {@link watchFile} method will return a new fs.StatWatcher object.
			
 
				+     */
			
 
				+    export interface StatWatcher extends EventEmitter {
			
 
				+        /**
			
 
				+         * When called, requests that the Node.js event loop _not_ exit so long as the `fs.StatWatcher` is active. Calling `watcher.ref()` multiple times will have
			
 
				+         * no effect.
			
 
				+         *
			
 
				+         * By default, all `fs.StatWatcher` objects are "ref'ed", making it normally
			
 
				+         * unnecessary to call `watcher.ref()` unless `watcher.unref()` had been
			
 
				+         * called previously.
			
 
				+         * @since v14.3.0, v12.20.0
			
 
				+         */
			
 
				+        ref(): this;
			
 
				+        /**
			
 
				+         * When called, the active `fs.StatWatcher` object will not require the Node.js
			
 
				+         * event loop to remain active. If there is no other activity keeping the
			
 
				+         * event loop running, the process may exit before the `fs.StatWatcher` object's
			
 
				+         * callback is invoked. Calling `watcher.unref()` multiple times will have
			
 
				+         * no effect.
			
 
				+         * @since v14.3.0, v12.20.0
			
 
				+         */
			
 
				+        unref(): this;
			
 
				+    }
			
 
				+    export interface FSWatcher extends EventEmitter {
			
 
				+        /**
			
 
				+         * Stop watching for changes on the given `fs.FSWatcher`. Once stopped, the `fs.FSWatcher` object is no longer usable.
			
 
				+         * @since v0.5.8
			
 
				+         */
			
 
				+        close(): void;
			
 
				+        /**
			
 
				+         * events.EventEmitter
			
 
				+         *   1. change
			
 
				+         *   2. error
			
 
				+         */
			
 
				+        addListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        addListener(event: 'change', listener: (eventType: string, filename: string | Buffer) => void): this;
			
 
				+        addListener(event: 'error', listener: (error: Error) => void): this;
			
 
				+        addListener(event: 'close', listener: () => void): this;
			
 
				+        on(event: string, listener: (...args: any[]) => void): this;
			
 
				+        on(event: 'change', listener: (eventType: string, filename: string | Buffer) => void): this;
			
 
				+        on(event: 'error', listener: (error: Error) => void): this;
			
 
				+        on(event: 'close', listener: () => void): this;
			
 
				+        once(event: string, listener: (...args: any[]) => void): this;
			
 
				+        once(event: 'change', listener: (eventType: string, filename: string | Buffer) => void): this;
			
 
				+        once(event: 'error', listener: (error: Error) => void): this;
			
 
				+        once(event: 'close', listener: () => void): this;
			
 
				+        prependListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependListener(event: 'change', listener: (eventType: string, filename: string | Buffer) => void): this;
			
 
				+        prependListener(event: 'error', listener: (error: Error) => void): this;
			
 
				+        prependListener(event: 'close', listener: () => void): this;
			
 
				+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
			
 
				+        prependOnceListener(event: 'change', listener: (eventType: string, filename: string | Buffer) => void): this;
			
 
				+        prependOnceListener(event: 'error', listener: (error: Error) => void): this;
			
 
				+        prependOnceListener(event: 'close', listener: () => void): this;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Instances of `fs.ReadStream` are created and returned using the {@link createReadStream} function.
			
 
				+     * @since v0.1.93
			
 
				+     */
			
 
				+    export class ReadStream extends stream.Readable {
			
 
				+        close(callback?: (err?: NodeJS.ErrnoException | null) => void): void;
			
 
				+        /**
			
 
				+         * The number of bytes that have been read so far.
			
 
				+         * @since v6.4.0
			
 
				+         */
			
 
				+        bytesRead: number;
			
 
				+        /**
			
 
				+         * The path to the file the stream is reading from as specified in the first
			
 
				+         * argument to `fs.createReadStream()`. If `path` is passed as a string, then`readStream.path` will be a string. If `path` is passed as a `Buffer`, then`readStream.path` will be a
			
 
				+         * `Buffer`. If `fd` is specified, then`readStream.path` will be `undefined`.
			
 
				+         * @since v0.1.93
			
 
				+         */
			
 
				+        path: string | Buffer;
			
 
				+        /**
			
 
				+         * This property is `true` if the underlying file has not been opened yet,
			
 
				+         * i.e. before the `'ready'` event is emitted.
			
 
				+         * @since v11.2.0, v10.16.0
			
 
				+         */
			
 
				+        pending: boolean;
			
 
				+        /**
			
 
				+         * events.EventEmitter
			
 
				+         *   1. open
			
 
				+         *   2. close
			
 
				+         *   3. ready
			
 
				+         */
			
 
				+        addListener(event: 'close', listener: () => void): this;
			
 
				+        addListener(event: 'data', listener: (chunk: Buffer | string) => void): this;
			
 
				+        addListener(event: 'end', listener: () => void): this;
			
 
				+        addListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        addListener(event: 'open', listener: (fd: number) => void): this;
			
 
				+        addListener(event: 'pause', listener: () => void): this;
			
 
				+        addListener(event: 'readable', listener: () => void): this;
			
 
				+        addListener(event: 'ready', listener: () => void): this;
			
 
				+        addListener(event: 'resume', listener: () => void): this;
			
 
				+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+        on(event: 'close', listener: () => void): this;
			
 
				+        on(event: 'data', listener: (chunk: Buffer | string) => void): this;
			
 
				+        on(event: 'end', listener: () => void): this;
			
 
				+        on(event: 'error', listener: (err: Error) => void): this;
			
 
				+        on(event: 'open', listener: (fd: number) => void): this;
			
 
				+        on(event: 'pause', listener: () => void): this;
			
 
				+        on(event: 'readable', listener: () => void): this;
			
 
				+        on(event: 'ready', listener: () => void): this;
			
 
				+        on(event: 'resume', listener: () => void): this;
			
 
				+        on(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+        once(event: 'close', listener: () => void): this;
			
 
				+        once(event: 'data', listener: (chunk: Buffer | string) => void): this;
			
 
				+        once(event: 'end', listener: () => void): this;
			
 
				+        once(event: 'error', listener: (err: Error) => void): this;
			
 
				+        once(event: 'open', listener: (fd: number) => void): this;
			
 
				+        once(event: 'pause', listener: () => void): this;
			
 
				+        once(event: 'readable', listener: () => void): this;
			
 
				+        once(event: 'ready', listener: () => void): this;
			
 
				+        once(event: 'resume', listener: () => void): this;
			
 
				+        once(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+        prependListener(event: 'close', listener: () => void): this;
			
 
				+        prependListener(event: 'data', listener: (chunk: Buffer | string) => void): this;
			
 
				+        prependListener(event: 'end', listener: () => void): this;
			
 
				+        prependListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        prependListener(event: 'open', listener: (fd: number) => void): this;
			
 
				+        prependListener(event: 'pause', listener: () => void): this;
			
 
				+        prependListener(event: 'readable', listener: () => void): this;
			
 
				+        prependListener(event: 'ready', listener: () => void): this;
			
 
				+        prependListener(event: 'resume', listener: () => void): this;
			
 
				+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+        prependOnceListener(event: 'close', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'data', listener: (chunk: Buffer | string) => void): this;
			
 
				+        prependOnceListener(event: 'end', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        prependOnceListener(event: 'open', listener: (fd: number) => void): this;
			
 
				+        prependOnceListener(event: 'pause', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'readable', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'ready', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'resume', listener: () => void): this;
			
 
				+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+    }
			
 
				+    /**
			
 
				+     * * Extends `stream.Writable`
			
 
				+     *
			
 
				+     * Instances of `fs.WriteStream` are created and returned using the {@link createWriteStream} function.
			
 
				+     * @since v0.1.93
			
 
				+     */
			
 
				+    export class WriteStream extends stream.Writable {
			
 
				+        /**
			
 
				+         * Closes `writeStream`. Optionally accepts a
			
 
				+         * callback that will be executed once the `writeStream`is closed.
			
 
				+         * @since v0.9.4
			
 
				+         */
			
 
				+        close(callback?: (err?: NodeJS.ErrnoException | null) => void): void;
			
 
				+        /**
			
 
				+         * The number of bytes written so far. Does not include data that is still queued
			
 
				+         * for writing.
			
 
				+         * @since v0.4.7
			
 
				+         */
			
 
				+        bytesWritten: number;
			
 
				+        /**
			
 
				+         * The path to the file the stream is writing to as specified in the first
			
 
				+         * argument to {@link createWriteStream}. If `path` is passed as a string, then`writeStream.path` will be a string. If `path` is passed as a `Buffer`, then`writeStream.path` will be a
			
 
				+         * `Buffer`.
			
 
				+         * @since v0.1.93
			
 
				+         */
			
 
				+        path: string | Buffer;
			
 
				+        /**
			
 
				+         * This property is `true` if the underlying file has not been opened yet,
			
 
				+         * i.e. before the `'ready'` event is emitted.
			
 
				+         * @since v11.2.0
			
 
				+         */
			
 
				+        pending: boolean;
			
 
				+        /**
			
 
				+         * events.EventEmitter
			
 
				+         *   1. open
			
 
				+         *   2. close
			
 
				+         *   3. ready
			
 
				+         */
			
 
				+        addListener(event: 'close', listener: () => void): this;
			
 
				+        addListener(event: 'drain', listener: () => void): this;
			
 
				+        addListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        addListener(event: 'finish', listener: () => void): this;
			
 
				+        addListener(event: 'open', listener: (fd: number) => void): this;
			
 
				+        addListener(event: 'pipe', listener: (src: stream.Readable) => void): this;
			
 
				+        addListener(event: 'ready', listener: () => void): this;
			
 
				+        addListener(event: 'unpipe', listener: (src: stream.Readable) => void): this;
			
 
				+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+        on(event: 'close', listener: () => void): this;
			
 
				+        on(event: 'drain', listener: () => void): this;
			
 
				+        on(event: 'error', listener: (err: Error) => void): this;
			
 
				+        on(event: 'finish', listener: () => void): this;
			
 
				+        on(event: 'open', listener: (fd: number) => void): this;
			
 
				+        on(event: 'pipe', listener: (src: stream.Readable) => void): this;
			
 
				+        on(event: 'ready', listener: () => void): this;
			
 
				+        on(event: 'unpipe', listener: (src: stream.Readable) => void): this;
			
 
				+        on(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+        once(event: 'close', listener: () => void): this;
			
 
				+        once(event: 'drain', listener: () => void): this;
			
 
				+        once(event: 'error', listener: (err: Error) => void): this;
			
 
				+        once(event: 'finish', listener: () => void): this;
			
 
				+        once(event: 'open', listener: (fd: number) => void): this;
			
 
				+        once(event: 'pipe', listener: (src: stream.Readable) => void): this;
			
 
				+        once(event: 'ready', listener: () => void): this;
			
 
				+        once(event: 'unpipe', listener: (src: stream.Readable) => void): this;
			
 
				+        once(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+        prependListener(event: 'close', listener: () => void): this;
			
 
				+        prependListener(event: 'drain', listener: () => void): this;
			
 
				+        prependListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        prependListener(event: 'finish', listener: () => void): this;
			
 
				+        prependListener(event: 'open', listener: (fd: number) => void): this;
			
 
				+        prependListener(event: 'pipe', listener: (src: stream.Readable) => void): this;
			
 
				+        prependListener(event: 'ready', listener: () => void): this;
			
 
				+        prependListener(event: 'unpipe', listener: (src: stream.Readable) => void): this;
			
 
				+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+        prependOnceListener(event: 'close', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'drain', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
			
 
				+        prependOnceListener(event: 'finish', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'open', listener: (fd: number) => void): this;
			
 
				+        prependOnceListener(event: 'pipe', listener: (src: stream.Readable) => void): this;
			
 
				+        prependOnceListener(event: 'ready', listener: () => void): this;
			
 
				+        prependOnceListener(event: 'unpipe', listener: (src: stream.Readable) => void): this;
			
 
				+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Asynchronously rename file at `oldPath` to the pathname provided
			
 
				+     * as `newPath`. In the case that `newPath` already exists, it will
			
 
				+     * be overwritten. If there is a directory at `newPath`, an error will
			
 
				+     * be raised instead. No arguments other than a possible exception are
			
 
				+     * given to the completion callback.
			
 
				+     *
			
 
				+     * See also: [`rename(2)`](http://man7.org/linux/man-pages/man2/rename.2.html).
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { rename } from 'fs';
			
 
				+     *
			
 
				+     * rename('oldFile.txt', 'newFile.txt', (err) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log('Rename complete!');
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v0.0.2
			
 
				+     */
			
 
				+    export function rename(oldPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
			
 
				+    export namespace rename {
			
 
				+        /**
			
 
				+         * Asynchronous rename(2) - Change the name or location of a file or directory.
			
 
				+         * @param oldPath A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * URL support is _experimental_.
			
 
				+         * @param newPath A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * URL support is _experimental_.
			
 
				+         */
			
 
				+        function __promisify__(oldPath: PathLike, newPath: PathLike): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Renames the file from `oldPath` to `newPath`. Returns `undefined`.
			
 
				+     *
			
 
				+     * See the POSIX [`rename(2)`](http://man7.org/linux/man-pages/man2/rename.2.html) documentation for more details.
			
 
				+     * @since v0.1.21
			
 
				+     */
			
 
				+    export function renameSync(oldPath: PathLike, newPath: PathLike): void;
			
 
				+    /**
			
 
				+     * Truncates the file. No arguments other than a possible exception are
			
 
				+     * given to the completion callback. A file descriptor can also be passed as the
			
 
				+     * first argument. In this case, `fs.ftruncate()` is called.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { truncate } from 'fs';
			
 
				+     * // Assuming that 'path/file.txt' is a regular file.
			
 
				+     * truncate('path/file.txt', (err) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log('path/file.txt was truncated');
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Passing a file descriptor is deprecated and may result in an error being thrown
			
 
				+     * in the future.
			
 
				+     *
			
 
				+     * See the POSIX [`truncate(2)`](http://man7.org/linux/man-pages/man2/truncate.2.html) documentation for more details.
			
 
				+     * @since v0.8.6
			
 
				+     * @param [len=0]
			
 
				+     */
			
 
				+    export function truncate(path: PathLike, len: number | undefined | null, callback: NoParamCallback): void;
			
 
				+    /**
			
 
				+     * Asynchronous truncate(2) - Truncate a file to a specified length.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function truncate(path: PathLike, callback: NoParamCallback): void;
			
 
				+    export namespace truncate {
			
 
				+        /**
			
 
				+         * Asynchronous truncate(2) - Truncate a file to a specified length.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param len If not specified, defaults to `0`.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, len?: number | null): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Truncates the file. Returns `undefined`. A file descriptor can also be
			
 
				+     * passed as the first argument. In this case, `fs.ftruncateSync()` is called.
			
 
				+     *
			
 
				+     * Passing a file descriptor is deprecated and may result in an error being thrown
			
 
				+     * in the future.
			
 
				+     * @since v0.8.6
			
 
				+     * @param [len=0]
			
 
				+     */
			
 
				+    export function truncateSync(path: PathLike, len?: number | null): void;
			
 
				+    /**
			
 
				+     * Truncates the file descriptor. No arguments other than a possible exception are
			
 
				+     * given to the completion callback.
			
 
				+     *
			
 
				+     * See the POSIX [`ftruncate(2)`](http://man7.org/linux/man-pages/man2/ftruncate.2.html) documentation for more detail.
			
 
				+     *
			
 
				+     * If the file referred to by the file descriptor was larger than `len` bytes, only
			
 
				+     * the first `len` bytes will be retained in the file.
			
 
				+     *
			
 
				+     * For example, the following program retains only the first four bytes of the
			
 
				+     * file:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { open, close, ftruncate } from 'fs';
			
 
				+     *
			
 
				+     * function closeFd(fd) {
			
 
				+     *   close(fd, (err) => {
			
 
				+     *     if (err) throw err;
			
 
				+     *   });
			
 
				+     * }
			
 
				+     *
			
 
				+     * open('temp.txt', 'r+', (err, fd) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *
			
 
				+     *   try {
			
 
				+     *     ftruncate(fd, 4, (err) => {
			
 
				+     *       closeFd(fd);
			
 
				+     *       if (err) throw err;
			
 
				+     *     });
			
 
				+     *   } catch (err) {
			
 
				+     *     closeFd(fd);
			
 
				+     *     if (err) throw err;
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If the file previously was shorter than `len` bytes, it is extended, and the
			
 
				+     * extended part is filled with null bytes (`'\0'`):
			
 
				+     *
			
 
				+     * If `len` is negative then `0` will be used.
			
 
				+     * @since v0.8.6
			
 
				+     * @param [len=0]
			
 
				+     */
			
 
				+    export function ftruncate(fd: number, len: number | undefined | null, callback: NoParamCallback): void;
			
 
				+    /**
			
 
				+     * Asynchronous ftruncate(2) - Truncate a file to a specified length.
			
 
				+     * @param fd A file descriptor.
			
 
				+     */
			
 
				+    export function ftruncate(fd: number, callback: NoParamCallback): void;
			
 
				+    export namespace ftruncate {
			
 
				+        /**
			
 
				+         * Asynchronous ftruncate(2) - Truncate a file to a specified length.
			
 
				+         * @param fd A file descriptor.
			
 
				+         * @param len If not specified, defaults to `0`.
			
 
				+         */
			
 
				+        function __promisify__(fd: number, len?: number | null): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Truncates the file descriptor. Returns `undefined`.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link ftruncate}.
			
 
				+     * @since v0.8.6
			
 
				+     * @param [len=0]
			
 
				+     */
			
 
				+    export function ftruncateSync(fd: number, len?: number | null): void;
			
 
				+    /**
			
 
				+     * Asynchronously changes owner and group of a file. No arguments other than a
			
 
				+     * possible exception are given to the completion callback.
			
 
				+     *
			
 
				+     * See the POSIX [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html) documentation for more detail.
			
 
				+     * @since v0.1.97
			
 
				+     */
			
 
				+    export function chown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
			
 
				+    export namespace chown {
			
 
				+        /**
			
 
				+         * Asynchronous chown(2) - Change ownership of a file.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, uid: number, gid: number): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronously changes owner and group of a file. Returns `undefined`.
			
 
				+     * This is the synchronous version of {@link chown}.
			
 
				+     *
			
 
				+     * See the POSIX [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html) documentation for more detail.
			
 
				+     * @since v0.1.97
			
 
				+     */
			
 
				+    export function chownSync(path: PathLike, uid: number, gid: number): void;
			
 
				+    /**
			
 
				+     * Sets the owner of the file. No arguments other than a possible exception are
			
 
				+     * given to the completion callback.
			
 
				+     *
			
 
				+     * See the POSIX [`fchown(2)`](http://man7.org/linux/man-pages/man2/fchown.2.html) documentation for more detail.
			
 
				+     * @since v0.4.7
			
 
				+     */
			
 
				+    export function fchown(fd: number, uid: number, gid: number, callback: NoParamCallback): void;
			
 
				+    export namespace fchown {
			
 
				+        /**
			
 
				+         * Asynchronous fchown(2) - Change ownership of a file.
			
 
				+         * @param fd A file descriptor.
			
 
				+         */
			
 
				+        function __promisify__(fd: number, uid: number, gid: number): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Sets the owner of the file. Returns `undefined`.
			
 
				+     *
			
 
				+     * See the POSIX [`fchown(2)`](http://man7.org/linux/man-pages/man2/fchown.2.html) documentation for more detail.
			
 
				+     * @since v0.4.7
			
 
				+     * @param uid The file's new owner's user id.
			
 
				+     * @param gid The file's new group's group id.
			
 
				+     */
			
 
				+    export function fchownSync(fd: number, uid: number, gid: number): void;
			
 
				+    /**
			
 
				+     * Set the owner of the symbolic link. No arguments other than a possible
			
 
				+     * exception are given to the completion callback.
			
 
				+     *
			
 
				+     * See the POSIX [`lchown(2)`](http://man7.org/linux/man-pages/man2/lchown.2.html) documentation for more detail.
			
 
				+     */
			
 
				+    export function lchown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
			
 
				+    export namespace lchown {
			
 
				+        /**
			
 
				+         * Asynchronous lchown(2) - Change ownership of a file. Does not dereference symbolic links.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, uid: number, gid: number): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Set the owner for the path. Returns `undefined`.
			
 
				+     *
			
 
				+     * See the POSIX [`lchown(2)`](http://man7.org/linux/man-pages/man2/lchown.2.html) documentation for more details.
			
 
				+     * @param uid The file's new owner's user id.
			
 
				+     * @param gid The file's new group's group id.
			
 
				+     */
			
 
				+    export function lchownSync(path: PathLike, uid: number, gid: number): void;
			
 
				+    /**
			
 
				+     * Changes the access and modification times of a file in the same way as {@link utimes}, with the difference that if the path refers to a symbolic
			
 
				+     * link, then the link is not dereferenced: instead, the timestamps of the
			
 
				+     * symbolic link itself are changed.
			
 
				+     *
			
 
				+     * No arguments other than a possible exception are given to the completion
			
 
				+     * callback.
			
 
				+     * @since v14.5.0, v12.19.0
			
 
				+     */
			
 
				+    export function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
			
 
				+    export namespace lutimes {
			
 
				+        /**
			
 
				+         * Changes the access and modification times of a file in the same way as `fsPromises.utimes()`,
			
 
				+         * with the difference that if the path refers to a symbolic link, then the link is not
			
 
				+         * dereferenced: instead, the timestamps of the symbolic link itself are changed.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param atime The last access time. If a string is provided, it will be coerced to number.
			
 
				+         * @param mtime The last modified time. If a string is provided, it will be coerced to number.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Change the file system timestamps of the symbolic link referenced by `path`.
			
 
				+     * Returns `undefined`, or throws an exception when parameters are incorrect or
			
 
				+     * the operation fails. This is the synchronous version of {@link lutimes}.
			
 
				+     * @since v14.5.0, v12.19.0
			
 
				+     */
			
 
				+    export function lutimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
			
 
				+    /**
			
 
				+     * Asynchronously changes the permissions of a file. No arguments other than a
			
 
				+     * possible exception are given to the completion callback.
			
 
				+     *
			
 
				+     * See the POSIX [`chmod(2)`](http://man7.org/linux/man-pages/man2/chmod.2.html) documentation for more detail.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { chmod } from 'fs';
			
 
				+     *
			
 
				+     * chmod('my_file.txt', 0o775, (err) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log('The permissions for file "my_file.txt" have been changed!');
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v0.1.30
			
 
				+     */
			
 
				+    export function chmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
			
 
				+    export namespace chmod {
			
 
				+        /**
			
 
				+         * Asynchronous chmod(2) - Change permissions of a file.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param mode A file mode. If a string is passed, it is parsed as an octal integer.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, mode: Mode): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link chmod}.
			
 
				+     *
			
 
				+     * See the POSIX [`chmod(2)`](http://man7.org/linux/man-pages/man2/chmod.2.html) documentation for more detail.
			
 
				+     * @since v0.6.7
			
 
				+     */
			
 
				+    export function chmodSync(path: PathLike, mode: Mode): void;
			
 
				+    /**
			
 
				+     * Sets the permissions on the file. No arguments other than a possible exception
			
 
				+     * are given to the completion callback.
			
 
				+     *
			
 
				+     * See the POSIX [`fchmod(2)`](http://man7.org/linux/man-pages/man2/fchmod.2.html) documentation for more detail.
			
 
				+     * @since v0.4.7
			
 
				+     */
			
 
				+    export function fchmod(fd: number, mode: Mode, callback: NoParamCallback): void;
			
 
				+    export namespace fchmod {
			
 
				+        /**
			
 
				+         * Asynchronous fchmod(2) - Change permissions of a file.
			
 
				+         * @param fd A file descriptor.
			
 
				+         * @param mode A file mode. If a string is passed, it is parsed as an octal integer.
			
 
				+         */
			
 
				+        function __promisify__(fd: number, mode: Mode): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Sets the permissions on the file. Returns `undefined`.
			
 
				+     *
			
 
				+     * See the POSIX [`fchmod(2)`](http://man7.org/linux/man-pages/man2/fchmod.2.html) documentation for more detail.
			
 
				+     * @since v0.4.7
			
 
				+     */
			
 
				+    export function fchmodSync(fd: number, mode: Mode): void;
			
 
				+    /**
			
 
				+     * Changes the permissions on a symbolic link. No arguments other than a possible
			
 
				+     * exception are given to the completion callback.
			
 
				+     *
			
 
				+     * This method is only implemented on macOS.
			
 
				+     *
			
 
				+     * See the POSIX [`lchmod(2)`](https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2) documentation for more detail.
			
 
				+     * @deprecated Since v0.4.7
			
 
				+     */
			
 
				+    export function lchmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
			
 
				+    /** @deprecated */
			
 
				+    export namespace lchmod {
			
 
				+        /**
			
 
				+         * Asynchronous lchmod(2) - Change permissions of a file. Does not dereference symbolic links.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param mode A file mode. If a string is passed, it is parsed as an octal integer.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, mode: Mode): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Changes the permissions on a symbolic link. Returns `undefined`.
			
 
				+     *
			
 
				+     * This method is only implemented on macOS.
			
 
				+     *
			
 
				+     * See the POSIX [`lchmod(2)`](https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2) documentation for more detail.
			
 
				+     * @deprecated Since v0.4.7
			
 
				+     */
			
 
				+    export function lchmodSync(path: PathLike, mode: Mode): void;
			
 
				+    /**
			
 
				+     * Asynchronous [`stat(2)`](http://man7.org/linux/man-pages/man2/stat.2.html). The callback gets two arguments `(err, stats)` where`stats` is an `fs.Stats` object.
			
 
				+     *
			
 
				+     * In case of an error, the `err.code` will be one of `Common System Errors`.
			
 
				+     *
			
 
				+     * Using `fs.stat()` to check for the existence of a file before calling`fs.open()`, `fs.readFile()` or `fs.writeFile()` is not recommended.
			
 
				+     * Instead, user code should open/read/write the file directly and handle the
			
 
				+     * error raised if the file is not available.
			
 
				+     *
			
 
				+     * To check if a file exists without manipulating it afterwards, {@link access} is recommended.
			
 
				+     *
			
 
				+     * For example, given the following directory structure:
			
 
				+     *
			
 
				+     * ```text
			
 
				+     * - txtDir
			
 
				+     * -- file.txt
			
 
				+     * - app.js
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The next program will check for the stats of the given paths:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { stat } from 'fs';
			
 
				+     *
			
 
				+     * const pathsToCheck = ['./txtDir', './txtDir/file.txt'];
			
 
				+     *
			
 
				+     * for (let i = 0; i < pathsToCheck.length; i++) {
			
 
				+     *   stat(pathsToCheck[i], (err, stats) => {
			
 
				+     *     console.log(stats.isDirectory());
			
 
				+     *     console.log(stats);
			
 
				+     *   });
			
 
				+     * }
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The resulting output will resemble:
			
 
				+     *
			
 
				+     * ```console
			
 
				+     * true
			
 
				+     * Stats {
			
 
				+     *   dev: 16777220,
			
 
				+     *   mode: 16877,
			
 
				+     *   nlink: 3,
			
 
				+     *   uid: 501,
			
 
				+     *   gid: 20,
			
 
				+     *   rdev: 0,
			
 
				+     *   blksize: 4096,
			
 
				+     *   ino: 14214262,
			
 
				+     *   size: 96,
			
 
				+     *   blocks: 0,
			
 
				+     *   atimeMs: 1561174653071.963,
			
 
				+     *   mtimeMs: 1561174614583.3518,
			
 
				+     *   ctimeMs: 1561174626623.5366,
			
 
				+     *   birthtimeMs: 1561174126937.2893,
			
 
				+     *   atime: 2019-06-22T03:37:33.072Z,
			
 
				+     *   mtime: 2019-06-22T03:36:54.583Z,
			
 
				+     *   ctime: 2019-06-22T03:37:06.624Z,
			
 
				+     *   birthtime: 2019-06-22T03:28:46.937Z
			
 
				+     * }
			
 
				+     * false
			
 
				+     * Stats {
			
 
				+     *   dev: 16777220,
			
 
				+     *   mode: 33188,
			
 
				+     *   nlink: 1,
			
 
				+     *   uid: 501,
			
 
				+     *   gid: 20,
			
 
				+     *   rdev: 0,
			
 
				+     *   blksize: 4096,
			
 
				+     *   ino: 14214074,
			
 
				+     *   size: 8,
			
 
				+     *   blocks: 8,
			
 
				+     *   atimeMs: 1561174616618.8555,
			
 
				+     *   mtimeMs: 1561174614584,
			
 
				+     *   ctimeMs: 1561174614583.8145,
			
 
				+     *   birthtimeMs: 1561174007710.7478,
			
 
				+     *   atime: 2019-06-22T03:36:56.619Z,
			
 
				+     *   mtime: 2019-06-22T03:36:54.584Z,
			
 
				+     *   ctime: 2019-06-22T03:36:54.584Z,
			
 
				+     *   birthtime: 2019-06-22T03:26:47.711Z
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v0.0.2
			
 
				+     */
			
 
				+    export function stat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
			
 
				+    export function stat(
			
 
				+        path: PathLike,
			
 
				+        options:
			
 
				+            | (StatOptions & {
			
 
				+                  bigint?: false | undefined;
			
 
				+              })
			
 
				+            | undefined,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void
			
 
				+    ): void;
			
 
				+    export function stat(
			
 
				+        path: PathLike,
			
 
				+        options: StatOptions & {
			
 
				+            bigint: true;
			
 
				+        },
			
 
				+        callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void
			
 
				+    ): void;
			
 
				+    export function stat(path: PathLike, options: StatOptions | undefined, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
			
 
				+    export namespace stat {
			
 
				+        /**
			
 
				+         * Asynchronous stat(2) - Get file status.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options?: StatOptions & {
			
 
				+                bigint?: false | undefined;
			
 
				+            }
			
 
				+        ): Promise<Stats>;
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options: StatOptions & {
			
 
				+                bigint: true;
			
 
				+            }
			
 
				+        ): Promise<BigIntStats>;
			
 
				+        function __promisify__(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats>;
			
 
				+    }
			
 
				+    export interface StatSyncFn extends Function {
			
 
				+        (path: PathLike, options?: undefined): Stats;
			
 
				+        (
			
 
				+            path: PathLike,
			
 
				+            options?: StatSyncOptions & {
			
 
				+                bigint?: false | undefined;
			
 
				+                throwIfNoEntry: false;
			
 
				+            }
			
 
				+        ): Stats | undefined;
			
 
				+        (
			
 
				+            path: PathLike,
			
 
				+            options: StatSyncOptions & {
			
 
				+                bigint: true;
			
 
				+                throwIfNoEntry: false;
			
 
				+            }
			
 
				+        ): BigIntStats | undefined;
			
 
				+        (
			
 
				+            path: PathLike,
			
 
				+            options?: StatSyncOptions & {
			
 
				+                bigint?: false | undefined;
			
 
				+            }
			
 
				+        ): Stats;
			
 
				+        (
			
 
				+            path: PathLike,
			
 
				+            options: StatSyncOptions & {
			
 
				+                bigint: true;
			
 
				+            }
			
 
				+        ): BigIntStats;
			
 
				+        (
			
 
				+            path: PathLike,
			
 
				+            options: StatSyncOptions & {
			
 
				+                bigint: boolean;
			
 
				+                throwIfNoEntry?: false | undefined;
			
 
				+            }
			
 
				+        ): Stats | BigIntStats;
			
 
				+        (path: PathLike, options?: StatSyncOptions): Stats | BigIntStats | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronous stat(2) - Get file status.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export const statSync: StatSyncFn;
			
 
				+    /**
			
 
				+     * Invokes the callback with the `fs.Stats` for the file descriptor.
			
 
				+     *
			
 
				+     * See the POSIX [`fstat(2)`](http://man7.org/linux/man-pages/man2/fstat.2.html) documentation for more detail.
			
 
				+     * @since v0.1.95
			
 
				+     */
			
 
				+    export function fstat(fd: number, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
			
 
				+    export function fstat(
			
 
				+        fd: number,
			
 
				+        options:
			
 
				+            | (StatOptions & {
			
 
				+                  bigint?: false | undefined;
			
 
				+              })
			
 
				+            | undefined,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void
			
 
				+    ): void;
			
 
				+    export function fstat(
			
 
				+        fd: number,
			
 
				+        options: StatOptions & {
			
 
				+            bigint: true;
			
 
				+        },
			
 
				+        callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void
			
 
				+    ): void;
			
 
				+    export function fstat(fd: number, options: StatOptions | undefined, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
			
 
				+    export namespace fstat {
			
 
				+        /**
			
 
				+         * Asynchronous fstat(2) - Get file status.
			
 
				+         * @param fd A file descriptor.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            fd: number,
			
 
				+            options?: StatOptions & {
			
 
				+                bigint?: false | undefined;
			
 
				+            }
			
 
				+        ): Promise<Stats>;
			
 
				+        function __promisify__(
			
 
				+            fd: number,
			
 
				+            options: StatOptions & {
			
 
				+                bigint: true;
			
 
				+            }
			
 
				+        ): Promise<BigIntStats>;
			
 
				+        function __promisify__(fd: number, options?: StatOptions): Promise<Stats | BigIntStats>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Retrieves the `fs.Stats` for the file descriptor.
			
 
				+     *
			
 
				+     * See the POSIX [`fstat(2)`](http://man7.org/linux/man-pages/man2/fstat.2.html) documentation for more detail.
			
 
				+     * @since v0.1.95
			
 
				+     */
			
 
				+    export function fstatSync(
			
 
				+        fd: number,
			
 
				+        options?: StatOptions & {
			
 
				+            bigint?: false | undefined;
			
 
				+        }
			
 
				+    ): Stats;
			
 
				+    export function fstatSync(
			
 
				+        fd: number,
			
 
				+        options: StatOptions & {
			
 
				+            bigint: true;
			
 
				+        }
			
 
				+    ): BigIntStats;
			
 
				+    export function fstatSync(fd: number, options?: StatOptions): Stats | BigIntStats;
			
 
				+    /**
			
 
				+     * Retrieves the `fs.Stats` for the symbolic link referred to by the path.
			
 
				+     * The callback gets two arguments `(err, stats)` where `stats` is a `fs.Stats` object. `lstat()` is identical to `stat()`, except that if `path` is a symbolic
			
 
				+     * link, then the link itself is stat-ed, not the file that it refers to.
			
 
				+     *
			
 
				+     * See the POSIX [`lstat(2)`](http://man7.org/linux/man-pages/man2/lstat.2.html) documentation for more details.
			
 
				+     * @since v0.1.30
			
 
				+     */
			
 
				+    export function lstat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
			
 
				+    export function lstat(
			
 
				+        path: PathLike,
			
 
				+        options:
			
 
				+            | (StatOptions & {
			
 
				+                  bigint?: false | undefined;
			
 
				+              })
			
 
				+            | undefined,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void
			
 
				+    ): void;
			
 
				+    export function lstat(
			
 
				+        path: PathLike,
			
 
				+        options: StatOptions & {
			
 
				+            bigint: true;
			
 
				+        },
			
 
				+        callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void
			
 
				+    ): void;
			
 
				+    export function lstat(path: PathLike, options: StatOptions | undefined, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
			
 
				+    export namespace lstat {
			
 
				+        /**
			
 
				+         * Asynchronous lstat(2) - Get file status. Does not dereference symbolic links.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options?: StatOptions & {
			
 
				+                bigint?: false | undefined;
			
 
				+            }
			
 
				+        ): Promise<Stats>;
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options: StatOptions & {
			
 
				+                bigint: true;
			
 
				+            }
			
 
				+        ): Promise<BigIntStats>;
			
 
				+        function __promisify__(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Asynchronous statfs(2). Returns information about the mounted file system which contains path. The callback gets two arguments (err, stats) where stats is an <fs.StatFs> object.
			
 
				+     * In case of an error, the err.code will be one of Common System Errors.
			
 
				+     * @param path A path to an existing file or directory on the file system to be queried.
			
 
				+     * @param callback
			
 
				+     */
			
 
				+    export function statfs(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void): void;
			
 
				+    export function statfs(
			
 
				+        path: PathLike,
			
 
				+        options:
			
 
				+            | (StatFsOptions & {
			
 
				+                  bigint?: false | undefined;
			
 
				+              })
			
 
				+            | undefined,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void
			
 
				+    ): void;
			
 
				+    export function statfs(
			
 
				+        path: PathLike,
			
 
				+        options: StatFsOptions & {
			
 
				+            bigint: true;
			
 
				+        },
			
 
				+        callback: (err: NodeJS.ErrnoException | null, stats: BigIntStatsFs) => void
			
 
				+    ): void;
			
 
				+    export function statfs(path: PathLike, options: StatFsOptions | undefined, callback: (err: NodeJS.ErrnoException | null, stats: StatsFs | BigIntStatsFs) => void): void;
			
 
				+    export namespace statfs {
			
 
				+        /**
			
 
				+         * Asynchronous statfs(2) - Returns information about the mounted file system which contains path. The callback gets two arguments (err, stats) where stats is an <fs.StatFs> object.
			
 
				+         * @param path A path to an existing file or directory on the file system to be queried.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options?: StatFsOptions & {
			
 
				+                bigint?: false | undefined;
			
 
				+            }
			
 
				+        ): Promise<StatsFs>;
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options: StatFsOptions & {
			
 
				+                bigint: true;
			
 
				+            }
			
 
				+        ): Promise<BigIntStatsFs>;
			
 
				+        function __promisify__(path: PathLike, options?: StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
			
 
				+    }
			
 
				+
			
 
				+    /**
			
 
				+     * Synchronous statfs(2). Returns information about the mounted file system which contains path. The callback gets two arguments (err, stats) where stats is an <fs.StatFs> object.
			
 
				+     * In case of an error, the err.code will be one of Common System Errors.
			
 
				+     * @param path A path to an existing file or directory on the file system to be queried.
			
 
				+     * @param callback
			
 
				+     */
			
 
				+    export function statfsSync(
			
 
				+        path: PathLike,
			
 
				+        options?: StatFsOptions & {
			
 
				+            bigint?: false | undefined;
			
 
				+        }
			
 
				+    ): StatsFs;
			
 
				+    export function statfsSync(
			
 
				+        path: PathLike,
			
 
				+        options: StatFsOptions & {
			
 
				+            bigint: true;
			
 
				+        }
			
 
				+    ): BigIntStatsFs;
			
 
				+
			
 
				+    export function statfsSync(path: PathLike, options?: StatFsOptions): StatsFs | BigIntStatsFs;
			
 
				+    /**
			
 
				+     * Synchronous lstat(2) - Get file status. Does not dereference symbolic links.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export const lstatSync: StatSyncFn;
			
 
				+    /**
			
 
				+     * Creates a new link from the `existingPath` to the `newPath`. See the POSIX [`link(2)`](http://man7.org/linux/man-pages/man2/link.2.html) documentation for more detail. No arguments other than
			
 
				+     * a possible
			
 
				+     * exception are given to the completion callback.
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function link(existingPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
			
 
				+    export namespace link {
			
 
				+        /**
			
 
				+         * Asynchronous link(2) - Create a new link (also known as a hard link) to an existing file.
			
 
				+         * @param existingPath A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param newPath A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         */
			
 
				+        function __promisify__(existingPath: PathLike, newPath: PathLike): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Creates a new link from the `existingPath` to the `newPath`. See the POSIX [`link(2)`](http://man7.org/linux/man-pages/man2/link.2.html) documentation for more detail. Returns `undefined`.
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function linkSync(existingPath: PathLike, newPath: PathLike): void;
			
 
				+    /**
			
 
				+     * Creates the link called `path` pointing to `target`. No arguments other than a
			
 
				+     * possible exception are given to the completion callback.
			
 
				+     *
			
 
				+     * See the POSIX [`symlink(2)`](http://man7.org/linux/man-pages/man2/symlink.2.html) documentation for more details.
			
 
				+     *
			
 
				+     * The `type` argument is only available on Windows and ignored on other platforms.
			
 
				+     * It can be set to `'dir'`, `'file'`, or `'junction'`. If the `type` argument is
			
 
				+     * not set, Node.js will autodetect `target` type and use `'file'` or `'dir'`. If
			
 
				+     * the `target` does not exist, `'file'` will be used. Windows junction points
			
 
				+     * require the destination path to be absolute. When using `'junction'`, the`target` argument will automatically be normalized to absolute path.
			
 
				+     *
			
 
				+     * Relative targets are relative to the link’s parent directory.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { symlink } from 'fs';
			
 
				+     *
			
 
				+     * symlink('./mew', './mewtwo', callback);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The above example creates a symbolic link `mewtwo` which points to `mew` in the
			
 
				+     * same directory:
			
 
				+     *
			
 
				+     * ```bash
			
 
				+     * $ tree .
			
 
				+     * .
			
 
				+     * ├── mew
			
 
				+     * └── mewtwo -> ./mew
			
 
				+     * ```
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function symlink(target: PathLike, path: PathLike, type: symlink.Type | undefined | null, callback: NoParamCallback): void;
			
 
				+    /**
			
 
				+     * Asynchronous symlink(2) - Create a new symbolic link to an existing file.
			
 
				+     * @param target A path to an existing file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param path A path to the new symlink. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function symlink(target: PathLike, path: PathLike, callback: NoParamCallback): void;
			
 
				+    export namespace symlink {
			
 
				+        /**
			
 
				+         * Asynchronous symlink(2) - Create a new symbolic link to an existing file.
			
 
				+         * @param target A path to an existing file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param path A path to the new symlink. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param type May be set to `'dir'`, `'file'`, or `'junction'` (default is `'file'`) and is only available on Windows (ignored on other platforms).
			
 
				+         * When using `'junction'`, the `target` argument will automatically be normalized to an absolute path.
			
 
				+         */
			
 
				+        function __promisify__(target: PathLike, path: PathLike, type?: string | null): Promise<void>;
			
 
				+        type Type = 'dir' | 'file' | 'junction';
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns `undefined`.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link symlink}.
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function symlinkSync(target: PathLike, path: PathLike, type?: symlink.Type | null): void;
			
 
				+    /**
			
 
				+     * Reads the contents of the symbolic link referred to by `path`. The callback gets
			
 
				+     * two arguments `(err, linkString)`.
			
 
				+     *
			
 
				+     * See the POSIX [`readlink(2)`](http://man7.org/linux/man-pages/man2/readlink.2.html) documentation for more details.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use for
			
 
				+     * the link path passed to the callback. If the `encoding` is set to `'buffer'`,
			
 
				+     * the link path returned will be passed as a `Buffer` object.
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function readlink(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, linkString: string) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous readlink(2) - read value of a symbolic link.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function readlink(path: PathLike, options: BufferEncodingOption, callback: (err: NodeJS.ErrnoException | null, linkString: Buffer) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous readlink(2) - read value of a symbolic link.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function readlink(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, linkString: string | Buffer) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous readlink(2) - read value of a symbolic link.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function readlink(path: PathLike, callback: (err: NodeJS.ErrnoException | null, linkString: string) => void): void;
			
 
				+    export namespace readlink {
			
 
				+        /**
			
 
				+         * Asynchronous readlink(2) - read value of a symbolic link.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, options?: EncodingOption): Promise<string>;
			
 
				+        /**
			
 
				+         * Asynchronous readlink(2) - read value of a symbolic link.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, options: BufferEncodingOption): Promise<Buffer>;
			
 
				+        /**
			
 
				+         * Asynchronous readlink(2) - read value of a symbolic link.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, options?: EncodingOption): Promise<string | Buffer>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns the symbolic link's string value.
			
 
				+     *
			
 
				+     * See the POSIX [`readlink(2)`](http://man7.org/linux/man-pages/man2/readlink.2.html) documentation for more details.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use for
			
 
				+     * the link path returned. If the `encoding` is set to `'buffer'`,
			
 
				+     * the link path returned will be passed as a `Buffer` object.
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function readlinkSync(path: PathLike, options?: EncodingOption): string;
			
 
				+    /**
			
 
				+     * Synchronous readlink(2) - read value of a symbolic link.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function readlinkSync(path: PathLike, options: BufferEncodingOption): Buffer;
			
 
				+    /**
			
 
				+     * Synchronous readlink(2) - read value of a symbolic link.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function readlinkSync(path: PathLike, options?: EncodingOption): string | Buffer;
			
 
				+    /**
			
 
				+     * Asynchronously computes the canonical pathname by resolving `.`, `..` and
			
 
				+     * symbolic links.
			
 
				+     *
			
 
				+     * A canonical pathname is not necessarily unique. Hard links and bind mounts can
			
 
				+     * expose a file system entity through many pathnames.
			
 
				+     *
			
 
				+     * This function behaves like [`realpath(3)`](http://man7.org/linux/man-pages/man3/realpath.3.html), with some exceptions:
			
 
				+     *
			
 
				+     * 1. No case conversion is performed on case-insensitive file systems.
			
 
				+     * 2. The maximum number of symbolic links is platform-independent and generally
			
 
				+     * (much) higher than what the native [`realpath(3)`](http://man7.org/linux/man-pages/man3/realpath.3.html) implementation supports.
			
 
				+     *
			
 
				+     * The `callback` gets two arguments `(err, resolvedPath)`. May use `process.cwd`to resolve relative paths.
			
 
				+     *
			
 
				+     * Only paths that can be converted to UTF8 strings are supported.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use for
			
 
				+     * the path passed to the callback. If the `encoding` is set to `'buffer'`,
			
 
				+     * the path returned will be passed as a `Buffer` object.
			
 
				+     *
			
 
				+     * If `path` resolves to a socket or a pipe, the function will return a system
			
 
				+     * dependent name for that object.
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function realpath(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function realpath(path: PathLike, options: BufferEncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: Buffer) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function realpath(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string | Buffer) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function realpath(path: PathLike, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
			
 
				+    export namespace realpath {
			
 
				+        /**
			
 
				+         * Asynchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, options?: EncodingOption): Promise<string>;
			
 
				+        /**
			
 
				+         * Asynchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, options: BufferEncodingOption): Promise<Buffer>;
			
 
				+        /**
			
 
				+         * Asynchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, options?: EncodingOption): Promise<string | Buffer>;
			
 
				+        /**
			
 
				+         * Asynchronous [`realpath(3)`](http://man7.org/linux/man-pages/man3/realpath.3.html).
			
 
				+         *
			
 
				+         * The `callback` gets two arguments `(err, resolvedPath)`.
			
 
				+         *
			
 
				+         * Only paths that can be converted to UTF8 strings are supported.
			
 
				+         *
			
 
				+         * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+         * object with an `encoding` property specifying the character encoding to use for
			
 
				+         * the path passed to the callback. If the `encoding` is set to `'buffer'`,
			
 
				+         * the path returned will be passed as a `Buffer` object.
			
 
				+         *
			
 
				+         * On Linux, when Node.js is linked against musl libc, the procfs file system must
			
 
				+         * be mounted on `/proc` in order for this function to work. Glibc does not have
			
 
				+         * this restriction.
			
 
				+         * @since v9.2.0
			
 
				+         */
			
 
				+        function native(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
			
 
				+        function native(path: PathLike, options: BufferEncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: Buffer) => void): void;
			
 
				+        function native(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string | Buffer) => void): void;
			
 
				+        function native(path: PathLike, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns the resolved pathname.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link realpath}.
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function realpathSync(path: PathLike, options?: EncodingOption): string;
			
 
				+    /**
			
 
				+     * Synchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function realpathSync(path: PathLike, options: BufferEncodingOption): Buffer;
			
 
				+    /**
			
 
				+     * Synchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function realpathSync(path: PathLike, options?: EncodingOption): string | Buffer;
			
 
				+    export namespace realpathSync {
			
 
				+        function native(path: PathLike, options?: EncodingOption): string;
			
 
				+        function native(path: PathLike, options: BufferEncodingOption): Buffer;
			
 
				+        function native(path: PathLike, options?: EncodingOption): string | Buffer;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Asynchronously removes a file or symbolic link. No arguments other than a
			
 
				+     * possible exception are given to the completion callback.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { unlink } from 'fs';
			
 
				+     * // Assuming that 'path/file.txt' is a regular file.
			
 
				+     * unlink('path/file.txt', (err) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log('path/file.txt was deleted');
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * `fs.unlink()` will not work on a directory, empty or otherwise. To remove a
			
 
				+     * directory, use {@link rmdir}.
			
 
				+     *
			
 
				+     * See the POSIX [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html) documentation for more details.
			
 
				+     * @since v0.0.2
			
 
				+     */
			
 
				+    export function unlink(path: PathLike, callback: NoParamCallback): void;
			
 
				+    export namespace unlink {
			
 
				+        /**
			
 
				+         * Asynchronous unlink(2) - delete a name and possibly the file it refers to.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronous [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html). Returns `undefined`.
			
 
				+     * @since v0.1.21
			
 
				+     */
			
 
				+    export function unlinkSync(path: PathLike): void;
			
 
				+    export interface RmDirOptions {
			
 
				+        /**
			
 
				+         * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
			
 
				+         * `EPERM` error is encountered, Node.js will retry the operation with a linear
			
 
				+         * backoff wait of `retryDelay` ms longer on each try. This option represents the
			
 
				+         * number of retries. This option is ignored if the `recursive` option is not
			
 
				+         * `true`.
			
 
				+         * @default 0
			
 
				+         */
			
 
				+        maxRetries?: number | undefined;
			
 
				+        /**
			
 
				+         * @deprecated since v14.14.0 In future versions of Node.js and will trigger a warning
			
 
				+         * `fs.rmdir(path, { recursive: true })` will throw if `path` does not exist or is a file.
			
 
				+         * Use `fs.rm(path, { recursive: true, force: true })` instead.
			
 
				+         *
			
 
				+         * If `true`, perform a recursive directory removal. In
			
 
				+         * recursive mode, operations are retried on failure.
			
 
				+         * @default false
			
 
				+         */
			
 
				+        recursive?: boolean | undefined;
			
 
				+        /**
			
 
				+         * The amount of time in milliseconds to wait between retries.
			
 
				+         * This option is ignored if the `recursive` option is not `true`.
			
 
				+         * @default 100
			
 
				+         */
			
 
				+        retryDelay?: number | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Asynchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). No arguments other than a possible exception are given
			
 
				+     * to the completion callback.
			
 
				+     *
			
 
				+     * Using `fs.rmdir()` on a file (not a directory) results in an `ENOENT` error on
			
 
				+     * Windows and an `ENOTDIR` error on POSIX.
			
 
				+     *
			
 
				+     * To get a behavior similar to the `rm -rf` Unix command, use {@link rm} with options `{ recursive: true, force: true }`.
			
 
				+     * @since v0.0.2
			
 
				+     */
			
 
				+    export function rmdir(path: PathLike, callback: NoParamCallback): void;
			
 
				+    export function rmdir(path: PathLike, options: RmDirOptions, callback: NoParamCallback): void;
			
 
				+    export namespace rmdir {
			
 
				+        /**
			
 
				+         * Asynchronous rmdir(2) - delete a directory.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, options?: RmDirOptions): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). Returns `undefined`.
			
 
				+     *
			
 
				+     * Using `fs.rmdirSync()` on a file (not a directory) results in an `ENOENT` error
			
 
				+     * on Windows and an `ENOTDIR` error on POSIX.
			
 
				+     *
			
 
				+     * To get a behavior similar to the `rm -rf` Unix command, use {@link rmSync} with options `{ recursive: true, force: true }`.
			
 
				+     * @since v0.1.21
			
 
				+     */
			
 
				+    export function rmdirSync(path: PathLike, options?: RmDirOptions): void;
			
 
				+    export interface RmOptions {
			
 
				+        /**
			
 
				+         * When `true`, exceptions will be ignored if `path` does not exist.
			
 
				+         * @default false
			
 
				+         */
			
 
				+        force?: boolean | undefined;
			
 
				+        /**
			
 
				+         * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
			
 
				+         * `EPERM` error is encountered, Node.js will retry the operation with a linear
			
 
				+         * backoff wait of `retryDelay` ms longer on each try. This option represents the
			
 
				+         * number of retries. This option is ignored if the `recursive` option is not
			
 
				+         * `true`.
			
 
				+         * @default 0
			
 
				+         */
			
 
				+        maxRetries?: number | undefined;
			
 
				+        /**
			
 
				+         * If `true`, perform a recursive directory removal. In
			
 
				+         * recursive mode, operations are retried on failure.
			
 
				+         * @default false
			
 
				+         */
			
 
				+        recursive?: boolean | undefined;
			
 
				+        /**
			
 
				+         * The amount of time in milliseconds to wait between retries.
			
 
				+         * This option is ignored if the `recursive` option is not `true`.
			
 
				+         * @default 100
			
 
				+         */
			
 
				+        retryDelay?: number | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Asynchronously removes files and directories (modeled on the standard POSIX `rm`utility). No arguments other than a possible exception are given to the
			
 
				+     * completion callback.
			
 
				+     * @since v14.14.0
			
 
				+     */
			
 
				+    export function rm(path: PathLike, callback: NoParamCallback): void;
			
 
				+    export function rm(path: PathLike, options: RmOptions, callback: NoParamCallback): void;
			
 
				+    export namespace rm {
			
 
				+        /**
			
 
				+         * Asynchronously removes files and directories (modeled on the standard POSIX `rm` utility).
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, options?: RmOptions): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronously removes files and directories (modeled on the standard POSIX `rm`utility). Returns `undefined`.
			
 
				+     * @since v14.14.0
			
 
				+     */
			
 
				+    export function rmSync(path: PathLike, options?: RmOptions): void;
			
 
				+    export interface MakeDirectoryOptions {
			
 
				+        /**
			
 
				+         * Indicates whether parent folders should be created.
			
 
				+         * If a folder was created, the path to the first created folder will be returned.
			
 
				+         * @default false
			
 
				+         */
			
 
				+        recursive?: boolean | undefined;
			
 
				+        /**
			
 
				+         * A file mode. If a string is passed, it is parsed as an octal integer. If not specified
			
 
				+         * @default 0o777
			
 
				+         */
			
 
				+        mode?: Mode | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Asynchronously creates a directory.
			
 
				+     *
			
 
				+     * The callback is given a possible exception and, if `recursive` is `true`, the
			
 
				+     * first directory path created, `(err[, path])`.`path` can still be `undefined` when `recursive` is `true`, if no directory was
			
 
				+     * created.
			
 
				+     *
			
 
				+     * The optional `options` argument can be an integer specifying `mode` (permission
			
 
				+     * and sticky bits), or an object with a `mode` property and a `recursive`property indicating whether parent directories should be created. Calling`fs.mkdir()` when `path` is a directory that
			
 
				+     * exists results in an error only
			
 
				+     * when `recursive` is false.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { mkdir } from 'fs';
			
 
				+     *
			
 
				+     * // Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.
			
 
				+     * mkdir('/tmp/a/apple', { recursive: true }, (err) => {
			
 
				+     *   if (err) throw err;
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * On Windows, using `fs.mkdir()` on the root directory even with recursion will
			
 
				+     * result in an error:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { mkdir } from 'fs';
			
 
				+     *
			
 
				+     * mkdir('/', { recursive: true }, (err) => {
			
 
				+     *   // => [Error: EPERM: operation not permitted, mkdir 'C:\']
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * See the POSIX [`mkdir(2)`](http://man7.org/linux/man-pages/man2/mkdir.2.html) documentation for more details.
			
 
				+     * @since v0.1.8
			
 
				+     */
			
 
				+    export function mkdir(
			
 
				+        path: PathLike,
			
 
				+        options: MakeDirectoryOptions & {
			
 
				+            recursive: true;
			
 
				+        },
			
 
				+        callback: (err: NodeJS.ErrnoException | null, path?: string) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronous mkdir(2) - create a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
			
 
				+     * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
			
 
				+     */
			
 
				+    export function mkdir(
			
 
				+        path: PathLike,
			
 
				+        options:
			
 
				+            | Mode
			
 
				+            | (MakeDirectoryOptions & {
			
 
				+                  recursive?: false | undefined;
			
 
				+              })
			
 
				+            | null
			
 
				+            | undefined,
			
 
				+        callback: NoParamCallback
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronous mkdir(2) - create a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
			
 
				+     * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
			
 
				+     */
			
 
				+    export function mkdir(path: PathLike, options: Mode | MakeDirectoryOptions | null | undefined, callback: (err: NodeJS.ErrnoException | null, path?: string) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous mkdir(2) - create a directory with a mode of `0o777`.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function mkdir(path: PathLike, callback: NoParamCallback): void;
			
 
				+    export namespace mkdir {
			
 
				+        /**
			
 
				+         * Asynchronous mkdir(2) - create a directory.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
			
 
				+         * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options: MakeDirectoryOptions & {
			
 
				+                recursive: true;
			
 
				+            }
			
 
				+        ): Promise<string | undefined>;
			
 
				+        /**
			
 
				+         * Asynchronous mkdir(2) - create a directory.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
			
 
				+         * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options?:
			
 
				+                | Mode
			
 
				+                | (MakeDirectoryOptions & {
			
 
				+                      recursive?: false | undefined;
			
 
				+                  })
			
 
				+                | null
			
 
				+        ): Promise<void>;
			
 
				+        /**
			
 
				+         * Asynchronous mkdir(2) - create a directory.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
			
 
				+         * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronously creates a directory. Returns `undefined`, or if `recursive` is`true`, the first directory path created.
			
 
				+     * This is the synchronous version of {@link mkdir}.
			
 
				+     *
			
 
				+     * See the POSIX [`mkdir(2)`](http://man7.org/linux/man-pages/man2/mkdir.2.html) documentation for more details.
			
 
				+     * @since v0.1.21
			
 
				+     */
			
 
				+    export function mkdirSync(
			
 
				+        path: PathLike,
			
 
				+        options: MakeDirectoryOptions & {
			
 
				+            recursive: true;
			
 
				+        }
			
 
				+    ): string | undefined;
			
 
				+    /**
			
 
				+     * Synchronous mkdir(2) - create a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
			
 
				+     * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
			
 
				+     */
			
 
				+    export function mkdirSync(
			
 
				+        path: PathLike,
			
 
				+        options?:
			
 
				+            | Mode
			
 
				+            | (MakeDirectoryOptions & {
			
 
				+                  recursive?: false | undefined;
			
 
				+              })
			
 
				+            | null
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Synchronous mkdir(2) - create a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
			
 
				+     * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
			
 
				+     */
			
 
				+    export function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions | null): string | undefined;
			
 
				+    /**
			
 
				+     * Creates a unique temporary directory.
			
 
				+     *
			
 
				+     * Generates six random characters to be appended behind a required`prefix` to create a unique temporary directory. Due to platform
			
 
				+     * inconsistencies, avoid trailing `X` characters in `prefix`. Some platforms,
			
 
				+     * notably the BSDs, can return more than six random characters, and replace
			
 
				+     * trailing `X` characters in `prefix` with random characters.
			
 
				+     *
			
 
				+     * The created directory path is passed as a string to the callback's second
			
 
				+     * parameter.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { mkdtemp } from 'fs';
			
 
				+     *
			
 
				+     * mkdtemp(path.join(os.tmpdir(), 'foo-'), (err, directory) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(directory);
			
 
				+     *   // Prints: /tmp/foo-itXde2 or C:\Users\...\AppData\Local\Temp\foo-itXde2
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The `fs.mkdtemp()` method will append the six randomly selected characters
			
 
				+     * directly to the `prefix` string. For instance, given a directory `/tmp`, if the
			
 
				+     * intention is to create a temporary directory _within_`/tmp`, the `prefix`must end with a trailing platform-specific path separator
			
 
				+     * (`require('path').sep`).
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { tmpdir } from 'os';
			
 
				+     * import { mkdtemp } from 'fs';
			
 
				+     *
			
 
				+     * // The parent directory for the new temporary directory
			
 
				+     * const tmpDir = tmpdir();
			
 
				+     *
			
 
				+     * // This method is *INCORRECT*:
			
 
				+     * mkdtemp(tmpDir, (err, directory) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(directory);
			
 
				+     *   // Will print something similar to `/tmpabc123`.
			
 
				+     *   // A new temporary directory is created at the file system root
			
 
				+     *   // rather than *within* the /tmp directory.
			
 
				+     * });
			
 
				+     *
			
 
				+     * // This method is *CORRECT*:
			
 
				+     * import { sep } from 'path';
			
 
				+     * mkdtemp(`${tmpDir}${sep}`, (err, directory) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(directory);
			
 
				+     *   // Will print something similar to `/tmp/abc123`.
			
 
				+     *   // A new temporary directory is created within
			
 
				+     *   // the /tmp directory.
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v5.10.0
			
 
				+     */
			
 
				+    export function mkdtemp(prefix: string, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, folder: string) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronously creates a unique temporary directory.
			
 
				+     * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function mkdtemp(
			
 
				+        prefix: string,
			
 
				+        options:
			
 
				+            | 'buffer'
			
 
				+            | {
			
 
				+                  encoding: 'buffer';
			
 
				+              },
			
 
				+        callback: (err: NodeJS.ErrnoException | null, folder: Buffer) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronously creates a unique temporary directory.
			
 
				+     * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function mkdtemp(prefix: string, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, folder: string | Buffer) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronously creates a unique temporary directory.
			
 
				+     * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
			
 
				+     */
			
 
				+    export function mkdtemp(prefix: string, callback: (err: NodeJS.ErrnoException | null, folder: string) => void): void;
			
 
				+    export namespace mkdtemp {
			
 
				+        /**
			
 
				+         * Asynchronously creates a unique temporary directory.
			
 
				+         * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(prefix: string, options?: EncodingOption): Promise<string>;
			
 
				+        /**
			
 
				+         * Asynchronously creates a unique temporary directory.
			
 
				+         * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(prefix: string, options: BufferEncodingOption): Promise<Buffer>;
			
 
				+        /**
			
 
				+         * Asynchronously creates a unique temporary directory.
			
 
				+         * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(prefix: string, options?: EncodingOption): Promise<string | Buffer>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns the created directory path.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link mkdtemp}.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use.
			
 
				+     * @since v5.10.0
			
 
				+     */
			
 
				+    export function mkdtempSync(prefix: string, options?: EncodingOption): string;
			
 
				+    /**
			
 
				+     * Synchronously creates a unique temporary directory.
			
 
				+     * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function mkdtempSync(prefix: string, options: BufferEncodingOption): Buffer;
			
 
				+    /**
			
 
				+     * Synchronously creates a unique temporary directory.
			
 
				+     * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function mkdtempSync(prefix: string, options?: EncodingOption): string | Buffer;
			
 
				+    /**
			
 
				+     * Reads the contents of a directory. The callback gets two arguments `(err, files)`where `files` is an array of the names of the files in the directory excluding`'.'` and `'..'`.
			
 
				+     *
			
 
				+     * See the POSIX [`readdir(3)`](http://man7.org/linux/man-pages/man3/readdir.3.html) documentation for more details.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use for
			
 
				+     * the filenames passed to the callback. If the `encoding` is set to `'buffer'`,
			
 
				+     * the filenames returned will be passed as `Buffer` objects.
			
 
				+     *
			
 
				+     * If `options.withFileTypes` is set to `true`, the `files` array will contain `fs.Dirent` objects.
			
 
				+     * @since v0.1.8
			
 
				+     */
			
 
				+    export function readdir(
			
 
				+        path: PathLike,
			
 
				+        options:
			
 
				+            | {
			
 
				+                  encoding: BufferEncoding | null;
			
 
				+                  withFileTypes?: false | undefined;
			
 
				+              }
			
 
				+            | BufferEncoding
			
 
				+            | undefined
			
 
				+            | null,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, files: string[]) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function readdir(
			
 
				+        path: PathLike,
			
 
				+        options:
			
 
				+            | {
			
 
				+                  encoding: 'buffer';
			
 
				+                  withFileTypes?: false | undefined;
			
 
				+              }
			
 
				+            | 'buffer',
			
 
				+        callback: (err: NodeJS.ErrnoException | null, files: Buffer[]) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function readdir(
			
 
				+        path: PathLike,
			
 
				+        options:
			
 
				+            | (ObjectEncodingOptions & {
			
 
				+                  withFileTypes?: false | undefined;
			
 
				+              })
			
 
				+            | BufferEncoding
			
 
				+            | undefined
			
 
				+            | null,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, files: string[] | Buffer[]) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function readdir(path: PathLike, callback: (err: NodeJS.ErrnoException | null, files: string[]) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options If called with `withFileTypes: true` the result data will be an array of Dirent.
			
 
				+     */
			
 
				+    export function readdir(
			
 
				+        path: PathLike,
			
 
				+        options: ObjectEncodingOptions & {
			
 
				+            withFileTypes: true;
			
 
				+        },
			
 
				+        callback: (err: NodeJS.ErrnoException | null, files: Dirent[]) => void
			
 
				+    ): void;
			
 
				+    export namespace readdir {
			
 
				+        /**
			
 
				+         * Asynchronous readdir(3) - read a directory.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options?:
			
 
				+                | {
			
 
				+                      encoding: BufferEncoding | null;
			
 
				+                      withFileTypes?: false | undefined;
			
 
				+                  }
			
 
				+                | BufferEncoding
			
 
				+                | null
			
 
				+        ): Promise<string[]>;
			
 
				+        /**
			
 
				+         * Asynchronous readdir(3) - read a directory.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options:
			
 
				+                | 'buffer'
			
 
				+                | {
			
 
				+                      encoding: 'buffer';
			
 
				+                      withFileTypes?: false | undefined;
			
 
				+                  }
			
 
				+        ): Promise<Buffer[]>;
			
 
				+        /**
			
 
				+         * Asynchronous readdir(3) - read a directory.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options?:
			
 
				+                | (ObjectEncodingOptions & {
			
 
				+                      withFileTypes?: false | undefined;
			
 
				+                  })
			
 
				+                | BufferEncoding
			
 
				+                | null
			
 
				+        ): Promise<string[] | Buffer[]>;
			
 
				+        /**
			
 
				+         * Asynchronous readdir(3) - read a directory.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param options If called with `withFileTypes: true` the result data will be an array of Dirent
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathLike,
			
 
				+            options: ObjectEncodingOptions & {
			
 
				+                withFileTypes: true;
			
 
				+            }
			
 
				+        ): Promise<Dirent[]>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Reads the contents of the directory.
			
 
				+     *
			
 
				+     * See the POSIX [`readdir(3)`](http://man7.org/linux/man-pages/man3/readdir.3.html) documentation for more details.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use for
			
 
				+     * the filenames returned. If the `encoding` is set to `'buffer'`,
			
 
				+     * the filenames returned will be passed as `Buffer` objects.
			
 
				+     *
			
 
				+     * If `options.withFileTypes` is set to `true`, the result will contain `fs.Dirent` objects.
			
 
				+     * @since v0.1.21
			
 
				+     */
			
 
				+    export function readdirSync(
			
 
				+        path: PathLike,
			
 
				+        options?:
			
 
				+            | {
			
 
				+                  encoding: BufferEncoding | null;
			
 
				+                  withFileTypes?: false | undefined;
			
 
				+              }
			
 
				+            | BufferEncoding
			
 
				+            | null
			
 
				+    ): string[];
			
 
				+    /**
			
 
				+     * Synchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function readdirSync(
			
 
				+        path: PathLike,
			
 
				+        options:
			
 
				+            | {
			
 
				+                  encoding: 'buffer';
			
 
				+                  withFileTypes?: false | undefined;
			
 
				+              }
			
 
				+            | 'buffer'
			
 
				+    ): Buffer[];
			
 
				+    /**
			
 
				+     * Synchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    export function readdirSync(
			
 
				+        path: PathLike,
			
 
				+        options?:
			
 
				+            | (ObjectEncodingOptions & {
			
 
				+                  withFileTypes?: false | undefined;
			
 
				+              })
			
 
				+            | BufferEncoding
			
 
				+            | null
			
 
				+    ): string[] | Buffer[];
			
 
				+    /**
			
 
				+     * Synchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options If called with `withFileTypes: true` the result data will be an array of Dirent.
			
 
				+     */
			
 
				+    export function readdirSync(
			
 
				+        path: PathLike,
			
 
				+        options: ObjectEncodingOptions & {
			
 
				+            withFileTypes: true;
			
 
				+        }
			
 
				+    ): Dirent[];
			
 
				+    /**
			
 
				+     * Closes the file descriptor. No arguments other than a possible exception are
			
 
				+     * given to the completion callback.
			
 
				+     *
			
 
				+     * Calling `fs.close()` on any file descriptor (`fd`) that is currently in use
			
 
				+     * through any other `fs` operation may lead to undefined behavior.
			
 
				+     *
			
 
				+     * See the POSIX [`close(2)`](http://man7.org/linux/man-pages/man2/close.2.html) documentation for more detail.
			
 
				+     * @since v0.0.2
			
 
				+     */
			
 
				+    export function close(fd: number, callback?: NoParamCallback): void;
			
 
				+    export namespace close {
			
 
				+        /**
			
 
				+         * Asynchronous close(2) - close a file descriptor.
			
 
				+         * @param fd A file descriptor.
			
 
				+         */
			
 
				+        function __promisify__(fd: number): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Closes the file descriptor. Returns `undefined`.
			
 
				+     *
			
 
				+     * Calling `fs.closeSync()` on any file descriptor (`fd`) that is currently in use
			
 
				+     * through any other `fs` operation may lead to undefined behavior.
			
 
				+     *
			
 
				+     * See the POSIX [`close(2)`](http://man7.org/linux/man-pages/man2/close.2.html) documentation for more detail.
			
 
				+     * @since v0.1.21
			
 
				+     */
			
 
				+    export function closeSync(fd: number): void;
			
 
				+    /**
			
 
				+     * Asynchronous file open. See the POSIX [`open(2)`](http://man7.org/linux/man-pages/man2/open.2.html) documentation for more details.
			
 
				+     *
			
 
				+     * `mode` sets the file mode (permission and sticky bits), but only if the file was
			
 
				+     * created. On Windows, only the write permission can be manipulated; see {@link chmod}.
			
 
				+     *
			
 
				+     * The callback gets two arguments `(err, fd)`.
			
 
				+     *
			
 
				+     * Some characters (`< > : " / \ | ? *`) are reserved under Windows as documented
			
 
				+     * by [Naming Files, Paths, and Namespaces](https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file). Under NTFS, if the filename contains
			
 
				+     * a colon, Node.js will open a file system stream, as described by [this MSDN page](https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams).
			
 
				+     *
			
 
				+     * Functions based on `fs.open()` exhibit this behavior as well:`fs.writeFile()`, `fs.readFile()`, etc.
			
 
				+     * @since v0.0.2
			
 
				+     * @param [flags='r'] See `support of file system `flags``.
			
 
				+     * @param [mode=0o666]
			
 
				+     */
			
 
				+    export function open(path: PathLike, flags: OpenMode | undefined, mode: Mode | undefined | null, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous open(2) - open and possibly create a file. If the file is created, its mode will be `0o666`.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param [flags='r'] See `support of file system `flags``.
			
 
				+     */
			
 
				+    export function open(path: PathLike, flags: OpenMode | undefined, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronous open(2) - open and possibly create a file. If the file is created, its mode will be `0o666`.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function open(path: PathLike, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
			
 
				+
			
 
				+    export namespace open {
			
 
				+        /**
			
 
				+         * Asynchronous open(2) - open and possibly create a file.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param mode A file mode. If a string is passed, it is parsed as an octal integer. If not supplied, defaults to `0o666`.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, flags: OpenMode, mode?: Mode | null): Promise<number>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns an integer representing the file descriptor.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link open}.
			
 
				+     * @since v0.1.21
			
 
				+     * @param [flags='r']
			
 
				+     * @param [mode=0o666]
			
 
				+     */
			
 
				+    export function openSync(path: PathLike, flags: OpenMode, mode?: Mode | null): number;
			
 
				+    /**
			
 
				+     * Change the file system timestamps of the object referenced by `path`.
			
 
				+     *
			
 
				+     * The `atime` and `mtime` arguments follow these rules:
			
 
				+     *
			
 
				+     * * Values can be either numbers representing Unix epoch time in seconds,`Date`s, or a numeric string like `'123456789.0'`.
			
 
				+     * * If the value can not be converted to a number, or is `NaN`, `Infinity` or`-Infinity`, an `Error` will be thrown.
			
 
				+     * @since v0.4.2
			
 
				+     */
			
 
				+    export function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
			
 
				+    export namespace utimes {
			
 
				+        /**
			
 
				+         * Asynchronously change file timestamps of the file referenced by the supplied path.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * @param atime The last access time. If a string is provided, it will be coerced to number.
			
 
				+         * @param mtime The last modified time. If a string is provided, it will be coerced to number.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns `undefined`.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link utimes}.
			
 
				+     * @since v0.4.2
			
 
				+     */
			
 
				+    export function utimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
			
 
				+    /**
			
 
				+     * Change the file system timestamps of the object referenced by the supplied file
			
 
				+     * descriptor. See {@link utimes}.
			
 
				+     * @since v0.4.2
			
 
				+     */
			
 
				+    export function futimes(fd: number, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
			
 
				+    export namespace futimes {
			
 
				+        /**
			
 
				+         * Asynchronously change file timestamps of the file referenced by the supplied file descriptor.
			
 
				+         * @param fd A file descriptor.
			
 
				+         * @param atime The last access time. If a string is provided, it will be coerced to number.
			
 
				+         * @param mtime The last modified time. If a string is provided, it will be coerced to number.
			
 
				+         */
			
 
				+        function __promisify__(fd: number, atime: TimeLike, mtime: TimeLike): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronous version of {@link futimes}. Returns `undefined`.
			
 
				+     * @since v0.4.2
			
 
				+     */
			
 
				+    export function futimesSync(fd: number, atime: TimeLike, mtime: TimeLike): void;
			
 
				+    /**
			
 
				+     * Request that all data for the open file descriptor is flushed to the storage
			
 
				+     * device. The specific implementation is operating system and device specific.
			
 
				+     * Refer to the POSIX [`fsync(2)`](http://man7.org/linux/man-pages/man2/fsync.2.html) documentation for more detail. No arguments other
			
 
				+     * than a possible exception are given to the completion callback.
			
 
				+     * @since v0.1.96
			
 
				+     */
			
 
				+    export function fsync(fd: number, callback: NoParamCallback): void;
			
 
				+    export namespace fsync {
			
 
				+        /**
			
 
				+         * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device.
			
 
				+         * @param fd A file descriptor.
			
 
				+         */
			
 
				+        function __promisify__(fd: number): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Request that all data for the open file descriptor is flushed to the storage
			
 
				+     * device. The specific implementation is operating system and device specific.
			
 
				+     * Refer to the POSIX [`fsync(2)`](http://man7.org/linux/man-pages/man2/fsync.2.html) documentation for more detail. Returns `undefined`.
			
 
				+     * @since v0.1.96
			
 
				+     */
			
 
				+    export function fsyncSync(fd: number): void;
			
 
				+    /**
			
 
				+     * Write `buffer` to the file specified by `fd`.
			
 
				+     *
			
 
				+     * `offset` determines the part of the buffer to be written, and `length` is
			
 
				+     * an integer specifying the number of bytes to write.
			
 
				+     *
			
 
				+     * `position` refers to the offset from the beginning of the file where this data
			
 
				+     * should be written. If `typeof position !== 'number'`, the data will be written
			
 
				+     * at the current position. See [`pwrite(2)`](http://man7.org/linux/man-pages/man2/pwrite.2.html).
			
 
				+     *
			
 
				+     * The callback will be given three arguments `(err, bytesWritten, buffer)` where`bytesWritten` specifies how many _bytes_ were written from `buffer`.
			
 
				+     *
			
 
				+     * If this method is invoked as its `util.promisify()` ed version, it returns
			
 
				+     * a promise for an `Object` with `bytesWritten` and `buffer` properties.
			
 
				+     *
			
 
				+     * It is unsafe to use `fs.write()` multiple times on the same file without waiting
			
 
				+     * for the callback. For this scenario, {@link createWriteStream} is
			
 
				+     * recommended.
			
 
				+     *
			
 
				+     * On Linux, positional writes don't work when the file is opened in append mode.
			
 
				+     * The kernel ignores the position argument and always appends the data to
			
 
				+     * the end of the file.
			
 
				+     * @since v0.0.2
			
 
				+     */
			
 
				+    export function write<TBuffer extends NodeJS.ArrayBufferView>(
			
 
				+        fd: number,
			
 
				+        buffer: TBuffer,
			
 
				+        offset: number | undefined | null,
			
 
				+        length: number | undefined | null,
			
 
				+        position: number | undefined | null,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor.
			
 
				+     * @param fd A file descriptor.
			
 
				+     * @param offset The part of the buffer to be written. If not supplied, defaults to `0`.
			
 
				+     * @param length The number of bytes to write. If not supplied, defaults to `buffer.length - offset`.
			
 
				+     */
			
 
				+    export function write<TBuffer extends NodeJS.ArrayBufferView>(
			
 
				+        fd: number,
			
 
				+        buffer: TBuffer,
			
 
				+        offset: number | undefined | null,
			
 
				+        length: number | undefined | null,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor.
			
 
				+     * @param fd A file descriptor.
			
 
				+     * @param offset The part of the buffer to be written. If not supplied, defaults to `0`.
			
 
				+     */
			
 
				+    export function write<TBuffer extends NodeJS.ArrayBufferView>(
			
 
				+        fd: number,
			
 
				+        buffer: TBuffer,
			
 
				+        offset: number | undefined | null,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor.
			
 
				+     * @param fd A file descriptor.
			
 
				+     */
			
 
				+    export function write<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronously writes `string` to the file referenced by the supplied file descriptor.
			
 
				+     * @param fd A file descriptor.
			
 
				+     * @param string A string to write.
			
 
				+     * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
			
 
				+     * @param encoding The expected string encoding.
			
 
				+     */
			
 
				+    export function write(
			
 
				+        fd: number,
			
 
				+        string: string,
			
 
				+        position: number | undefined | null,
			
 
				+        encoding: BufferEncoding | undefined | null,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, written: number, str: string) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronously writes `string` to the file referenced by the supplied file descriptor.
			
 
				+     * @param fd A file descriptor.
			
 
				+     * @param string A string to write.
			
 
				+     * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
			
 
				+     */
			
 
				+    export function write(fd: number, string: string, position: number | undefined | null, callback: (err: NodeJS.ErrnoException | null, written: number, str: string) => void): void;
			
 
				+    /**
			
 
				+     * Asynchronously writes `string` to the file referenced by the supplied file descriptor.
			
 
				+     * @param fd A file descriptor.
			
 
				+     * @param string A string to write.
			
 
				+     */
			
 
				+    export function write(fd: number, string: string, callback: (err: NodeJS.ErrnoException | null, written: number, str: string) => void): void;
			
 
				+    export namespace write {
			
 
				+        /**
			
 
				+         * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor.
			
 
				+         * @param fd A file descriptor.
			
 
				+         * @param offset The part of the buffer to be written. If not supplied, defaults to `0`.
			
 
				+         * @param length The number of bytes to write. If not supplied, defaults to `buffer.length - offset`.
			
 
				+         * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
			
 
				+         */
			
 
				+        function __promisify__<TBuffer extends NodeJS.ArrayBufferView>(
			
 
				+            fd: number,
			
 
				+            buffer?: TBuffer,
			
 
				+            offset?: number,
			
 
				+            length?: number,
			
 
				+            position?: number | null
			
 
				+        ): Promise<{
			
 
				+            bytesWritten: number;
			
 
				+            buffer: TBuffer;
			
 
				+        }>;
			
 
				+        /**
			
 
				+         * Asynchronously writes `string` to the file referenced by the supplied file descriptor.
			
 
				+         * @param fd A file descriptor.
			
 
				+         * @param string A string to write.
			
 
				+         * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
			
 
				+         * @param encoding The expected string encoding.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            fd: number,
			
 
				+            string: string,
			
 
				+            position?: number | null,
			
 
				+            encoding?: BufferEncoding | null
			
 
				+        ): Promise<{
			
 
				+            bytesWritten: number;
			
 
				+            buffer: string;
			
 
				+        }>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link write}.
			
 
				+     * @since v0.1.21
			
 
				+     * @return The number of bytes written.
			
 
				+     */
			
 
				+    export function writeSync(fd: number, buffer: NodeJS.ArrayBufferView, offset?: number | null, length?: number | null, position?: number | null): number;
			
 
				+    /**
			
 
				+     * Synchronously writes `string` to the file referenced by the supplied file descriptor, returning the number of bytes written.
			
 
				+     * @param fd A file descriptor.
			
 
				+     * @param string A string to write.
			
 
				+     * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
			
 
				+     * @param encoding The expected string encoding.
			
 
				+     */
			
 
				+    export function writeSync(fd: number, string: string, position?: number | null, encoding?: BufferEncoding | null): number;
			
 
				+    export type ReadPosition = number | bigint;
			
 
				+    export interface ReadSyncOptions {
			
 
				+        /**
			
 
				+         * @default 0
			
 
				+         */
			
 
				+        offset?: number | undefined;
			
 
				+        /**
			
 
				+         * @default `length of buffer`
			
 
				+         */
			
 
				+        length?: number | undefined;
			
 
				+        /**
			
 
				+         * @default null
			
 
				+         */
			
 
				+        position?: ReadPosition | null | undefined;
			
 
				+    }
			
 
				+    export interface ReadAsyncOptions<TBuffer extends NodeJS.ArrayBufferView> extends ReadSyncOptions {
			
 
				+        buffer?: TBuffer;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Read data from the file specified by `fd`.
			
 
				+     *
			
 
				+     * The callback is given the three arguments, `(err, bytesRead, buffer)`.
			
 
				+     *
			
 
				+     * If the file is not modified concurrently, the end-of-file is reached when the
			
 
				+     * number of bytes read is zero.
			
 
				+     *
			
 
				+     * If this method is invoked as its `util.promisify()` ed version, it returns
			
 
				+     * a promise for an `Object` with `bytesRead` and `buffer` properties.
			
 
				+     * @since v0.0.2
			
 
				+     * @param buffer The buffer that the data will be written to.
			
 
				+     * @param offset The position in `buffer` to write the data to.
			
 
				+     * @param length The number of bytes to read.
			
 
				+     * @param position Specifies where to begin reading from in the file. If `position` is `null` or `-1 `, data will be read from the current file position, and the file position will be updated. If
			
 
				+     * `position` is an integer, the file position will be unchanged.
			
 
				+     */
			
 
				+    export function read<TBuffer extends NodeJS.ArrayBufferView>(
			
 
				+        fd: number,
			
 
				+        buffer: TBuffer,
			
 
				+        offset: number,
			
 
				+        length: number,
			
 
				+        position: ReadPosition | null,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Similar to the above `fs.read` function, this version takes an optional `options` object.
			
 
				+     * If not otherwise specified in an `options` object,
			
 
				+     * `buffer` defaults to `Buffer.alloc(16384)`,
			
 
				+     * `offset` defaults to `0`,
			
 
				+     * `length` defaults to `buffer.byteLength`, `- offset` as of Node 17.6.0
			
 
				+     * `position` defaults to `null`
			
 
				+     * @since v12.17.0, 13.11.0
			
 
				+     */
			
 
				+    export function read<TBuffer extends NodeJS.ArrayBufferView>(
			
 
				+        fd: number,
			
 
				+        options: ReadAsyncOptions<TBuffer>,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void
			
 
				+    ): void;
			
 
				+    export function read(fd: number, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: NodeJS.ArrayBufferView) => void): void;
			
 
				+    export namespace read {
			
 
				+        /**
			
 
				+         * @param fd A file descriptor.
			
 
				+         * @param buffer The buffer that the data will be written to.
			
 
				+         * @param offset The offset in the buffer at which to start writing.
			
 
				+         * @param length The number of bytes to read.
			
 
				+         * @param position The offset from the beginning of the file from which data should be read. If `null`, data will be read from the current position.
			
 
				+         */
			
 
				+        function __promisify__<TBuffer extends NodeJS.ArrayBufferView>(
			
 
				+            fd: number,
			
 
				+            buffer: TBuffer,
			
 
				+            offset: number,
			
 
				+            length: number,
			
 
				+            position: number | null
			
 
				+        ): Promise<{
			
 
				+            bytesRead: number;
			
 
				+            buffer: TBuffer;
			
 
				+        }>;
			
 
				+        function __promisify__<TBuffer extends NodeJS.ArrayBufferView>(
			
 
				+            fd: number,
			
 
				+            options: ReadAsyncOptions<TBuffer>
			
 
				+        ): Promise<{
			
 
				+            bytesRead: number;
			
 
				+            buffer: TBuffer;
			
 
				+        }>;
			
 
				+        function __promisify__(fd: number): Promise<{
			
 
				+            bytesRead: number;
			
 
				+            buffer: NodeJS.ArrayBufferView;
			
 
				+        }>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns the number of `bytesRead`.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link read}.
			
 
				+     * @since v0.1.21
			
 
				+     */
			
 
				+    export function readSync(fd: number, buffer: NodeJS.ArrayBufferView, offset: number, length: number, position: ReadPosition | null): number;
			
 
				+    /**
			
 
				+     * Similar to the above `fs.readSync` function, this version takes an optional `options` object.
			
 
				+     * If no `options` object is specified, it will default with the above values.
			
 
				+     */
			
 
				+    export function readSync(fd: number, buffer: NodeJS.ArrayBufferView, opts?: ReadSyncOptions): number;
			
 
				+    /**
			
 
				+     * Asynchronously reads the entire contents of a file.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { readFile } from 'fs';
			
 
				+     *
			
 
				+     * readFile('/etc/passwd', (err, data) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log(data);
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The callback is passed two arguments `(err, data)`, where `data` is the
			
 
				+     * contents of the file.
			
 
				+     *
			
 
				+     * If no encoding is specified, then the raw buffer is returned.
			
 
				+     *
			
 
				+     * If `options` is a string, then it specifies the encoding:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { readFile } from 'fs';
			
 
				+     *
			
 
				+     * readFile('/etc/passwd', 'utf8', callback);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * When the path is a directory, the behavior of `fs.readFile()` and {@link readFileSync} is platform-specific. On macOS, Linux, and Windows, an
			
 
				+     * error will be returned. On FreeBSD, a representation of the directory's contents
			
 
				+     * will be returned.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { readFile } from 'fs';
			
 
				+     *
			
 
				+     * // macOS, Linux, and Windows
			
 
				+     * readFile('<directory>', (err, data) => {
			
 
				+     *   // => [Error: EISDIR: illegal operation on a directory, read <directory>]
			
 
				+     * });
			
 
				+     *
			
 
				+     * //  FreeBSD
			
 
				+     * readFile('<directory>', (err, data) => {
			
 
				+     *   // => null, <data>
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * It is possible to abort an ongoing request using an `AbortSignal`. If a
			
 
				+     * request is aborted the callback is called with an `AbortError`:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { readFile } from 'fs';
			
 
				+     *
			
 
				+     * const controller = new AbortController();
			
 
				+     * const signal = controller.signal;
			
 
				+     * readFile(fileInfo[0].name, { signal }, (err, buf) => {
			
 
				+     *   // ...
			
 
				+     * });
			
 
				+     * // When you want to abort the request
			
 
				+     * controller.abort();
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The `fs.readFile()` function buffers the entire file. To minimize memory costs,
			
 
				+     * when possible prefer streaming via `fs.createReadStream()`.
			
 
				+     *
			
 
				+     * Aborting an ongoing request does not abort individual operating
			
 
				+     * system requests but rather the internal buffering `fs.readFile` performs.
			
 
				+     * @since v0.1.29
			
 
				+     * @param path filename or file descriptor
			
 
				+     */
			
 
				+    export function readFile(
			
 
				+        path: PathOrFileDescriptor,
			
 
				+        options:
			
 
				+            | ({
			
 
				+                  encoding?: null | undefined;
			
 
				+                  flag?: string | undefined;
			
 
				+              } & Abortable)
			
 
				+            | undefined
			
 
				+            | null,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, data: Buffer) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronously reads the entire contents of a file.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+     * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
			
 
				+     * If a flag is not provided, it defaults to `'r'`.
			
 
				+     */
			
 
				+    export function readFile(
			
 
				+        path: PathOrFileDescriptor,
			
 
				+        options:
			
 
				+            | ({
			
 
				+                  encoding: BufferEncoding;
			
 
				+                  flag?: string | undefined;
			
 
				+              } & Abortable)
			
 
				+            | BufferEncoding,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, data: string) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronously reads the entire contents of a file.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+     * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
			
 
				+     * If a flag is not provided, it defaults to `'r'`.
			
 
				+     */
			
 
				+    export function readFile(
			
 
				+        path: PathOrFileDescriptor,
			
 
				+        options:
			
 
				+            | (ObjectEncodingOptions & {
			
 
				+                  flag?: string | undefined;
			
 
				+              } & Abortable)
			
 
				+            | BufferEncoding
			
 
				+            | undefined
			
 
				+            | null,
			
 
				+        callback: (err: NodeJS.ErrnoException | null, data: string | Buffer) => void
			
 
				+    ): void;
			
 
				+    /**
			
 
				+     * Asynchronously reads the entire contents of a file.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+     */
			
 
				+    export function readFile(path: PathOrFileDescriptor, callback: (err: NodeJS.ErrnoException | null, data: Buffer) => void): void;
			
 
				+    export namespace readFile {
			
 
				+        /**
			
 
				+         * Asynchronously reads the entire contents of a file.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+         * @param options An object that may contain an optional flag.
			
 
				+         * If a flag is not provided, it defaults to `'r'`.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathOrFileDescriptor,
			
 
				+            options?: {
			
 
				+                encoding?: null | undefined;
			
 
				+                flag?: string | undefined;
			
 
				+            } | null
			
 
				+        ): Promise<Buffer>;
			
 
				+        /**
			
 
				+         * Asynchronously reads the entire contents of a file.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * URL support is _experimental_.
			
 
				+         * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+         * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
			
 
				+         * If a flag is not provided, it defaults to `'r'`.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathOrFileDescriptor,
			
 
				+            options:
			
 
				+                | {
			
 
				+                      encoding: BufferEncoding;
			
 
				+                      flag?: string | undefined;
			
 
				+                  }
			
 
				+                | BufferEncoding
			
 
				+        ): Promise<string>;
			
 
				+        /**
			
 
				+         * Asynchronously reads the entire contents of a file.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * URL support is _experimental_.
			
 
				+         * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+         * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
			
 
				+         * If a flag is not provided, it defaults to `'r'`.
			
 
				+         */
			
 
				+        function __promisify__(
			
 
				+            path: PathOrFileDescriptor,
			
 
				+            options?:
			
 
				+                | (ObjectEncodingOptions & {
			
 
				+                      flag?: string | undefined;
			
 
				+                  })
			
 
				+                | BufferEncoding
			
 
				+                | null
			
 
				+        ): Promise<string | Buffer>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns the contents of the `path`.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link readFile}.
			
 
				+     *
			
 
				+     * If the `encoding` option is specified then this function returns a
			
 
				+     * string. Otherwise it returns a buffer.
			
 
				+     *
			
 
				+     * Similar to {@link readFile}, when the path is a directory, the behavior of`fs.readFileSync()` is platform-specific.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { readFileSync } from 'fs';
			
 
				+     *
			
 
				+     * // macOS, Linux, and Windows
			
 
				+     * readFileSync('<directory>');
			
 
				+     * // => [Error: EISDIR: illegal operation on a directory, read <directory>]
			
 
				+     *
			
 
				+     * //  FreeBSD
			
 
				+     * readFileSync('<directory>'); // => <data>
			
 
				+     * ```
			
 
				+     * @since v0.1.8
			
 
				+     * @param path filename or file descriptor
			
 
				+     */
			
 
				+    export function readFileSync(
			
 
				+        path: PathOrFileDescriptor,
			
 
				+        options?: {
			
 
				+            encoding?: null | undefined;
			
 
				+            flag?: string | undefined;
			
 
				+        } | null
			
 
				+    ): Buffer;
			
 
				+    /**
			
 
				+     * Synchronously reads the entire contents of a file.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+     * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
			
 
				+     * If a flag is not provided, it defaults to `'r'`.
			
 
				+     */
			
 
				+    export function readFileSync(
			
 
				+        path: PathOrFileDescriptor,
			
 
				+        options:
			
 
				+            | {
			
 
				+                  encoding: BufferEncoding;
			
 
				+                  flag?: string | undefined;
			
 
				+              }
			
 
				+            | BufferEncoding
			
 
				+    ): string;
			
 
				+    /**
			
 
				+     * Synchronously reads the entire contents of a file.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+     * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
			
 
				+     * If a flag is not provided, it defaults to `'r'`.
			
 
				+     */
			
 
				+    export function readFileSync(
			
 
				+        path: PathOrFileDescriptor,
			
 
				+        options?:
			
 
				+            | (ObjectEncodingOptions & {
			
 
				+                  flag?: string | undefined;
			
 
				+              })
			
 
				+            | BufferEncoding
			
 
				+            | null
			
 
				+    ): string | Buffer;
			
 
				+    export type WriteFileOptions =
			
 
				+        | (ObjectEncodingOptions &
			
 
				+              Abortable & {
			
 
				+                  mode?: Mode | undefined;
			
 
				+                  flag?: string | undefined;
			
 
				+              })
			
 
				+        | BufferEncoding
			
 
				+        | null;
			
 
				+    /**
			
 
				+     * When `file` is a filename, asynchronously writes data to the file, replacing the
			
 
				+     * file if it already exists. `data` can be a string or a buffer.
			
 
				+     *
			
 
				+     * When `file` is a file descriptor, the behavior is similar to calling`fs.write()` directly (which is recommended). See the notes below on using
			
 
				+     * a file descriptor.
			
 
				+     *
			
 
				+     * The `encoding` option is ignored if `data` is a buffer.
			
 
				+     *
			
 
				+     * The `mode` option only affects the newly created file. See {@link open} for more details.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { writeFile } from 'fs';
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     *
			
 
				+     * const data = new Uint8Array(Buffer.from('Hello Node.js'));
			
 
				+     * writeFile('message.txt', data, (err) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log('The file has been saved!');
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If `options` is a string, then it specifies the encoding:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { writeFile } from 'fs';
			
 
				+     *
			
 
				+     * writeFile('message.txt', 'Hello Node.js', 'utf8', callback);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * It is unsafe to use `fs.writeFile()` multiple times on the same file without
			
 
				+     * waiting for the callback. For this scenario, {@link createWriteStream} is
			
 
				+     * recommended.
			
 
				+     *
			
 
				+     * Similarly to `fs.readFile` \- `fs.writeFile` is a convenience method that
			
 
				+     * performs multiple `write` calls internally to write the buffer passed to it.
			
 
				+     * For performance sensitive code consider using {@link createWriteStream}.
			
 
				+     *
			
 
				+     * It is possible to use an `AbortSignal` to cancel an `fs.writeFile()`.
			
 
				+     * Cancelation is "best effort", and some amount of data is likely still
			
 
				+     * to be written.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { writeFile } from 'fs';
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     *
			
 
				+     * const controller = new AbortController();
			
 
				+     * const { signal } = controller;
			
 
				+     * const data = new Uint8Array(Buffer.from('Hello Node.js'));
			
 
				+     * writeFile('message.txt', data, { signal }, (err) => {
			
 
				+     *   // When a request is aborted - the callback is called with an AbortError
			
 
				+     * });
			
 
				+     * // When the request should be aborted
			
 
				+     * controller.abort();
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Aborting an ongoing request does not abort individual operating
			
 
				+     * system requests but rather the internal buffering `fs.writeFile` performs.
			
 
				+     * @since v0.1.29
			
 
				+     * @param file filename or file descriptor
			
 
				+     */
			
 
				+    export function writeFile(file: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options: WriteFileOptions, callback: NoParamCallback): void;
			
 
				+    /**
			
 
				+     * Asynchronously writes data to a file, replacing the file if it already exists.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+     * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string.
			
 
				+     */
			
 
				+    export function writeFile(path: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, callback: NoParamCallback): void;
			
 
				+    export namespace writeFile {
			
 
				+        /**
			
 
				+         * Asynchronously writes data to a file, replacing the file if it already exists.
			
 
				+         * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * URL support is _experimental_.
			
 
				+         * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+         * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string.
			
 
				+         * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
			
 
				+         * If `encoding` is not supplied, the default of `'utf8'` is used.
			
 
				+         * If `mode` is not supplied, the default of `0o666` is used.
			
 
				+         * If `mode` is a string, it is parsed as an octal integer.
			
 
				+         * If `flag` is not supplied, the default of `'w'` is used.
			
 
				+         */
			
 
				+        function __promisify__(path: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns `undefined`.
			
 
				+     *
			
 
				+     * The `mode` option only affects the newly created file. See {@link open} for more details.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link writeFile}.
			
 
				+     * @since v0.1.29
			
 
				+     * @param file filename or file descriptor
			
 
				+     */
			
 
				+    export function writeFileSync(file: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): void;
			
 
				+    /**
			
 
				+     * Asynchronously append data to a file, creating the file if it does not yet
			
 
				+     * exist. `data` can be a string or a `Buffer`.
			
 
				+     *
			
 
				+     * The `mode` option only affects the newly created file. See {@link open} for more details.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { appendFile } from 'fs';
			
 
				+     *
			
 
				+     * appendFile('message.txt', 'data to append', (err) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log('The "data to append" was appended to file!');
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If `options` is a string, then it specifies the encoding:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { appendFile } from 'fs';
			
 
				+     *
			
 
				+     * appendFile('message.txt', 'data to append', 'utf8', callback);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The `path` may be specified as a numeric file descriptor that has been opened
			
 
				+     * for appending (using `fs.open()` or `fs.openSync()`). The file descriptor will
			
 
				+     * not be closed automatically.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { open, close, appendFile } from 'fs';
			
 
				+     *
			
 
				+     * function closeFd(fd) {
			
 
				+     *   close(fd, (err) => {
			
 
				+     *     if (err) throw err;
			
 
				+     *   });
			
 
				+     * }
			
 
				+     *
			
 
				+     * open('message.txt', 'a', (err, fd) => {
			
 
				+     *   if (err) throw err;
			
 
				+     *
			
 
				+     *   try {
			
 
				+     *     appendFile(fd, 'data to append', 'utf8', (err) => {
			
 
				+     *       closeFd(fd);
			
 
				+     *       if (err) throw err;
			
 
				+     *     });
			
 
				+     *   } catch (err) {
			
 
				+     *     closeFd(fd);
			
 
				+     *     throw err;
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     * @since v0.6.7
			
 
				+     * @param path filename or file descriptor
			
 
				+     */
			
 
				+    export function appendFile(path: PathOrFileDescriptor, data: string | Uint8Array, options: WriteFileOptions, callback: NoParamCallback): void;
			
 
				+    /**
			
 
				+     * Asynchronously append data to a file, creating the file if it does not exist.
			
 
				+     * @param file A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+     * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string.
			
 
				+     */
			
 
				+    export function appendFile(file: PathOrFileDescriptor, data: string | Uint8Array, callback: NoParamCallback): void;
			
 
				+    export namespace appendFile {
			
 
				+        /**
			
 
				+         * Asynchronously append data to a file, creating the file if it does not exist.
			
 
				+         * @param file A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * URL support is _experimental_.
			
 
				+         * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
			
 
				+         * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string.
			
 
				+         * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
			
 
				+         * If `encoding` is not supplied, the default of `'utf8'` is used.
			
 
				+         * If `mode` is not supplied, the default of `0o666` is used.
			
 
				+         * If `mode` is a string, it is parsed as an octal integer.
			
 
				+         * If `flag` is not supplied, the default of `'a'` is used.
			
 
				+         */
			
 
				+        function __promisify__(file: PathOrFileDescriptor, data: string | Uint8Array, options?: WriteFileOptions): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronously append data to a file, creating the file if it does not yet
			
 
				+     * exist. `data` can be a string or a `Buffer`.
			
 
				+     *
			
 
				+     * The `mode` option only affects the newly created file. See {@link open} for more details.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { appendFileSync } from 'fs';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   appendFileSync('message.txt', 'data to append');
			
 
				+     *   console.log('The "data to append" was appended to file!');
			
 
				+     * } catch (err) {
			
 
				+     *   // Handle the error
			
 
				+     * }
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If `options` is a string, then it specifies the encoding:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { appendFileSync } from 'fs';
			
 
				+     *
			
 
				+     * appendFileSync('message.txt', 'data to append', 'utf8');
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The `path` may be specified as a numeric file descriptor that has been opened
			
 
				+     * for appending (using `fs.open()` or `fs.openSync()`). The file descriptor will
			
 
				+     * not be closed automatically.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { openSync, closeSync, appendFileSync } from 'fs';
			
 
				+     *
			
 
				+     * let fd;
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   fd = openSync('message.txt', 'a');
			
 
				+     *   appendFileSync(fd, 'data to append', 'utf8');
			
 
				+     * } catch (err) {
			
 
				+     *   // Handle the error
			
 
				+     * } finally {
			
 
				+     *   if (fd !== undefined)
			
 
				+     *     closeSync(fd);
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v0.6.7
			
 
				+     * @param path filename or file descriptor
			
 
				+     */
			
 
				+    export function appendFileSync(path: PathOrFileDescriptor, data: string | Uint8Array, options?: WriteFileOptions): void;
			
 
				+    /**
			
 
				+     * Watch for changes on `filename`. The callback `listener` will be called each
			
 
				+     * time the file is accessed.
			
 
				+     *
			
 
				+     * The `options` argument may be omitted. If provided, it should be an object. The`options` object may contain a boolean named `persistent` that indicates
			
 
				+     * whether the process should continue to run as long as files are being watched.
			
 
				+     * The `options` object may specify an `interval` property indicating how often the
			
 
				+     * target should be polled in milliseconds.
			
 
				+     *
			
 
				+     * The `listener` gets two arguments the current stat object and the previous
			
 
				+     * stat object:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { watchFile } from 'fs';
			
 
				+     *
			
 
				+     * watchFile('message.text', (curr, prev) => {
			
 
				+     *   console.log(`the current mtime is: ${curr.mtime}`);
			
 
				+     *   console.log(`the previous mtime was: ${prev.mtime}`);
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * These stat objects are instances of `fs.Stat`. If the `bigint` option is `true`,
			
 
				+     * the numeric values in these objects are specified as `BigInt`s.
			
 
				+     *
			
 
				+     * To be notified when the file was modified, not just accessed, it is necessary
			
 
				+     * to compare `curr.mtimeMs` and `prev.mtimeMs`.
			
 
				+     *
			
 
				+     * When an `fs.watchFile` operation results in an `ENOENT` error, it
			
 
				+     * will invoke the listener once, with all the fields zeroed (or, for dates, the
			
 
				+     * Unix Epoch). If the file is created later on, the listener will be called
			
 
				+     * again, with the latest stat objects. This is a change in functionality since
			
 
				+     * v0.10.
			
 
				+     *
			
 
				+     * Using {@link watch} is more efficient than `fs.watchFile` and`fs.unwatchFile`. `fs.watch` should be used instead of `fs.watchFile` and`fs.unwatchFile` when possible.
			
 
				+     *
			
 
				+     * When a file being watched by `fs.watchFile()` disappears and reappears,
			
 
				+     * then the contents of `previous` in the second callback event (the file's
			
 
				+     * reappearance) will be the same as the contents of `previous` in the first
			
 
				+     * callback event (its disappearance).
			
 
				+     *
			
 
				+     * This happens when:
			
 
				+     *
			
 
				+     * * the file is deleted, followed by a restore
			
 
				+     * * the file is renamed and then renamed a second time back to its original name
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export interface WatchFileOptions {
			
 
				+        bigint?: boolean | undefined;
			
 
				+        persistent?: boolean | undefined;
			
 
				+        interval?: number | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Watch for changes on `filename`. The callback `listener` will be called each
			
 
				+     * time the file is accessed.
			
 
				+     *
			
 
				+     * The `options` argument may be omitted. If provided, it should be an object. The`options` object may contain a boolean named `persistent` that indicates
			
 
				+     * whether the process should continue to run as long as files are being watched.
			
 
				+     * The `options` object may specify an `interval` property indicating how often the
			
 
				+     * target should be polled in milliseconds.
			
 
				+     *
			
 
				+     * The `listener` gets two arguments the current stat object and the previous
			
 
				+     * stat object:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { watchFile } from 'fs';
			
 
				+     *
			
 
				+     * watchFile('message.text', (curr, prev) => {
			
 
				+     *   console.log(`the current mtime is: ${curr.mtime}`);
			
 
				+     *   console.log(`the previous mtime was: ${prev.mtime}`);
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * These stat objects are instances of `fs.Stat`. If the `bigint` option is `true`,
			
 
				+     * the numeric values in these objects are specified as `BigInt`s.
			
 
				+     *
			
 
				+     * To be notified when the file was modified, not just accessed, it is necessary
			
 
				+     * to compare `curr.mtimeMs` and `prev.mtimeMs`.
			
 
				+     *
			
 
				+     * When an `fs.watchFile` operation results in an `ENOENT` error, it
			
 
				+     * will invoke the listener once, with all the fields zeroed (or, for dates, the
			
 
				+     * Unix Epoch). If the file is created later on, the listener will be called
			
 
				+     * again, with the latest stat objects. This is a change in functionality since
			
 
				+     * v0.10.
			
 
				+     *
			
 
				+     * Using {@link watch} is more efficient than `fs.watchFile` and`fs.unwatchFile`. `fs.watch` should be used instead of `fs.watchFile` and`fs.unwatchFile` when possible.
			
 
				+     *
			
 
				+     * When a file being watched by `fs.watchFile()` disappears and reappears,
			
 
				+     * then the contents of `previous` in the second callback event (the file's
			
 
				+     * reappearance) will be the same as the contents of `previous` in the first
			
 
				+     * callback event (its disappearance).
			
 
				+     *
			
 
				+     * This happens when:
			
 
				+     *
			
 
				+     * * the file is deleted, followed by a restore
			
 
				+     * * the file is renamed and then renamed a second time back to its original name
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function watchFile(
			
 
				+        filename: PathLike,
			
 
				+        options:
			
 
				+            | (WatchFileOptions & {
			
 
				+                  bigint?: false | undefined;
			
 
				+              })
			
 
				+            | undefined,
			
 
				+        listener: (curr: Stats, prev: Stats) => void
			
 
				+    ): StatWatcher;
			
 
				+    export function watchFile(
			
 
				+        filename: PathLike,
			
 
				+        options:
			
 
				+            | (WatchFileOptions & {
			
 
				+                  bigint: true;
			
 
				+              })
			
 
				+            | undefined,
			
 
				+        listener: (curr: BigIntStats, prev: BigIntStats) => void
			
 
				+    ): StatWatcher;
			
 
				+    /**
			
 
				+     * Watch for changes on `filename`. The callback `listener` will be called each time the file is accessed.
			
 
				+     * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function watchFile(filename: PathLike, listener: (curr: Stats, prev: Stats) => void): StatWatcher;
			
 
				+    /**
			
 
				+     * Stop watching for changes on `filename`. If `listener` is specified, only that
			
 
				+     * particular listener is removed. Otherwise, _all_ listeners are removed,
			
 
				+     * effectively stopping watching of `filename`.
			
 
				+     *
			
 
				+     * Calling `fs.unwatchFile()` with a filename that is not being watched is a
			
 
				+     * no-op, not an error.
			
 
				+     *
			
 
				+     * Using {@link watch} is more efficient than `fs.watchFile()` and`fs.unwatchFile()`. `fs.watch()` should be used instead of `fs.watchFile()`and `fs.unwatchFile()` when possible.
			
 
				+     * @since v0.1.31
			
 
				+     * @param listener Optional, a listener previously attached using `fs.watchFile()`
			
 
				+     */
			
 
				+    export function unwatchFile(filename: PathLike, listener?: (curr: Stats, prev: Stats) => void): void;
			
 
				+    export interface WatchOptions extends Abortable {
			
 
				+        encoding?: BufferEncoding | 'buffer' | undefined;
			
 
				+        persistent?: boolean | undefined;
			
 
				+        recursive?: boolean | undefined;
			
 
				+    }
			
 
				+    export type WatchEventType = 'rename' | 'change';
			
 
				+    export type WatchListener<T> = (event: WatchEventType, filename: T) => void;
			
 
				+    /**
			
 
				+     * Watch for changes on `filename`, where `filename` is either a file or a
			
 
				+     * directory.
			
 
				+     *
			
 
				+     * The second argument is optional. If `options` is provided as a string, it
			
 
				+     * specifies the `encoding`. Otherwise `options` should be passed as an object.
			
 
				+     *
			
 
				+     * The listener callback gets two arguments `(eventType, filename)`. `eventType`is either `'rename'` or `'change'`, and `filename` is the name of the file
			
 
				+     * which triggered the event.
			
 
				+     *
			
 
				+     * On most platforms, `'rename'` is emitted whenever a filename appears or
			
 
				+     * disappears in the directory.
			
 
				+     *
			
 
				+     * The listener callback is attached to the `'change'` event fired by `fs.FSWatcher`, but it is not the same thing as the `'change'` value of`eventType`.
			
 
				+     *
			
 
				+     * If a `signal` is passed, aborting the corresponding AbortController will close
			
 
				+     * the returned `fs.FSWatcher`.
			
 
				+     * @since v0.5.10
			
 
				+     * @param listener
			
 
				+     */
			
 
				+    export function watch(
			
 
				+        filename: PathLike,
			
 
				+        options:
			
 
				+            | (WatchOptions & {
			
 
				+                  encoding: 'buffer';
			
 
				+              })
			
 
				+            | 'buffer',
			
 
				+        listener?: WatchListener<Buffer>
			
 
				+    ): FSWatcher;
			
 
				+    /**
			
 
				+     * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
			
 
				+     * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the encoding for the filename provided to the listener, or an object optionally specifying encoding, persistent, and recursive options.
			
 
				+     * If `encoding` is not supplied, the default of `'utf8'` is used.
			
 
				+     * If `persistent` is not supplied, the default of `true` is used.
			
 
				+     * If `recursive` is not supplied, the default of `false` is used.
			
 
				+     */
			
 
				+    export function watch(filename: PathLike, options?: WatchOptions | BufferEncoding | null, listener?: WatchListener<string>): FSWatcher;
			
 
				+    /**
			
 
				+     * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
			
 
				+     * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the encoding for the filename provided to the listener, or an object optionally specifying encoding, persistent, and recursive options.
			
 
				+     * If `encoding` is not supplied, the default of `'utf8'` is used.
			
 
				+     * If `persistent` is not supplied, the default of `true` is used.
			
 
				+     * If `recursive` is not supplied, the default of `false` is used.
			
 
				+     */
			
 
				+    export function watch(filename: PathLike, options: WatchOptions | string, listener?: WatchListener<string | Buffer>): FSWatcher;
			
 
				+    /**
			
 
				+     * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
			
 
				+     * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function watch(filename: PathLike, listener?: WatchListener<string>): FSWatcher;
			
 
				+    /**
			
 
				+     * Test whether or not the given path exists by checking with the file system.
			
 
				+     * Then call the `callback` argument with either true or false:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { exists } from 'fs';
			
 
				+     *
			
 
				+     * exists('/etc/passwd', (e) => {
			
 
				+     *   console.log(e ? 'it exists' : 'no passwd!');
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * **The parameters for this callback are not consistent with other Node.js**
			
 
				+     * **callbacks.** Normally, the first parameter to a Node.js callback is an `err`parameter, optionally followed by other parameters. The `fs.exists()` callback
			
 
				+     * has only one boolean parameter. This is one reason `fs.access()` is recommended
			
 
				+     * instead of `fs.exists()`.
			
 
				+     *
			
 
				+     * Using `fs.exists()` to check for the existence of a file before calling`fs.open()`, `fs.readFile()` or `fs.writeFile()` is not recommended. Doing
			
 
				+     * so introduces a race condition, since other processes may change the file's
			
 
				+     * state between the two calls. Instead, user code should open/read/write the
			
 
				+     * file directly and handle the error raised if the file does not exist.
			
 
				+     *
			
 
				+     * **write (NOT RECOMMENDED)**
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { exists, open, close } from 'fs';
			
 
				+     *
			
 
				+     * exists('myfile', (e) => {
			
 
				+     *   if (e) {
			
 
				+     *     console.error('myfile already exists');
			
 
				+     *   } else {
			
 
				+     *     open('myfile', 'wx', (err, fd) => {
			
 
				+     *       if (err) throw err;
			
 
				+     *
			
 
				+     *       try {
			
 
				+     *         writeMyData(fd);
			
 
				+     *       } finally {
			
 
				+     *         close(fd, (err) => {
			
 
				+     *           if (err) throw err;
			
 
				+     *         });
			
 
				+     *       }
			
 
				+     *     });
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * **write (RECOMMENDED)**
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { open, close } from 'fs';
			
 
				+     * open('myfile', 'wx', (err, fd) => {
			
 
				+     *   if (err) {
			
 
				+     *     if (err.code === 'EEXIST') {
			
 
				+     *       console.error('myfile already exists');
			
 
				+     *       return;
			
 
				+     *     }
			
 
				+     *
			
 
				+     *     throw err;
			
 
				+     *   }
			
 
				+     *
			
 
				+     *   try {
			
 
				+     *     writeMyData(fd);
			
 
				+     *   } finally {
			
 
				+     *     close(fd, (err) => {
			
 
				+     *       if (err) throw err;
			
 
				+     *     });
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * **read (NOT RECOMMENDED)**
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { open, close, exists } from 'fs';
			
 
				+     *
			
 
				+     * exists('myfile', (e) => {
			
 
				+     *   if (e) {
			
 
				+     *     open('myfile', 'r', (err, fd) => {
			
 
				+     *       if (err) throw err;
			
 
				+     *
			
 
				+     *       try {
			
 
				+     *         readMyData(fd);
			
 
				+     *       } finally {
			
 
				+     *         close(fd, (err) => {
			
 
				+     *           if (err) throw err;
			
 
				+     *         });
			
 
				+     *       }
			
 
				+     *     });
			
 
				+     *   } else {
			
 
				+     *     console.error('myfile does not exist');
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * **read (RECOMMENDED)**
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { open, close } from 'fs';
			
 
				+     *
			
 
				+     * open('myfile', 'r', (err, fd) => {
			
 
				+     *   if (err) {
			
 
				+     *     if (err.code === 'ENOENT') {
			
 
				+     *       console.error('myfile does not exist');
			
 
				+     *       return;
			
 
				+     *     }
			
 
				+     *
			
 
				+     *     throw err;
			
 
				+     *   }
			
 
				+     *
			
 
				+     *   try {
			
 
				+     *     readMyData(fd);
			
 
				+     *   } finally {
			
 
				+     *     close(fd, (err) => {
			
 
				+     *       if (err) throw err;
			
 
				+     *     });
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The "not recommended" examples above check for existence and then use the
			
 
				+     * file; the "recommended" examples are better because they use the file directly
			
 
				+     * and handle the error, if any.
			
 
				+     *
			
 
				+     * In general, check for the existence of a file only if the file won’t be
			
 
				+     * used directly, for example when its existence is a signal from another
			
 
				+     * process.
			
 
				+     * @since v0.0.2
			
 
				+     * @deprecated Since v1.0.0 - Use {@link stat} or {@link access} instead.
			
 
				+     */
			
 
				+    export function exists(path: PathLike, callback: (exists: boolean) => void): void;
			
 
				+    /** @deprecated */
			
 
				+    export namespace exists {
			
 
				+        /**
			
 
				+         * @param path A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * URL support is _experimental_.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike): Promise<boolean>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Returns `true` if the path exists, `false` otherwise.
			
 
				+     *
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link exists}.
			
 
				+     *
			
 
				+     * `fs.exists()` is deprecated, but `fs.existsSync()` is not. The `callback`parameter to `fs.exists()` accepts parameters that are inconsistent with other
			
 
				+     * Node.js callbacks. `fs.existsSync()` does not use a callback.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { existsSync } from 'fs';
			
 
				+     *
			
 
				+     * if (existsSync('/etc/passwd'))
			
 
				+     *   console.log('The path exists.');
			
 
				+     * ```
			
 
				+     * @since v0.1.21
			
 
				+     */
			
 
				+    export function existsSync(path: PathLike): boolean;
			
 
				+    export namespace constants {
			
 
				+        // File Access Constants
			
 
				+        /** Constant for fs.access(). File is visible to the calling process. */
			
 
				+        const F_OK: number;
			
 
				+        /** Constant for fs.access(). File can be read by the calling process. */
			
 
				+        const R_OK: number;
			
 
				+        /** Constant for fs.access(). File can be written by the calling process. */
			
 
				+        const W_OK: number;
			
 
				+        /** Constant for fs.access(). File can be executed by the calling process. */
			
 
				+        const X_OK: number;
			
 
				+        // File Copy Constants
			
 
				+        /** Constant for fs.copyFile. Flag indicating the destination file should not be overwritten if it already exists. */
			
 
				+        const COPYFILE_EXCL: number;
			
 
				+        /**
			
 
				+         * Constant for fs.copyFile. copy operation will attempt to create a copy-on-write reflink.
			
 
				+         * If the underlying platform does not support copy-on-write, then a fallback copy mechanism is used.
			
 
				+         */
			
 
				+        const COPYFILE_FICLONE: number;
			
 
				+        /**
			
 
				+         * Constant for fs.copyFile. Copy operation will attempt to create a copy-on-write reflink.
			
 
				+         * If the underlying platform does not support copy-on-write, then the operation will fail with an error.
			
 
				+         */
			
 
				+        const COPYFILE_FICLONE_FORCE: number;
			
 
				+        // File Open Constants
			
 
				+        /** Constant for fs.open(). Flag indicating to open a file for read-only access. */
			
 
				+        const O_RDONLY: number;
			
 
				+        /** Constant for fs.open(). Flag indicating to open a file for write-only access. */
			
 
				+        const O_WRONLY: number;
			
 
				+        /** Constant for fs.open(). Flag indicating to open a file for read-write access. */
			
 
				+        const O_RDWR: number;
			
 
				+        /** Constant for fs.open(). Flag indicating to create the file if it does not already exist. */
			
 
				+        const O_CREAT: number;
			
 
				+        /** Constant for fs.open(). Flag indicating that opening a file should fail if the O_CREAT flag is set and the file already exists. */
			
 
				+        const O_EXCL: number;
			
 
				+        /**
			
 
				+         * Constant for fs.open(). Flag indicating that if path identifies a terminal device,
			
 
				+         * opening the path shall not cause that terminal to become the controlling terminal for the process
			
 
				+         * (if the process does not already have one).
			
 
				+         */
			
 
				+        const O_NOCTTY: number;
			
 
				+        /** Constant for fs.open(). Flag indicating that if the file exists and is a regular file, and the file is opened successfully for write access, its length shall be truncated to zero. */
			
 
				+        const O_TRUNC: number;
			
 
				+        /** Constant for fs.open(). Flag indicating that data will be appended to the end of the file. */
			
 
				+        const O_APPEND: number;
			
 
				+        /** Constant for fs.open(). Flag indicating that the open should fail if the path is not a directory. */
			
 
				+        const O_DIRECTORY: number;
			
 
				+        /**
			
 
				+         * constant for fs.open().
			
 
				+         * Flag indicating reading accesses to the file system will no longer result in
			
 
				+         * an update to the atime information associated with the file.
			
 
				+         * This flag is available on Linux operating systems only.
			
 
				+         */
			
 
				+        const O_NOATIME: number;
			
 
				+        /** Constant for fs.open(). Flag indicating that the open should fail if the path is a symbolic link. */
			
 
				+        const O_NOFOLLOW: number;
			
 
				+        /** Constant for fs.open(). Flag indicating that the file is opened for synchronous I/O. */
			
 
				+        const O_SYNC: number;
			
 
				+        /** Constant for fs.open(). Flag indicating that the file is opened for synchronous I/O with write operations waiting for data integrity. */
			
 
				+        const O_DSYNC: number;
			
 
				+        /** Constant for fs.open(). Flag indicating to open the symbolic link itself rather than the resource it is pointing to. */
			
 
				+        const O_SYMLINK: number;
			
 
				+        /** Constant for fs.open(). When set, an attempt will be made to minimize caching effects of file I/O. */
			
 
				+        const O_DIRECT: number;
			
 
				+        /** Constant for fs.open(). Flag indicating to open the file in nonblocking mode when possible. */
			
 
				+        const O_NONBLOCK: number;
			
 
				+        // File Type Constants
			
 
				+        /** Constant for fs.Stats mode property for determining a file's type. Bit mask used to extract the file type code. */
			
 
				+        const S_IFMT: number;
			
 
				+        /** Constant for fs.Stats mode property for determining a file's type. File type constant for a regular file. */
			
 
				+        const S_IFREG: number;
			
 
				+        /** Constant for fs.Stats mode property for determining a file's type. File type constant for a directory. */
			
 
				+        const S_IFDIR: number;
			
 
				+        /** Constant for fs.Stats mode property for determining a file's type. File type constant for a character-oriented device file. */
			
 
				+        const S_IFCHR: number;
			
 
				+        /** Constant for fs.Stats mode property for determining a file's type. File type constant for a block-oriented device file. */
			
 
				+        const S_IFBLK: number;
			
 
				+        /** Constant for fs.Stats mode property for determining a file's type. File type constant for a FIFO/pipe. */
			
 
				+        const S_IFIFO: number;
			
 
				+        /** Constant for fs.Stats mode property for determining a file's type. File type constant for a symbolic link. */
			
 
				+        const S_IFLNK: number;
			
 
				+        /** Constant for fs.Stats mode property for determining a file's type. File type constant for a socket. */
			
 
				+        const S_IFSOCK: number;
			
 
				+        // File Mode Constants
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable, writable and executable by owner. */
			
 
				+        const S_IRWXU: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable by owner. */
			
 
				+        const S_IRUSR: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating writable by owner. */
			
 
				+        const S_IWUSR: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by owner. */
			
 
				+        const S_IXUSR: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable, writable and executable by group. */
			
 
				+        const S_IRWXG: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable by group. */
			
 
				+        const S_IRGRP: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating writable by group. */
			
 
				+        const S_IWGRP: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by group. */
			
 
				+        const S_IXGRP: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable, writable and executable by others. */
			
 
				+        const S_IRWXO: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable by others. */
			
 
				+        const S_IROTH: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating writable by others. */
			
 
				+        const S_IWOTH: number;
			
 
				+        /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by others. */
			
 
				+        const S_IXOTH: number;
			
 
				+        /**
			
 
				+         * When set, a memory file mapping is used to access the file. This flag
			
 
				+         * is available on Windows operating systems only. On other operating systems,
			
 
				+         * this flag is ignored.
			
 
				+         */
			
 
				+        const UV_FS_O_FILEMAP: number;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Tests a user's permissions for the file or directory specified by `path`.
			
 
				+     * The `mode` argument is an optional integer that specifies the accessibility
			
 
				+     * checks to be performed. `mode` should be either the value `fs.constants.F_OK`or a mask consisting of the bitwise OR of any of `fs.constants.R_OK`,`fs.constants.W_OK`, and `fs.constants.X_OK`
			
 
				+     * (e.g.`fs.constants.W_OK | fs.constants.R_OK`). Check `File access constants` for
			
 
				+     * possible values of `mode`.
			
 
				+     *
			
 
				+     * The final argument, `callback`, is a callback function that is invoked with
			
 
				+     * a possible error argument. If any of the accessibility checks fail, the error
			
 
				+     * argument will be an `Error` object. The following examples check if`package.json` exists, and if it is readable or writable.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { access, constants } from 'fs';
			
 
				+     *
			
 
				+     * const file = 'package.json';
			
 
				+     *
			
 
				+     * // Check if the file exists in the current directory.
			
 
				+     * access(file, constants.F_OK, (err) => {
			
 
				+     *   console.log(`${file} ${err ? 'does not exist' : 'exists'}`);
			
 
				+     * });
			
 
				+     *
			
 
				+     * // Check if the file is readable.
			
 
				+     * access(file, constants.R_OK, (err) => {
			
 
				+     *   console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);
			
 
				+     * });
			
 
				+     *
			
 
				+     * // Check if the file is writable.
			
 
				+     * access(file, constants.W_OK, (err) => {
			
 
				+     *   console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);
			
 
				+     * });
			
 
				+     *
			
 
				+     * // Check if the file is readable and writable.
			
 
				+     * access(file, constants.R_OK | constants.W_OK, (err) => {
			
 
				+     *   console.log(`${file} ${err ? 'is not' : 'is'} readable and writable`);
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Do not use `fs.access()` to check for the accessibility of a file before calling`fs.open()`, `fs.readFile()` or `fs.writeFile()`. Doing
			
 
				+     * so introduces a race condition, since other processes may change the file's
			
 
				+     * state between the two calls. Instead, user code should open/read/write the
			
 
				+     * file directly and handle the error raised if the file is not accessible.
			
 
				+     *
			
 
				+     * **write (NOT RECOMMENDED)**
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { access, open, close } from 'fs';
			
 
				+     *
			
 
				+     * access('myfile', (err) => {
			
 
				+     *   if (!err) {
			
 
				+     *     console.error('myfile already exists');
			
 
				+     *     return;
			
 
				+     *   }
			
 
				+     *
			
 
				+     *   open('myfile', 'wx', (err, fd) => {
			
 
				+     *     if (err) throw err;
			
 
				+     *
			
 
				+     *     try {
			
 
				+     *       writeMyData(fd);
			
 
				+     *     } finally {
			
 
				+     *       close(fd, (err) => {
			
 
				+     *         if (err) throw err;
			
 
				+     *       });
			
 
				+     *     }
			
 
				+     *   });
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * **write (RECOMMENDED)**
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { open, close } from 'fs';
			
 
				+     *
			
 
				+     * open('myfile', 'wx', (err, fd) => {
			
 
				+     *   if (err) {
			
 
				+     *     if (err.code === 'EEXIST') {
			
 
				+     *       console.error('myfile already exists');
			
 
				+     *       return;
			
 
				+     *     }
			
 
				+     *
			
 
				+     *     throw err;
			
 
				+     *   }
			
 
				+     *
			
 
				+     *   try {
			
 
				+     *     writeMyData(fd);
			
 
				+     *   } finally {
			
 
				+     *     close(fd, (err) => {
			
 
				+     *       if (err) throw err;
			
 
				+     *     });
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * **read (NOT RECOMMENDED)**
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { access, open, close } from 'fs';
			
 
				+     * access('myfile', (err) => {
			
 
				+     *   if (err) {
			
 
				+     *     if (err.code === 'ENOENT') {
			
 
				+     *       console.error('myfile does not exist');
			
 
				+     *       return;
			
 
				+     *     }
			
 
				+     *
			
 
				+     *     throw err;
			
 
				+     *   }
			
 
				+     *
			
 
				+     *   open('myfile', 'r', (err, fd) => {
			
 
				+     *     if (err) throw err;
			
 
				+     *
			
 
				+     *     try {
			
 
				+     *       readMyData(fd);
			
 
				+     *     } finally {
			
 
				+     *       close(fd, (err) => {
			
 
				+     *         if (err) throw err;
			
 
				+     *       });
			
 
				+     *     }
			
 
				+     *   });
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * **read (RECOMMENDED)**
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { open, close } from 'fs';
			
 
				+     *
			
 
				+     * open('myfile', 'r', (err, fd) => {
			
 
				+     *   if (err) {
			
 
				+     *     if (err.code === 'ENOENT') {
			
 
				+     *       console.error('myfile does not exist');
			
 
				+     *       return;
			
 
				+     *     }
			
 
				+     *
			
 
				+     *     throw err;
			
 
				+     *   }
			
 
				+     *
			
 
				+     *   try {
			
 
				+     *     readMyData(fd);
			
 
				+     *   } finally {
			
 
				+     *     close(fd, (err) => {
			
 
				+     *       if (err) throw err;
			
 
				+     *     });
			
 
				+     *   }
			
 
				+     * });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The "not recommended" examples above check for accessibility and then use the
			
 
				+     * file; the "recommended" examples are better because they use the file directly
			
 
				+     * and handle the error, if any.
			
 
				+     *
			
 
				+     * In general, check for the accessibility of a file only if the file will not be
			
 
				+     * used directly, for example when its accessibility is a signal from another
			
 
				+     * process.
			
 
				+     *
			
 
				+     * On Windows, access-control policies (ACLs) on a directory may limit access to
			
 
				+     * a file or directory. The `fs.access()` function, however, does not check the
			
 
				+     * ACL and therefore may report that a path is accessible even if the ACL restricts
			
 
				+     * the user from reading or writing to it.
			
 
				+     * @since v0.11.15
			
 
				+     * @param [mode=fs.constants.F_OK]
			
 
				+     */
			
 
				+    export function access(path: PathLike, mode: number | undefined, callback: NoParamCallback): void;
			
 
				+    /**
			
 
				+     * Asynchronously tests a user's permissions for the file specified by path.
			
 
				+     * @param path A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
			
 
				+     */
			
 
				+    export function access(path: PathLike, callback: NoParamCallback): void;
			
 
				+    export namespace access {
			
 
				+        /**
			
 
				+         * Asynchronously tests a user's permissions for the file specified by path.
			
 
				+         * @param path A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
			
 
				+         * URL support is _experimental_.
			
 
				+         */
			
 
				+        function __promisify__(path: PathLike, mode?: number): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronously tests a user's permissions for the file or directory specified
			
 
				+     * by `path`. The `mode` argument is an optional integer that specifies the
			
 
				+     * accessibility checks to be performed. `mode` should be either the value`fs.constants.F_OK` or a mask consisting of the bitwise OR of any of`fs.constants.R_OK`, `fs.constants.W_OK`, and
			
 
				+     * `fs.constants.X_OK` (e.g.`fs.constants.W_OK | fs.constants.R_OK`). Check `File access constants` for
			
 
				+     * possible values of `mode`.
			
 
				+     *
			
 
				+     * If any of the accessibility checks fail, an `Error` will be thrown. Otherwise,
			
 
				+     * the method will return `undefined`.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { accessSync, constants } from 'fs';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   accessSync('etc/passwd', constants.R_OK | constants.W_OK);
			
 
				+     *   console.log('can read/write');
			
 
				+     * } catch (err) {
			
 
				+     *   console.error('no access!');
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v0.11.15
			
 
				+     * @param [mode=fs.constants.F_OK]
			
 
				+     */
			
 
				+    export function accessSync(path: PathLike, mode?: number): void;
			
 
				+    interface StreamOptions {
			
 
				+        flags?: string | undefined;
			
 
				+        encoding?: BufferEncoding | undefined;
			
 
				+        fd?: number | promises.FileHandle | undefined;
			
 
				+        mode?: number | undefined;
			
 
				+        autoClose?: boolean | undefined;
			
 
				+        /**
			
 
				+         * @default false
			
 
				+         */
			
 
				+        emitClose?: boolean | undefined;
			
 
				+        start?: number | undefined;
			
 
				+        highWaterMark?: number | undefined;
			
 
				+    }
			
 
				+    interface ReadStreamOptions extends StreamOptions {
			
 
				+        end?: number | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Unlike the 16 kb default `highWaterMark` for a `stream.Readable`, the stream
			
 
				+     * returned by this method has a default `highWaterMark` of 64 kb.
			
 
				+     *
			
 
				+     * `options` can include `start` and `end` values to read a range of bytes from
			
 
				+     * the file instead of the entire file. Both `start` and `end` are inclusive and
			
 
				+     * start counting at 0, allowed values are in the
			
 
				+     * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. If `fd` is specified and `start` is
			
 
				+     * omitted or `undefined`, `fs.createReadStream()` reads sequentially from the
			
 
				+     * current file position. The `encoding` can be any one of those accepted by `Buffer`.
			
 
				+     *
			
 
				+     * If `fd` is specified, `ReadStream` will ignore the `path` argument and will use
			
 
				+     * the specified file descriptor. This means that no `'open'` event will be
			
 
				+     * emitted. `fd` should be blocking; non-blocking `fd`s should be passed to `net.Socket`.
			
 
				+     *
			
 
				+     * If `fd` points to a character device that only supports blocking reads
			
 
				+     * (such as keyboard or sound card), read operations do not finish until data is
			
 
				+     * available. This can prevent the process from exiting and the stream from
			
 
				+     * closing naturally.
			
 
				+     *
			
 
				+     * By default, the stream will emit a `'close'` event after it has been
			
 
				+     * destroyed.  Set the `emitClose` option to `false` to change this behavior.
			
 
				+     *
			
 
				+     * By providing the `fs` option, it is possible to override the corresponding `fs`implementations for `open`, `read`, and `close`. When providing the `fs` option,
			
 
				+     * an override for `read` is required. If no `fd` is provided, an override for`open` is also required. If `autoClose` is `true`, an override for `close` is
			
 
				+     * also required.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { createReadStream } from 'fs';
			
 
				+     *
			
 
				+     * // Create a stream from some character device.
			
 
				+     * const stream = createReadStream('/dev/input/event0');
			
 
				+     * setTimeout(() => {
			
 
				+     *   stream.close(); // This may not close the stream.
			
 
				+     *   // Artificially marking end-of-stream, as if the underlying resource had
			
 
				+     *   // indicated end-of-file by itself, allows the stream to close.
			
 
				+     *   // This does not cancel pending read operations, and if there is such an
			
 
				+     *   // operation, the process may still not be able to exit successfully
			
 
				+     *   // until it finishes.
			
 
				+     *   stream.push(null);
			
 
				+     *   stream.read(0);
			
 
				+     * }, 100);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If `autoClose` is false, then the file descriptor won't be closed, even if
			
 
				+     * there's an error. It is the application's responsibility to close it and make
			
 
				+     * sure there's no file descriptor leak. If `autoClose` is set to true (default
			
 
				+     * behavior), on `'error'` or `'end'` the file descriptor will be closed
			
 
				+     * automatically.
			
 
				+     *
			
 
				+     * `mode` sets the file mode (permission and sticky bits), but only if the
			
 
				+     * file was created.
			
 
				+     *
			
 
				+     * An example to read the last 10 bytes of a file which is 100 bytes long:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { createReadStream } from 'fs';
			
 
				+     *
			
 
				+     * createReadStream('sample.txt', { start: 90, end: 99 });
			
 
				+     * ```
			
 
				+     *
			
 
				+     * If `options` is a string, then it specifies the encoding.
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function createReadStream(path: PathLike, options?: BufferEncoding | ReadStreamOptions): ReadStream;
			
 
				+    /**
			
 
				+     * `options` may also include a `start` option to allow writing data at some
			
 
				+     * position past the beginning of the file, allowed values are in the
			
 
				+     * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. Modifying a file rather than
			
 
				+     * replacing it may require the `flags` option to be set to `r+` rather than the
			
 
				+     * default `w`. The `encoding` can be any one of those accepted by `Buffer`.
			
 
				+     *
			
 
				+     * If `autoClose` is set to true (default behavior) on `'error'` or `'finish'`the file descriptor will be closed automatically. If `autoClose` is false,
			
 
				+     * then the file descriptor won't be closed, even if there's an error.
			
 
				+     * It is the application's responsibility to close it and make sure there's no
			
 
				+     * file descriptor leak.
			
 
				+     *
			
 
				+     * By default, the stream will emit a `'close'` event after it has been
			
 
				+     * destroyed.  Set the `emitClose` option to `false` to change this behavior.
			
 
				+     *
			
 
				+     * By providing the `fs` option it is possible to override the corresponding `fs`implementations for `open`, `write`, `writev` and `close`. Overriding `write()`without `writev()` can reduce
			
 
				+     * performance as some optimizations (`_writev()`)
			
 
				+     * will be disabled. When providing the `fs` option, overrides for at least one of`write` and `writev` are required. If no `fd` option is supplied, an override
			
 
				+     * for `open` is also required. If `autoClose` is `true`, an override for `close`is also required.
			
 
				+     *
			
 
				+     * Like `fs.ReadStream`, if `fd` is specified, `fs.WriteStream` will ignore the`path` argument and will use the specified file descriptor. This means that no`'open'` event will be
			
 
				+     * emitted. `fd` should be blocking; non-blocking `fd`s
			
 
				+     * should be passed to `net.Socket`.
			
 
				+     *
			
 
				+     * If `options` is a string, then it specifies the encoding.
			
 
				+     * @since v0.1.31
			
 
				+     */
			
 
				+    export function createWriteStream(path: PathLike, options?: BufferEncoding | StreamOptions): WriteStream;
			
 
				+    /**
			
 
				+     * Forces all currently queued I/O operations associated with the file to the
			
 
				+     * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details. No arguments other
			
 
				+     * than a possible
			
 
				+     * exception are given to the completion callback.
			
 
				+     * @since v0.1.96
			
 
				+     */
			
 
				+    export function fdatasync(fd: number, callback: NoParamCallback): void;
			
 
				+    export namespace fdatasync {
			
 
				+        /**
			
 
				+         * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
			
 
				+         * @param fd A file descriptor.
			
 
				+         */
			
 
				+        function __promisify__(fd: number): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Forces all currently queued I/O operations associated with the file to the
			
 
				+     * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details. Returns `undefined`.
			
 
				+     * @since v0.1.96
			
 
				+     */
			
 
				+    export function fdatasyncSync(fd: number): void;
			
 
				+    /**
			
 
				+     * Asynchronously copies `src` to `dest`. By default, `dest` is overwritten if it
			
 
				+     * already exists. No arguments other than a possible exception are given to the
			
 
				+     * callback function. Node.js makes no guarantees about the atomicity of the copy
			
 
				+     * operation. If an error occurs after the destination file has been opened for
			
 
				+     * writing, Node.js will attempt to remove the destination.
			
 
				+     *
			
 
				+     * `mode` is an optional integer that specifies the behavior
			
 
				+     * of the copy operation. It is possible to create a mask consisting of the bitwise
			
 
				+     * OR of two or more values (e.g.`fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`).
			
 
				+     *
			
 
				+     * * `fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already
			
 
				+     * exists.
			
 
				+     * * `fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a
			
 
				+     * copy-on-write reflink. If the platform does not support copy-on-write, then a
			
 
				+     * fallback copy mechanism is used.
			
 
				+     * * `fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to
			
 
				+     * create a copy-on-write reflink. If the platform does not support
			
 
				+     * copy-on-write, then the operation will fail.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { copyFile, constants } from 'fs';
			
 
				+     *
			
 
				+     * function callback(err) {
			
 
				+     *   if (err) throw err;
			
 
				+     *   console.log('source.txt was copied to destination.txt');
			
 
				+     * }
			
 
				+     *
			
 
				+     * // destination.txt will be created or overwritten by default.
			
 
				+     * copyFile('source.txt', 'destination.txt', callback);
			
 
				+     *
			
 
				+     * // By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
			
 
				+     * copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL, callback);
			
 
				+     * ```
			
 
				+     * @since v8.5.0
			
 
				+     * @param src source filename to copy
			
 
				+     * @param dest destination filename of the copy operation
			
 
				+     * @param [mode=0] modifiers for copy operation.
			
 
				+     */
			
 
				+    export function copyFile(src: PathLike, dest: PathLike, callback: NoParamCallback): void;
			
 
				+    export function copyFile(src: PathLike, dest: PathLike, mode: number, callback: NoParamCallback): void;
			
 
				+    export namespace copyFile {
			
 
				+        function __promisify__(src: PathLike, dst: PathLike, mode?: number): Promise<void>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronously copies `src` to `dest`. By default, `dest` is overwritten if it
			
 
				+     * already exists. Returns `undefined`. Node.js makes no guarantees about the
			
 
				+     * atomicity of the copy operation. If an error occurs after the destination file
			
 
				+     * has been opened for writing, Node.js will attempt to remove the destination.
			
 
				+     *
			
 
				+     * `mode` is an optional integer that specifies the behavior
			
 
				+     * of the copy operation. It is possible to create a mask consisting of the bitwise
			
 
				+     * OR of two or more values (e.g.`fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`).
			
 
				+     *
			
 
				+     * * `fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already
			
 
				+     * exists.
			
 
				+     * * `fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a
			
 
				+     * copy-on-write reflink. If the platform does not support copy-on-write, then a
			
 
				+     * fallback copy mechanism is used.
			
 
				+     * * `fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to
			
 
				+     * create a copy-on-write reflink. If the platform does not support
			
 
				+     * copy-on-write, then the operation will fail.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { copyFileSync, constants } from 'fs';
			
 
				+     *
			
 
				+     * // destination.txt will be created or overwritten by default.
			
 
				+     * copyFileSync('source.txt', 'destination.txt');
			
 
				+     * console.log('source.txt was copied to destination.txt');
			
 
				+     *
			
 
				+     * // By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
			
 
				+     * copyFileSync('source.txt', 'destination.txt', constants.COPYFILE_EXCL);
			
 
				+     * ```
			
 
				+     * @since v8.5.0
			
 
				+     * @param src source filename to copy
			
 
				+     * @param dest destination filename of the copy operation
			
 
				+     * @param [mode=0] modifiers for copy operation.
			
 
				+     */
			
 
				+    export function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void;
			
 
				+    /**
			
 
				+     * Write an array of `ArrayBufferView`s to the file specified by `fd` using`writev()`.
			
 
				+     *
			
 
				+     * `position` is the offset from the beginning of the file where this data
			
 
				+     * should be written. If `typeof position !== 'number'`, the data will be written
			
 
				+     * at the current position.
			
 
				+     *
			
 
				+     * The callback will be given three arguments: `err`, `bytesWritten`, and`buffers`. `bytesWritten` is how many bytes were written from `buffers`.
			
 
				+     *
			
 
				+     * If this method is `util.promisify()` ed, it returns a promise for an`Object` with `bytesWritten` and `buffers` properties.
			
 
				+     *
			
 
				+     * It is unsafe to use `fs.writev()` multiple times on the same file without
			
 
				+     * waiting for the callback. For this scenario, use {@link createWriteStream}.
			
 
				+     *
			
 
				+     * On Linux, positional writes don't work when the file is opened in append mode.
			
 
				+     * The kernel ignores the position argument and always appends the data to
			
 
				+     * the end of the file.
			
 
				+     * @since v12.9.0
			
 
				+     */
			
 
				+    export function writev(fd: number, buffers: ReadonlyArray<NodeJS.ArrayBufferView>, cb: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: NodeJS.ArrayBufferView[]) => void): void;
			
 
				+    export function writev(
			
 
				+        fd: number,
			
 
				+        buffers: ReadonlyArray<NodeJS.ArrayBufferView>,
			
 
				+        position: number,
			
 
				+        cb: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: NodeJS.ArrayBufferView[]) => void
			
 
				+    ): void;
			
 
				+    export interface WriteVResult {
			
 
				+        bytesWritten: number;
			
 
				+        buffers: NodeJS.ArrayBufferView[];
			
 
				+    }
			
 
				+    export namespace writev {
			
 
				+        function __promisify__(fd: number, buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): Promise<WriteVResult>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link writev}.
			
 
				+     * @since v12.9.0
			
 
				+     * @return The number of bytes written.
			
 
				+     */
			
 
				+    export function writevSync(fd: number, buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): number;
			
 
				+    /**
			
 
				+     * Read from a file specified by `fd` and write to an array of `ArrayBufferView`s
			
 
				+     * using `readv()`.
			
 
				+     *
			
 
				+     * `position` is the offset from the beginning of the file from where data
			
 
				+     * should be read. If `typeof position !== 'number'`, the data will be read
			
 
				+     * from the current position.
			
 
				+     *
			
 
				+     * The callback will be given three arguments: `err`, `bytesRead`, and`buffers`. `bytesRead` is how many bytes were read from the file.
			
 
				+     *
			
 
				+     * If this method is invoked as its `util.promisify()` ed version, it returns
			
 
				+     * a promise for an `Object` with `bytesRead` and `buffers` properties.
			
 
				+     * @since v13.13.0, v12.17.0
			
 
				+     */
			
 
				+    export function readv(fd: number, buffers: ReadonlyArray<NodeJS.ArrayBufferView>, cb: (err: NodeJS.ErrnoException | null, bytesRead: number, buffers: NodeJS.ArrayBufferView[]) => void): void;
			
 
				+    export function readv(
			
 
				+        fd: number,
			
 
				+        buffers: ReadonlyArray<NodeJS.ArrayBufferView>,
			
 
				+        position: number,
			
 
				+        cb: (err: NodeJS.ErrnoException | null, bytesRead: number, buffers: NodeJS.ArrayBufferView[]) => void
			
 
				+    ): void;
			
 
				+    export interface ReadVResult {
			
 
				+        bytesRead: number;
			
 
				+        buffers: NodeJS.ArrayBufferView[];
			
 
				+    }
			
 
				+    export namespace readv {
			
 
				+        function __promisify__(fd: number, buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): Promise<ReadVResult>;
			
 
				+    }
			
 
				+    /**
			
 
				+     * For detailed information, see the documentation of the asynchronous version of
			
 
				+     * this API: {@link readv}.
			
 
				+     * @since v13.13.0, v12.17.0
			
 
				+     * @return The number of bytes read.
			
 
				+     */
			
 
				+    export function readvSync(fd: number, buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): number;
			
 
				+    export interface OpenDirOptions {
			
 
				+        encoding?: BufferEncoding | undefined;
			
 
				+        /**
			
 
				+         * Number of directory entries that are buffered
			
 
				+         * internally when reading from the directory. Higher values lead to better
			
 
				+         * performance but higher memory usage.
			
 
				+         * @default 32
			
 
				+         */
			
 
				+        bufferSize?: number | undefined;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Synchronously open a directory. See [`opendir(3)`](http://man7.org/linux/man-pages/man3/opendir.3.html).
			
 
				+     *
			
 
				+     * Creates an `fs.Dir`, which contains all further functions for reading from
			
 
				+     * and cleaning up the directory.
			
 
				+     *
			
 
				+     * The `encoding` option sets the encoding for the `path` while opening the
			
 
				+     * directory and subsequent read operations.
			
 
				+     * @since v12.12.0
			
 
				+     */
			
 
				+    export function opendirSync(path: PathLike, options?: OpenDirOptions): Dir;
			
 
				+    /**
			
 
				+     * Asynchronously open a directory. See the POSIX [`opendir(3)`](http://man7.org/linux/man-pages/man3/opendir.3.html) documentation for
			
 
				+     * more details.
			
 
				+     *
			
 
				+     * Creates an `fs.Dir`, which contains all further functions for reading from
			
 
				+     * and cleaning up the directory.
			
 
				+     *
			
 
				+     * The `encoding` option sets the encoding for the `path` while opening the
			
 
				+     * directory and subsequent read operations.
			
 
				+     * @since v12.12.0
			
 
				+     */
			
 
				+    export function opendir(path: PathLike, cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
			
 
				+    export function opendir(path: PathLike, options: OpenDirOptions, cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
			
 
				+    export namespace opendir {
			
 
				+        function __promisify__(path: PathLike, options?: OpenDirOptions): Promise<Dir>;
			
 
				+    }
			
 
				+    export interface BigIntStats extends StatsBase<bigint> {
			
 
				+        atimeNs: bigint;
			
 
				+        mtimeNs: bigint;
			
 
				+        ctimeNs: bigint;
			
 
				+        birthtimeNs: bigint;
			
 
				+    }
			
 
				+    export interface BigIntOptions {
			
 
				+        bigint: true;
			
 
				+    }
			
 
				+    export interface StatOptions {
			
 
				+        bigint?: boolean | undefined;
			
 
				+    }
			
 
				+    export interface StatSyncOptions extends StatOptions {
			
 
				+        throwIfNoEntry?: boolean | undefined;
			
 
				+    }
			
 
				+    interface CopyOptionsBase {
			
 
				+        /**
			
 
				+         * Dereference symlinks
			
 
				+         * @default false
			
 
				+         */
			
 
				+        dereference?: boolean;
			
 
				+        /**
			
 
				+         * When `force` is `false`, and the destination
			
 
				+         * exists, throw an error.
			
 
				+         * @default false
			
 
				+         */
			
 
				+        errorOnExist?: boolean;
			
 
				+        /**
			
 
				+         * Overwrite existing file or directory. _The copy
			
 
				+         * operation will ignore errors if you set this to false and the destination
			
 
				+         * exists. Use the `errorOnExist` option to change this behavior.
			
 
				+         * @default true
			
 
				+         */
			
 
				+        force?: boolean;
			
 
				+        /**
			
 
				+         * When `true` timestamps from `src` will
			
 
				+         * be preserved.
			
 
				+         * @default false
			
 
				+         */
			
 
				+        preserveTimestamps?: boolean;
			
 
				+        /**
			
 
				+         * Copy directories recursively.
			
 
				+         * @default false
			
 
				+         */
			
 
				+        recursive?: boolean;
			
 
				+        /**
			
 
				+         * When true, path resolution for symlinks will be skipped
			
 
				+         * @default false
			
 
				+         */
			
 
				+        verbatimSymlinks?: boolean;
			
 
				+    }
			
 
				+    export interface CopyOptions extends CopyOptionsBase {
			
 
				+        /**
			
 
				+         * Function to filter copied files/directories. Return
			
 
				+         * `true` to copy the item, `false` to ignore it.
			
 
				+         */
			
 
				+        filter?(source: string, destination: string): boolean | Promise<boolean>;
			
 
				+    }
			
 
				+    export interface CopySyncOptions extends CopyOptionsBase {
			
 
				+        /**
			
 
				+         * Function to filter copied files/directories. Return
			
 
				+         * `true` to copy the item, `false` to ignore it.
			
 
				+         */
			
 
				+        filter?(source: string, destination: string): boolean;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Asynchronously copies the entire directory structure from `src` to `dest`,
			
 
				+     * including subdirectories and files.
			
 
				+     *
			
 
				+     * When copying a directory to another directory, globs are not supported and
			
 
				+     * behavior is similar to `cp dir1/ dir2/`.
			
 
				+     * @since v16.7.0
			
 
				+     * @experimental
			
 
				+     * @param src source path to copy.
			
 
				+     * @param dest destination path to copy to.
			
 
				+     */
			
 
				+    export function cp(source: string | URL, destination: string | URL, callback: (err: NodeJS.ErrnoException | null) => void): void;
			
 
				+    export function cp(source: string | URL, destination: string | URL, opts: CopyOptions, callback: (err: NodeJS.ErrnoException | null) => void): void;
			
 
				+    /**
			
 
				+     * Synchronously copies the entire directory structure from `src` to `dest`,
			
 
				+     * including subdirectories and files.
			
 
				+     *
			
 
				+     * When copying a directory to another directory, globs are not supported and
			
 
				+     * behavior is similar to `cp dir1/ dir2/`.
			
 
				+     * @since v16.7.0
			
 
				+     * @experimental
			
 
				+     * @param src source path to copy.
			
 
				+     * @param dest destination path to copy to.
			
 
				+     */
			
 
				+    export function cpSync(source: string | URL, destination: string | URL, opts?: CopySyncOptions): void;
			
 
				+}
			
 
				+declare module 'node:fs' {
			
 
				+    export * from 'fs';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/fs/promises.d.ts
+++ b/Asistent/node_modules/@types/node/fs/promises.d.ts
@@ -0,0 +1,1159 @@
 
				+/**
			
 
				+ * The `fs/promises` API provides asynchronous file system methods that return
			
 
				+ * promises.
			
 
				+ *
			
 
				+ * The promise APIs use the underlying Node.js threadpool to perform file
			
 
				+ * system operations off the event loop thread. These operations are not
			
 
				+ * synchronized or threadsafe. Care must be taken when performing multiple
			
 
				+ * concurrent modifications on the same file or data corruption may occur.
			
 
				+ * @since v10.0.0
			
 
				+ */
			
 
				+declare module 'fs/promises' {
			
 
				+    import { Abortable } from 'node:events';
			
 
				+    import { Stream } from 'node:stream';
			
 
				+    import { ReadableStream } from 'node:stream/web';
			
 
				+    import {
			
 
				+        BigIntStats,
			
 
				+        BigIntStatsFs,
			
 
				+        BufferEncodingOption,
			
 
				+        constants as fsConstants,
			
 
				+        CopyOptions,
			
 
				+        Dir,
			
 
				+        Dirent,
			
 
				+        MakeDirectoryOptions,
			
 
				+        Mode,
			
 
				+        ObjectEncodingOptions,
			
 
				+        OpenDirOptions,
			
 
				+        OpenMode,
			
 
				+        PathLike,
			
 
				+        ReadStream,
			
 
				+        ReadVResult,
			
 
				+        RmDirOptions,
			
 
				+        RmOptions,
			
 
				+        StatOptions,
			
 
				+        StatFsOptions,
			
 
				+        Stats,
			
 
				+        StatsFs,
			
 
				+        TimeLike,
			
 
				+        WatchEventType,
			
 
				+        WatchOptions,
			
 
				+        WriteStream,
			
 
				+        WriteVResult,
			
 
				+    } from 'node:fs';
			
 
				+    import { Interface as ReadlineInterface } from 'node:readline';
			
 
				+
			
 
				+    interface FileChangeInfo<T extends string | Buffer> {
			
 
				+        eventType: WatchEventType;
			
 
				+        filename: T;
			
 
				+    }
			
 
				+    interface FlagAndOpenMode {
			
 
				+        mode?: Mode | undefined;
			
 
				+        flag?: OpenMode | undefined;
			
 
				+    }
			
 
				+    interface FileReadResult<T extends NodeJS.ArrayBufferView> {
			
 
				+        bytesRead: number;
			
 
				+        buffer: T;
			
 
				+    }
			
 
				+    interface FileReadOptions<T extends NodeJS.ArrayBufferView = Buffer> {
			
 
				+        /**
			
 
				+         * @default `Buffer.alloc(0xffff)`
			
 
				+         */
			
 
				+        buffer?: T;
			
 
				+        /**
			
 
				+         * @default 0
			
 
				+         */
			
 
				+        offset?: number | null;
			
 
				+        /**
			
 
				+         * @default `buffer.byteLength`
			
 
				+         */
			
 
				+        length?: number | null;
			
 
				+        position?: number | null;
			
 
				+    }
			
 
				+    interface CreateReadStreamOptions {
			
 
				+        encoding?: BufferEncoding | null | undefined;
			
 
				+        autoClose?: boolean | undefined;
			
 
				+        emitClose?: boolean | undefined;
			
 
				+        start?: number | undefined;
			
 
				+        end?: number | undefined;
			
 
				+        highWaterMark?: number | undefined;
			
 
				+    }
			
 
				+    interface CreateWriteStreamOptions {
			
 
				+        encoding?: BufferEncoding | null | undefined;
			
 
				+        autoClose?: boolean | undefined;
			
 
				+        emitClose?: boolean | undefined;
			
 
				+        start?: number | undefined;
			
 
				+    }
			
 
				+    // TODO: Add `EventEmitter` close
			
 
				+    interface FileHandle {
			
 
				+        /**
			
 
				+         * The numeric file descriptor managed by the {FileHandle} object.
			
 
				+         * @since v10.0.0
			
 
				+         */
			
 
				+        readonly fd: number;
			
 
				+        /**
			
 
				+         * Alias of `filehandle.writeFile()`.
			
 
				+         *
			
 
				+         * When operating on file handles, the mode cannot be changed from what it was set
			
 
				+         * to with `fsPromises.open()`. Therefore, this is equivalent to `filehandle.writeFile()`.
			
 
				+         * @since v10.0.0
			
 
				+         * @return Fulfills with `undefined` upon success.
			
 
				+         */
			
 
				+        appendFile(data: string | Uint8Array, options?: (ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding | null): Promise<void>;
			
 
				+        /**
			
 
				+         * Changes the ownership of the file. A wrapper for [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html).
			
 
				+         * @since v10.0.0
			
 
				+         * @param uid The file's new owner's user id.
			
 
				+         * @param gid The file's new group's group id.
			
 
				+         * @return Fulfills with `undefined` upon success.
			
 
				+         */
			
 
				+        chown(uid: number, gid: number): Promise<void>;
			
 
				+        /**
			
 
				+         * Modifies the permissions on the file. See [`chmod(2)`](http://man7.org/linux/man-pages/man2/chmod.2.html).
			
 
				+         * @since v10.0.0
			
 
				+         * @param mode the file mode bit mask.
			
 
				+         * @return Fulfills with `undefined` upon success.
			
 
				+         */
			
 
				+        chmod(mode: Mode): Promise<void>;
			
 
				+        /**
			
 
				+         * Unlike the 16 kb default `highWaterMark` for a `stream.Readable`, the stream
			
 
				+         * returned by this method has a default `highWaterMark` of 64 kb.
			
 
				+         *
			
 
				+         * `options` can include `start` and `end` values to read a range of bytes from
			
 
				+         * the file instead of the entire file. Both `start` and `end` are inclusive and
			
 
				+         * start counting at 0, allowed values are in the
			
 
				+         * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. If `start` is
			
 
				+         * omitted or `undefined`, `filehandle.createReadStream()` reads sequentially from
			
 
				+         * the current file position. The `encoding` can be any one of those accepted by `Buffer`.
			
 
				+         *
			
 
				+         * If the `FileHandle` points to a character device that only supports blocking
			
 
				+         * reads (such as keyboard or sound card), read operations do not finish until data
			
 
				+         * is available. This can prevent the process from exiting and the stream from
			
 
				+         * closing naturally.
			
 
				+         *
			
 
				+         * By default, the stream will emit a `'close'` event after it has been
			
 
				+         * destroyed.  Set the `emitClose` option to `false` to change this behavior.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import { open } from 'fs/promises';
			
 
				+         *
			
 
				+         * const fd = await open('/dev/input/event0');
			
 
				+         * // Create a stream from some character device.
			
 
				+         * const stream = fd.createReadStream();
			
 
				+         * setTimeout(() => {
			
 
				+         *   stream.close(); // This may not close the stream.
			
 
				+         *   // Artificially marking end-of-stream, as if the underlying resource had
			
 
				+         *   // indicated end-of-file by itself, allows the stream to close.
			
 
				+         *   // This does not cancel pending read operations, and if there is such an
			
 
				+         *   // operation, the process may still not be able to exit successfully
			
 
				+         *   // until it finishes.
			
 
				+         *   stream.push(null);
			
 
				+         *   stream.read(0);
			
 
				+         * }, 100);
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If `autoClose` is false, then the file descriptor won't be closed, even if
			
 
				+         * there's an error. It is the application's responsibility to close it and make
			
 
				+         * sure there's no file descriptor leak. If `autoClose` is set to true (default
			
 
				+         * behavior), on `'error'` or `'end'` the file descriptor will be closed
			
 
				+         * automatically.
			
 
				+         *
			
 
				+         * An example to read the last 10 bytes of a file which is 100 bytes long:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import { open } from 'fs/promises';
			
 
				+         *
			
 
				+         * const fd = await open('sample.txt');
			
 
				+         * fd.createReadStream({ start: 90, end: 99 });
			
 
				+         * ```
			
 
				+         * @since v16.11.0
			
 
				+         */
			
 
				+        createReadStream(options?: CreateReadStreamOptions): ReadStream;
			
 
				+        /**
			
 
				+         * `options` may also include a `start` option to allow writing data at some
			
 
				+         * position past the beginning of the file, allowed values are in the
			
 
				+         * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. Modifying a file rather than
			
 
				+         * replacing it may require the `flags` `open` option to be set to `r+` rather than
			
 
				+         * the default `r`. The `encoding` can be any one of those accepted by `Buffer`.
			
 
				+         *
			
 
				+         * If `autoClose` is set to true (default behavior) on `'error'` or `'finish'`the file descriptor will be closed automatically. If `autoClose` is false,
			
 
				+         * then the file descriptor won't be closed, even if there's an error.
			
 
				+         * It is the application's responsibility to close it and make sure there's no
			
 
				+         * file descriptor leak.
			
 
				+         *
			
 
				+         * By default, the stream will emit a `'close'` event after it has been
			
 
				+         * destroyed.  Set the `emitClose` option to `false` to change this behavior.
			
 
				+         * @since v16.11.0
			
 
				+         */
			
 
				+        createWriteStream(options?: CreateWriteStreamOptions): WriteStream;
			
 
				+        /**
			
 
				+         * Forces all currently queued I/O operations associated with the file to the
			
 
				+         * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details.
			
 
				+         *
			
 
				+         * Unlike `filehandle.sync` this method does not flush modified metadata.
			
 
				+         * @since v10.0.0
			
 
				+         * @return Fulfills with `undefined` upon success.
			
 
				+         */
			
 
				+        datasync(): Promise<void>;
			
 
				+        /**
			
 
				+         * Request that all data for the open file descriptor is flushed to the storage
			
 
				+         * device. The specific implementation is operating system and device specific.
			
 
				+         * Refer to the POSIX [`fsync(2)`](http://man7.org/linux/man-pages/man2/fsync.2.html) documentation for more detail.
			
 
				+         * @since v10.0.0
			
 
				+         * @return Fufills with `undefined` upon success.
			
 
				+         */
			
 
				+        sync(): Promise<void>;
			
 
				+        /**
			
 
				+         * Reads data from the file and stores that in the given buffer.
			
 
				+         *
			
 
				+         * If the file is not modified concurrently, the end-of-file is reached when the
			
 
				+         * number of bytes read is zero.
			
 
				+         * @since v10.0.0
			
 
				+         * @param buffer A buffer that will be filled with the file data read.
			
 
				+         * @param offset The location in the buffer at which to start filling.
			
 
				+         * @param length The number of bytes to read.
			
 
				+         * @param position The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an
			
 
				+         * integer, the current file position will remain unchanged.
			
 
				+         * @return Fulfills upon success with an object with two properties:
			
 
				+         */
			
 
				+        read<T extends NodeJS.ArrayBufferView>(buffer: T, offset?: number | null, length?: number | null, position?: number | null): Promise<FileReadResult<T>>;
			
 
				+        read<T extends NodeJS.ArrayBufferView = Buffer>(options?: FileReadOptions<T>): Promise<FileReadResult<T>>;
			
 
				+        /**
			
 
				+         * Returns a `ReadableStream` that may be used to read the files data.
			
 
				+         *
			
 
				+         * An error will be thrown if this method is called more than once or is called after the `FileHandle` is closed
			
 
				+         * or closing.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import { open } from 'node:fs/promises';
			
 
				+         *
			
 
				+         * const file = await open('./some/file/to/read');
			
 
				+         *
			
 
				+         * for await (const chunk of file.readableWebStream())
			
 
				+         *   console.log(chunk);
			
 
				+         *
			
 
				+         * await file.close();
			
 
				+         * ```
			
 
				+         *
			
 
				+         * While the `ReadableStream` will read the file to completion, it will not close the `FileHandle` automatically. User code must still call the `fileHandle.close()` method.
			
 
				+         *
			
 
				+         * @since v17.0.0
			
 
				+         * @experimental
			
 
				+         */
			
 
				+        readableWebStream(): ReadableStream;
			
 
				+        /**
			
 
				+         * Asynchronously reads the entire contents of a file.
			
 
				+         *
			
 
				+         * If `options` is a string, then it specifies the `encoding`.
			
 
				+         *
			
 
				+         * The `FileHandle` has to support reading.
			
 
				+         *
			
 
				+         * If one or more `filehandle.read()` calls are made on a file handle and then a`filehandle.readFile()` call is made, the data will be read from the current
			
 
				+         * position till the end of the file. It doesn't always read from the beginning
			
 
				+         * of the file.
			
 
				+         * @since v10.0.0
			
 
				+         * @return Fulfills upon a successful read with the contents of the file. If no encoding is specified (using `options.encoding`), the data is returned as a {Buffer} object. Otherwise, the
			
 
				+         * data will be a string.
			
 
				+         */
			
 
				+        readFile(
			
 
				+            options?: {
			
 
				+                encoding?: null | undefined;
			
 
				+                flag?: OpenMode | undefined;
			
 
				+            } | null
			
 
				+        ): Promise<Buffer>;
			
 
				+        /**
			
 
				+         * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
			
 
				+         * The `FileHandle` must have been opened for reading.
			
 
				+         * @param options An object that may contain an optional flag.
			
 
				+         * If a flag is not provided, it defaults to `'r'`.
			
 
				+         */
			
 
				+        readFile(
			
 
				+            options:
			
 
				+                | {
			
 
				+                      encoding: BufferEncoding;
			
 
				+                      flag?: OpenMode | undefined;
			
 
				+                  }
			
 
				+                | BufferEncoding
			
 
				+        ): Promise<string>;
			
 
				+        /**
			
 
				+         * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
			
 
				+         * The `FileHandle` must have been opened for reading.
			
 
				+         * @param options An object that may contain an optional flag.
			
 
				+         * If a flag is not provided, it defaults to `'r'`.
			
 
				+         */
			
 
				+        readFile(
			
 
				+            options?:
			
 
				+                | (ObjectEncodingOptions & {
			
 
				+                      flag?: OpenMode | undefined;
			
 
				+                  })
			
 
				+                | BufferEncoding
			
 
				+                | null
			
 
				+        ): Promise<string | Buffer>;
			
 
				+        /**
			
 
				+         * Convenience method to create a `readline` interface and stream over the file. For example:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import { open } from 'node:fs/promises';
			
 
				+         *
			
 
				+         * const file = await open('./some/file/to/read');
			
 
				+         *
			
 
				+         * for await (const line of file.readLines()) {
			
 
				+         *   console.log(line);
			
 
				+         * }
			
 
				+         * ```
			
 
				+         *
			
 
				+         * @since v18.11.0
			
 
				+         * @param options See `filehandle.createReadStream()` for the options.
			
 
				+         */
			
 
				+        readLines(options?: CreateReadStreamOptions): ReadlineInterface;
			
 
				+        /**
			
 
				+         * @since v10.0.0
			
 
				+         * @return Fulfills with an {fs.Stats} for the file.
			
 
				+         */
			
 
				+        stat(
			
 
				+            opts?: StatOptions & {
			
 
				+                bigint?: false | undefined;
			
 
				+            }
			
 
				+        ): Promise<Stats>;
			
 
				+        stat(
			
 
				+            opts: StatOptions & {
			
 
				+                bigint: true;
			
 
				+            }
			
 
				+        ): Promise<BigIntStats>;
			
 
				+        stat(opts?: StatOptions): Promise<Stats | BigIntStats>;
			
 
				+        /**
			
 
				+         * Truncates the file.
			
 
				+         *
			
 
				+         * If the file was larger than `len` bytes, only the first `len` bytes will be
			
 
				+         * retained in the file.
			
 
				+         *
			
 
				+         * The following example retains only the first four bytes of the file:
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import { open } from 'fs/promises';
			
 
				+         *
			
 
				+         * let filehandle = null;
			
 
				+         * try {
			
 
				+         *   filehandle = await open('temp.txt', 'r+');
			
 
				+         *   await filehandle.truncate(4);
			
 
				+         * } finally {
			
 
				+         *   await filehandle?.close();
			
 
				+         * }
			
 
				+         * ```
			
 
				+         *
			
 
				+         * If the file previously was shorter than `len` bytes, it is extended, and the
			
 
				+         * extended part is filled with null bytes (`'\0'`):
			
 
				+         *
			
 
				+         * If `len` is negative then `0` will be used.
			
 
				+         * @since v10.0.0
			
 
				+         * @param [len=0]
			
 
				+         * @return Fulfills with `undefined` upon success.
			
 
				+         */
			
 
				+        truncate(len?: number): Promise<void>;
			
 
				+        /**
			
 
				+         * Change the file system timestamps of the object referenced by the `FileHandle` then resolves the promise with no arguments upon success.
			
 
				+         * @since v10.0.0
			
 
				+         */
			
 
				+        utimes(atime: TimeLike, mtime: TimeLike): Promise<void>;
			
 
				+        /**
			
 
				+         * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a buffer, an
			
 
				+         * [AsyncIterable](https://tc39.github.io/ecma262/#sec-asynciterable-interface) or
			
 
				+         * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol) object.
			
 
				+         * The promise is resolved with no arguments upon success.
			
 
				+         *
			
 
				+         * If `options` is a string, then it specifies the `encoding`.
			
 
				+         *
			
 
				+         * The `FileHandle` has to support writing.
			
 
				+         *
			
 
				+         * It is unsafe to use `filehandle.writeFile()` multiple times on the same file
			
 
				+         * without waiting for the promise to be resolved (or rejected).
			
 
				+         *
			
 
				+         * If one or more `filehandle.write()` calls are made on a file handle and then a`filehandle.writeFile()` call is made, the data will be written from the
			
 
				+         * current position till the end of the file. It doesn't always write from the
			
 
				+         * beginning of the file.
			
 
				+         * @since v10.0.0
			
 
				+         */
			
 
				+        writeFile(data: string | Uint8Array, options?: (ObjectEncodingOptions & FlagAndOpenMode & Abortable) | BufferEncoding | null): Promise<void>;
			
 
				+        /**
			
 
				+         * Write `buffer` to the file.
			
 
				+         *
			
 
				+         * The promise is resolved with an object containing two properties:
			
 
				+         *
			
 
				+         * It is unsafe to use `filehandle.write()` multiple times on the same file
			
 
				+         * without waiting for the promise to be resolved (or rejected). For this
			
 
				+         * scenario, use `filehandle.createWriteStream()`.
			
 
				+         *
			
 
				+         * On Linux, positional writes do not work when the file is opened in append mode.
			
 
				+         * The kernel ignores the position argument and always appends the data to
			
 
				+         * the end of the file.
			
 
				+         * @since v10.0.0
			
 
				+         * @param [offset=0] The start position from within `buffer` where the data to write begins.
			
 
				+         * @param [length=buffer.byteLength - offset] The number of bytes from `buffer` to write.
			
 
				+         * @param position The offset from the beginning of the file where the data from `buffer` should be written. If `position` is not a `number`, the data will be written at the current position.
			
 
				+         * See the POSIX pwrite(2) documentation for more detail.
			
 
				+         */
			
 
				+        write<TBuffer extends Uint8Array>(
			
 
				+            buffer: TBuffer,
			
 
				+            offset?: number | null,
			
 
				+            length?: number | null,
			
 
				+            position?: number | null
			
 
				+        ): Promise<{
			
 
				+            bytesWritten: number;
			
 
				+            buffer: TBuffer;
			
 
				+        }>;
			
 
				+        write(
			
 
				+            data: string,
			
 
				+            position?: number | null,
			
 
				+            encoding?: BufferEncoding | null
			
 
				+        ): Promise<{
			
 
				+            bytesWritten: number;
			
 
				+            buffer: string;
			
 
				+        }>;
			
 
				+        /**
			
 
				+         * Write an array of [ArrayBufferView](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView) s to the file.
			
 
				+         *
			
 
				+         * The promise is resolved with an object containing a two properties:
			
 
				+         *
			
 
				+         * It is unsafe to call `writev()` multiple times on the same file without waiting
			
 
				+         * for the promise to be resolved (or rejected).
			
 
				+         *
			
 
				+         * On Linux, positional writes don't work when the file is opened in append mode.
			
 
				+         * The kernel ignores the position argument and always appends the data to
			
 
				+         * the end of the file.
			
 
				+         * @since v12.9.0
			
 
				+         * @param position The offset from the beginning of the file where the data from `buffers` should be written. If `position` is not a `number`, the data will be written at the current
			
 
				+         * position.
			
 
				+         */
			
 
				+        writev(buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): Promise<WriteVResult>;
			
 
				+        /**
			
 
				+         * Read from a file and write to an array of [ArrayBufferView](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView) s
			
 
				+         * @since v13.13.0, v12.17.0
			
 
				+         * @param position The offset from the beginning of the file where the data should be read from. If `position` is not a `number`, the data will be read from the current position.
			
 
				+         * @return Fulfills upon success an object containing two properties:
			
 
				+         */
			
 
				+        readv(buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): Promise<ReadVResult>;
			
 
				+        /**
			
 
				+         * Closes the file handle after waiting for any pending operation on the handle to
			
 
				+         * complete.
			
 
				+         *
			
 
				+         * ```js
			
 
				+         * import { open } from 'fs/promises';
			
 
				+         *
			
 
				+         * let filehandle;
			
 
				+         * try {
			
 
				+         *   filehandle = await open('thefile.txt', 'r');
			
 
				+         * } finally {
			
 
				+         *   await filehandle?.close();
			
 
				+         * }
			
 
				+         * ```
			
 
				+         * @since v10.0.0
			
 
				+         * @return Fulfills with `undefined` upon success.
			
 
				+         */
			
 
				+        close(): Promise<void>;
			
 
				+    }
			
 
				+
			
 
				+    const constants: typeof fsConstants;
			
 
				+
			
 
				+    /**
			
 
				+     * Tests a user's permissions for the file or directory specified by `path`.
			
 
				+     * The `mode` argument is an optional integer that specifies the accessibility
			
 
				+     * checks to be performed. `mode` should be either the value `fs.constants.F_OK`or a mask consisting of the bitwise OR of any of `fs.constants.R_OK`,`fs.constants.W_OK`, and `fs.constants.X_OK`
			
 
				+     * (e.g.`fs.constants.W_OK | fs.constants.R_OK`). Check `File access constants` for
			
 
				+     * possible values of `mode`.
			
 
				+     *
			
 
				+     * If the accessibility check is successful, the promise is resolved with no
			
 
				+     * value. If any of the accessibility checks fail, the promise is rejected
			
 
				+     * with an [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) object. The following example checks if the file`/etc/passwd` can be read and
			
 
				+     * written by the current process.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { access } from 'fs/promises';
			
 
				+     * import { constants } from 'fs';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   await access('/etc/passwd', constants.R_OK | constants.W_OK);
			
 
				+     *   console.log('can access');
			
 
				+     * } catch {
			
 
				+     *   console.error('cannot access');
			
 
				+     * }
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Using `fsPromises.access()` to check for the accessibility of a file before
			
 
				+     * calling `fsPromises.open()` is not recommended. Doing so introduces a race
			
 
				+     * condition, since other processes may change the file's state between the two
			
 
				+     * calls. Instead, user code should open/read/write the file directly and handle
			
 
				+     * the error raised if the file is not accessible.
			
 
				+     * @since v10.0.0
			
 
				+     * @param [mode=fs.constants.F_OK]
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function access(path: PathLike, mode?: number): Promise<void>;
			
 
				+    /**
			
 
				+     * Asynchronously copies `src` to `dest`. By default, `dest` is overwritten if it
			
 
				+     * already exists.
			
 
				+     *
			
 
				+     * No guarantees are made about the atomicity of the copy operation. If an
			
 
				+     * error occurs after the destination file has been opened for writing, an attempt
			
 
				+     * will be made to remove the destination.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { constants } from 'fs';
			
 
				+     * import { copyFile } from 'fs/promises';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   await copyFile('source.txt', 'destination.txt');
			
 
				+     *   console.log('source.txt was copied to destination.txt');
			
 
				+     * } catch {
			
 
				+     *   console.log('The file could not be copied');
			
 
				+     * }
			
 
				+     *
			
 
				+     * // By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
			
 
				+     * try {
			
 
				+     *   await copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL);
			
 
				+     *   console.log('source.txt was copied to destination.txt');
			
 
				+     * } catch {
			
 
				+     *   console.log('The file could not be copied');
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v10.0.0
			
 
				+     * @param src source filename to copy
			
 
				+     * @param dest destination filename of the copy operation
			
 
				+     * @param [mode=0] Optional modifiers that specify the behavior of the copy operation. It is possible to create a mask consisting of the bitwise OR of two or more values (e.g.
			
 
				+     * `fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`)
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function copyFile(src: PathLike, dest: PathLike, mode?: number): Promise<void>;
			
 
				+    /**
			
 
				+     * Opens a `FileHandle`.
			
 
				+     *
			
 
				+     * Refer to the POSIX [`open(2)`](http://man7.org/linux/man-pages/man2/open.2.html) documentation for more detail.
			
 
				+     *
			
 
				+     * Some characters (`< > : " / \ | ? *`) are reserved under Windows as documented
			
 
				+     * by [Naming Files, Paths, and Namespaces](https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file). Under NTFS, if the filename contains
			
 
				+     * a colon, Node.js will open a file system stream, as described by [this MSDN page](https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams).
			
 
				+     * @since v10.0.0
			
 
				+     * @param [flags='r'] See `support of file system `flags``.
			
 
				+     * @param [mode=0o666] Sets the file mode (permission and sticky bits) if the file is created.
			
 
				+     * @return Fulfills with a {FileHandle} object.
			
 
				+     */
			
 
				+    function open(path: PathLike, flags?: string | number, mode?: Mode): Promise<FileHandle>;
			
 
				+    /**
			
 
				+     * Renames `oldPath` to `newPath`.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function rename(oldPath: PathLike, newPath: PathLike): Promise<void>;
			
 
				+    /**
			
 
				+     * Truncates (shortens or extends the length) of the content at `path` to `len`bytes.
			
 
				+     * @since v10.0.0
			
 
				+     * @param [len=0]
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function truncate(path: PathLike, len?: number): Promise<void>;
			
 
				+    /**
			
 
				+     * Removes the directory identified by `path`.
			
 
				+     *
			
 
				+     * Using `fsPromises.rmdir()` on a file (not a directory) results in the
			
 
				+     * promise being rejected with an `ENOENT` error on Windows and an `ENOTDIR`error on POSIX.
			
 
				+     *
			
 
				+     * To get a behavior similar to the `rm -rf` Unix command, use `fsPromises.rm()` with options `{ recursive: true, force: true }`.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function rmdir(path: PathLike, options?: RmDirOptions): Promise<void>;
			
 
				+    /**
			
 
				+     * Removes files and directories (modeled on the standard POSIX `rm` utility).
			
 
				+     * @since v14.14.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function rm(path: PathLike, options?: RmOptions): Promise<void>;
			
 
				+    /**
			
 
				+     * Asynchronously creates a directory.
			
 
				+     *
			
 
				+     * The optional `options` argument can be an integer specifying `mode` (permission
			
 
				+     * and sticky bits), or an object with a `mode` property and a `recursive`property indicating whether parent directories should be created. Calling`fsPromises.mkdir()` when `path` is a directory
			
 
				+     * that exists results in a
			
 
				+     * rejection only when `recursive` is false.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Upon success, fulfills with `undefined` if `recursive` is `false`, or the first directory path created if `recursive` is `true`.
			
 
				+     */
			
 
				+    function mkdir(
			
 
				+        path: PathLike,
			
 
				+        options: MakeDirectoryOptions & {
			
 
				+            recursive: true;
			
 
				+        }
			
 
				+    ): Promise<string | undefined>;
			
 
				+    /**
			
 
				+     * Asynchronous mkdir(2) - create a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
			
 
				+     * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
			
 
				+     */
			
 
				+    function mkdir(
			
 
				+        path: PathLike,
			
 
				+        options?:
			
 
				+            | Mode
			
 
				+            | (MakeDirectoryOptions & {
			
 
				+                  recursive?: false | undefined;
			
 
				+              })
			
 
				+            | null
			
 
				+    ): Promise<void>;
			
 
				+    /**
			
 
				+     * Asynchronous mkdir(2) - create a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
			
 
				+     * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
			
 
				+     */
			
 
				+    function mkdir(path: PathLike, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined>;
			
 
				+    /**
			
 
				+     * Reads the contents of a directory.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use for
			
 
				+     * the filenames. If the `encoding` is set to `'buffer'`, the filenames returned
			
 
				+     * will be passed as `Buffer` objects.
			
 
				+     *
			
 
				+     * If `options.withFileTypes` is set to `true`, the resolved array will contain `fs.Dirent` objects.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { readdir } from 'fs/promises';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   const files = await readdir(path);
			
 
				+     *   for (const file of files)
			
 
				+     *     console.log(file);
			
 
				+     * } catch (err) {
			
 
				+     *   console.error(err);
			
 
				+     * }
			
 
				+     * ```
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with an array of the names of the files in the directory excluding `'.'` and `'..'`.
			
 
				+     */
			
 
				+    function readdir(
			
 
				+        path: PathLike,
			
 
				+        options?:
			
 
				+            | (ObjectEncodingOptions & {
			
 
				+                  withFileTypes?: false | undefined;
			
 
				+              })
			
 
				+            | BufferEncoding
			
 
				+            | null
			
 
				+    ): Promise<string[]>;
			
 
				+    /**
			
 
				+     * Asynchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    function readdir(
			
 
				+        path: PathLike,
			
 
				+        options:
			
 
				+            | {
			
 
				+                  encoding: 'buffer';
			
 
				+                  withFileTypes?: false | undefined;
			
 
				+              }
			
 
				+            | 'buffer'
			
 
				+    ): Promise<Buffer[]>;
			
 
				+    /**
			
 
				+     * Asynchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    function readdir(
			
 
				+        path: PathLike,
			
 
				+        options?:
			
 
				+            | (ObjectEncodingOptions & {
			
 
				+                  withFileTypes?: false | undefined;
			
 
				+              })
			
 
				+            | BufferEncoding
			
 
				+            | null
			
 
				+    ): Promise<string[] | Buffer[]>;
			
 
				+    /**
			
 
				+     * Asynchronous readdir(3) - read a directory.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options If called with `withFileTypes: true` the result data will be an array of Dirent.
			
 
				+     */
			
 
				+    function readdir(
			
 
				+        path: PathLike,
			
 
				+        options: ObjectEncodingOptions & {
			
 
				+            withFileTypes: true;
			
 
				+        }
			
 
				+    ): Promise<Dirent[]>;
			
 
				+    /**
			
 
				+     * Reads the contents of the symbolic link referred to by `path`. See the POSIX [`readlink(2)`](http://man7.org/linux/man-pages/man2/readlink.2.html) documentation for more detail. The promise is
			
 
				+     * resolved with the`linkString` upon success.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use for
			
 
				+     * the link path returned. If the `encoding` is set to `'buffer'`, the link path
			
 
				+     * returned will be passed as a `Buffer` object.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with the `linkString` upon success.
			
 
				+     */
			
 
				+    function readlink(path: PathLike, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
			
 
				+    /**
			
 
				+     * Asynchronous readlink(2) - read value of a symbolic link.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    function readlink(path: PathLike, options: BufferEncodingOption): Promise<Buffer>;
			
 
				+    /**
			
 
				+     * Asynchronous readlink(2) - read value of a symbolic link.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    function readlink(path: PathLike, options?: ObjectEncodingOptions | string | null): Promise<string | Buffer>;
			
 
				+    /**
			
 
				+     * Creates a symbolic link.
			
 
				+     *
			
 
				+     * The `type` argument is only used on Windows platforms and can be one of `'dir'`,`'file'`, or `'junction'`. Windows junction points require the destination path
			
 
				+     * to be absolute. When using `'junction'`, the `target` argument will
			
 
				+     * automatically be normalized to absolute path.
			
 
				+     * @since v10.0.0
			
 
				+     * @param [type='file']
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function symlink(target: PathLike, path: PathLike, type?: string | null): Promise<void>;
			
 
				+    /**
			
 
				+     * Equivalent to `fsPromises.stat()` unless `path` refers to a symbolic link,
			
 
				+     * in which case the link itself is stat-ed, not the file that it refers to.
			
 
				+     * Refer to the POSIX [`lstat(2)`](http://man7.org/linux/man-pages/man2/lstat.2.html) document for more detail.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with the {fs.Stats} object for the given symbolic link `path`.
			
 
				+     */
			
 
				+    function lstat(
			
 
				+        path: PathLike,
			
 
				+        opts?: StatOptions & {
			
 
				+            bigint?: false | undefined;
			
 
				+        }
			
 
				+    ): Promise<Stats>;
			
 
				+    function lstat(
			
 
				+        path: PathLike,
			
 
				+        opts: StatOptions & {
			
 
				+            bigint: true;
			
 
				+        }
			
 
				+    ): Promise<BigIntStats>;
			
 
				+    function lstat(path: PathLike, opts?: StatOptions): Promise<Stats | BigIntStats>;
			
 
				+    /**
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with the {fs.Stats} object for the given `path`.
			
 
				+     */
			
 
				+    function stat(
			
 
				+        path: PathLike,
			
 
				+        opts?: StatOptions & {
			
 
				+            bigint?: false | undefined;
			
 
				+        }
			
 
				+    ): Promise<Stats>;
			
 
				+    function stat(
			
 
				+        path: PathLike,
			
 
				+        opts: StatOptions & {
			
 
				+            bigint: true;
			
 
				+        }
			
 
				+    ): Promise<BigIntStats>;
			
 
				+    function stat(path: PathLike, opts?: StatOptions): Promise<Stats | BigIntStats>;
			
 
				+    /**
			
 
				+     * @since v18.15.0
			
 
				+     * @return Fulfills with an {fs.StatFs} for the file system.
			
 
				+     */
			
 
				+    function statfs(
			
 
				+        path: PathLike,
			
 
				+        opts?: StatFsOptions & {
			
 
				+            bigint?: false | undefined;
			
 
				+        }
			
 
				+    ): Promise<StatsFs>;
			
 
				+    function statfs(
			
 
				+        path: PathLike,
			
 
				+        opts: StatFsOptions & {
			
 
				+            bigint: true;
			
 
				+        }
			
 
				+    ): Promise<BigIntStatsFs>;
			
 
				+    function statfs(path: PathLike, opts?: StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
			
 
				+
			
 
				+    /**
			
 
				+     * Creates a new link from the `existingPath` to the `newPath`. See the POSIX [`link(2)`](http://man7.org/linux/man-pages/man2/link.2.html) documentation for more detail.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function link(existingPath: PathLike, newPath: PathLike): Promise<void>;
			
 
				+    /**
			
 
				+     * If `path` refers to a symbolic link, then the link is removed without affecting
			
 
				+     * the file or directory to which that link refers. If the `path` refers to a file
			
 
				+     * path that is not a symbolic link, the file is deleted. See the POSIX [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html) documentation for more detail.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function unlink(path: PathLike): Promise<void>;
			
 
				+    /**
			
 
				+     * Changes the permissions of a file.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function chmod(path: PathLike, mode: Mode): Promise<void>;
			
 
				+    /**
			
 
				+     * Changes the permissions on a symbolic link.
			
 
				+     *
			
 
				+     * This method is only implemented on macOS.
			
 
				+     * @deprecated Since v10.0.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function lchmod(path: PathLike, mode: Mode): Promise<void>;
			
 
				+    /**
			
 
				+     * Changes the ownership on a symbolic link.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function lchown(path: PathLike, uid: number, gid: number): Promise<void>;
			
 
				+    /**
			
 
				+     * Changes the access and modification times of a file in the same way as `fsPromises.utimes()`, with the difference that if the path refers to a
			
 
				+     * symbolic link, then the link is not dereferenced: instead, the timestamps of
			
 
				+     * the symbolic link itself are changed.
			
 
				+     * @since v14.5.0, v12.19.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
			
 
				+    /**
			
 
				+     * Changes the ownership of a file.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function chown(path: PathLike, uid: number, gid: number): Promise<void>;
			
 
				+    /**
			
 
				+     * Change the file system timestamps of the object referenced by `path`.
			
 
				+     *
			
 
				+     * The `atime` and `mtime` arguments follow these rules:
			
 
				+     *
			
 
				+     * * Values can be either numbers representing Unix epoch time, `Date`s, or a
			
 
				+     * numeric string like `'123456789.0'`.
			
 
				+     * * If the value can not be converted to a number, or is `NaN`, `Infinity` or`-Infinity`, an `Error` will be thrown.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
			
 
				+    /**
			
 
				+     * Determines the actual location of `path` using the same semantics as the`fs.realpath.native()` function.
			
 
				+     *
			
 
				+     * Only paths that can be converted to UTF8 strings are supported.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use for
			
 
				+     * the path. If the `encoding` is set to `'buffer'`, the path returned will be
			
 
				+     * passed as a `Buffer` object.
			
 
				+     *
			
 
				+     * On Linux, when Node.js is linked against musl libc, the procfs file system must
			
 
				+     * be mounted on `/proc` in order for this function to work. Glibc does not have
			
 
				+     * this restriction.
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with the resolved path upon success.
			
 
				+     */
			
 
				+    function realpath(path: PathLike, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
			
 
				+    /**
			
 
				+     * Asynchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    function realpath(path: PathLike, options: BufferEncodingOption): Promise<Buffer>;
			
 
				+    /**
			
 
				+     * Asynchronous realpath(3) - return the canonicalized absolute pathname.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    function realpath(path: PathLike, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
			
 
				+    /**
			
 
				+     * Creates a unique temporary directory. A unique directory name is generated by
			
 
				+     * appending six random characters to the end of the provided `prefix`. Due to
			
 
				+     * platform inconsistencies, avoid trailing `X` characters in `prefix`. Some
			
 
				+     * platforms, notably the BSDs, can return more than six random characters, and
			
 
				+     * replace trailing `X` characters in `prefix` with random characters.
			
 
				+     *
			
 
				+     * The optional `options` argument can be a string specifying an encoding, or an
			
 
				+     * object with an `encoding` property specifying the character encoding to use.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { mkdtemp } from 'fs/promises';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   await mkdtemp(path.join(os.tmpdir(), 'foo-'));
			
 
				+     * } catch (err) {
			
 
				+     *   console.error(err);
			
 
				+     * }
			
 
				+     * ```
			
 
				+     *
			
 
				+     * The `fsPromises.mkdtemp()` method will append the six randomly selected
			
 
				+     * characters directly to the `prefix` string. For instance, given a directory`/tmp`, if the intention is to create a temporary directory _within_`/tmp`, the`prefix` must end with a trailing
			
 
				+     * platform-specific path separator
			
 
				+     * (`require('path').sep`).
			
 
				+     * @since v10.0.0
			
 
				+     * @return Fulfills with a string containing the filesystem path of the newly created temporary directory.
			
 
				+     */
			
 
				+    function mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
			
 
				+    /**
			
 
				+     * Asynchronously creates a unique temporary directory.
			
 
				+     * Generates six random characters to be appended behind a required `prefix` to create a unique temporary directory.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    function mkdtemp(prefix: string, options: BufferEncodingOption): Promise<Buffer>;
			
 
				+    /**
			
 
				+     * Asynchronously creates a unique temporary directory.
			
 
				+     * Generates six random characters to be appended behind a required `prefix` to create a unique temporary directory.
			
 
				+     * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
			
 
				+     */
			
 
				+    function mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
			
 
				+    /**
			
 
				+     * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a buffer, an
			
 
				+     * [AsyncIterable](https://tc39.github.io/ecma262/#sec-asynciterable-interface) or
			
 
				+     * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol) object.
			
 
				+     *
			
 
				+     * The `encoding` option is ignored if `data` is a buffer.
			
 
				+     *
			
 
				+     * If `options` is a string, then it specifies the encoding.
			
 
				+     *
			
 
				+     * The `mode` option only affects the newly created file. See `fs.open()` for more details.
			
 
				+     *
			
 
				+     * Any specified `FileHandle` has to support writing.
			
 
				+     *
			
 
				+     * It is unsafe to use `fsPromises.writeFile()` multiple times on the same file
			
 
				+     * without waiting for the promise to be settled.
			
 
				+     *
			
 
				+     * Similarly to `fsPromises.readFile` \- `fsPromises.writeFile` is a convenience
			
 
				+     * method that performs multiple `write` calls internally to write the buffer
			
 
				+     * passed to it. For performance sensitive code consider using `fs.createWriteStream()` or `filehandle.createWriteStream()`.
			
 
				+     *
			
 
				+     * It is possible to use an `AbortSignal` to cancel an `fsPromises.writeFile()`.
			
 
				+     * Cancelation is "best effort", and some amount of data is likely still
			
 
				+     * to be written.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { writeFile } from 'fs/promises';
			
 
				+     * import { Buffer } from 'buffer';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   const controller = new AbortController();
			
 
				+     *   const { signal } = controller;
			
 
				+     *   const data = new Uint8Array(Buffer.from('Hello Node.js'));
			
 
				+     *   const promise = writeFile('message.txt', data, { signal });
			
 
				+     *
			
 
				+     *   // Abort the request before the promise settles.
			
 
				+     *   controller.abort();
			
 
				+     *
			
 
				+     *   await promise;
			
 
				+     * } catch (err) {
			
 
				+     *   // When a request is aborted - err is an AbortError
			
 
				+     *   console.error(err);
			
 
				+     * }
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Aborting an ongoing request does not abort individual operating
			
 
				+     * system requests but rather the internal buffering `fs.writeFile` performs.
			
 
				+     * @since v10.0.0
			
 
				+     * @param file filename or `FileHandle`
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function writeFile(
			
 
				+        file: PathLike | FileHandle,
			
 
				+        data: string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView> | Stream,
			
 
				+        options?:
			
 
				+            | (ObjectEncodingOptions & {
			
 
				+                  mode?: Mode | undefined;
			
 
				+                  flag?: OpenMode | undefined;
			
 
				+              } & Abortable)
			
 
				+            | BufferEncoding
			
 
				+            | null
			
 
				+    ): Promise<void>;
			
 
				+    /**
			
 
				+     * Asynchronously append data to a file, creating the file if it does not yet
			
 
				+     * exist. `data` can be a string or a `Buffer`.
			
 
				+     *
			
 
				+     * If `options` is a string, then it specifies the `encoding`.
			
 
				+     *
			
 
				+     * The `mode` option only affects the newly created file. See `fs.open()` for more details.
			
 
				+     *
			
 
				+     * The `path` may be specified as a `FileHandle` that has been opened
			
 
				+     * for appending (using `fsPromises.open()`).
			
 
				+     * @since v10.0.0
			
 
				+     * @param path filename or {FileHandle}
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function appendFile(path: PathLike | FileHandle, data: string | Uint8Array, options?: (ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding | null): Promise<void>;
			
 
				+    /**
			
 
				+     * Asynchronously reads the entire contents of a file.
			
 
				+     *
			
 
				+     * If no encoding is specified (using `options.encoding`), the data is returned
			
 
				+     * as a `Buffer` object. Otherwise, the data will be a string.
			
 
				+     *
			
 
				+     * If `options` is a string, then it specifies the encoding.
			
 
				+     *
			
 
				+     * When the `path` is a directory, the behavior of `fsPromises.readFile()` is
			
 
				+     * platform-specific. On macOS, Linux, and Windows, the promise will be rejected
			
 
				+     * with an error. On FreeBSD, a representation of the directory's contents will be
			
 
				+     * returned.
			
 
				+     *
			
 
				+     * It is possible to abort an ongoing `readFile` using an `AbortSignal`. If a
			
 
				+     * request is aborted the promise returned is rejected with an `AbortError`:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { readFile } from 'fs/promises';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   const controller = new AbortController();
			
 
				+     *   const { signal } = controller;
			
 
				+     *   const promise = readFile(fileName, { signal });
			
 
				+     *
			
 
				+     *   // Abort the request before the promise settles.
			
 
				+     *   controller.abort();
			
 
				+     *
			
 
				+     *   await promise;
			
 
				+     * } catch (err) {
			
 
				+     *   // When a request is aborted - err is an AbortError
			
 
				+     *   console.error(err);
			
 
				+     * }
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Aborting an ongoing request does not abort individual operating
			
 
				+     * system requests but rather the internal buffering `fs.readFile` performs.
			
 
				+     *
			
 
				+     * Any specified `FileHandle` has to support reading.
			
 
				+     * @since v10.0.0
			
 
				+     * @param path filename or `FileHandle`
			
 
				+     * @return Fulfills with the contents of the file.
			
 
				+     */
			
 
				+    function readFile(
			
 
				+        path: PathLike | FileHandle,
			
 
				+        options?:
			
 
				+            | ({
			
 
				+                  encoding?: null | undefined;
			
 
				+                  flag?: OpenMode | undefined;
			
 
				+              } & Abortable)
			
 
				+            | null
			
 
				+    ): Promise<Buffer>;
			
 
				+    /**
			
 
				+     * Asynchronously reads the entire contents of a file.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * If a `FileHandle` is provided, the underlying file will _not_ be closed automatically.
			
 
				+     * @param options An object that may contain an optional flag.
			
 
				+     * If a flag is not provided, it defaults to `'r'`.
			
 
				+     */
			
 
				+    function readFile(
			
 
				+        path: PathLike | FileHandle,
			
 
				+        options:
			
 
				+            | ({
			
 
				+                  encoding: BufferEncoding;
			
 
				+                  flag?: OpenMode | undefined;
			
 
				+              } & Abortable)
			
 
				+            | BufferEncoding
			
 
				+    ): Promise<string>;
			
 
				+    /**
			
 
				+     * Asynchronously reads the entire contents of a file.
			
 
				+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * If a `FileHandle` is provided, the underlying file will _not_ be closed automatically.
			
 
				+     * @param options An object that may contain an optional flag.
			
 
				+     * If a flag is not provided, it defaults to `'r'`.
			
 
				+     */
			
 
				+    function readFile(
			
 
				+        path: PathLike | FileHandle,
			
 
				+        options?:
			
 
				+            | (ObjectEncodingOptions &
			
 
				+                  Abortable & {
			
 
				+                      flag?: OpenMode | undefined;
			
 
				+                  })
			
 
				+            | BufferEncoding
			
 
				+            | null
			
 
				+    ): Promise<string | Buffer>;
			
 
				+    /**
			
 
				+     * Asynchronously open a directory for iterative scanning. See the POSIX [`opendir(3)`](http://man7.org/linux/man-pages/man3/opendir.3.html) documentation for more detail.
			
 
				+     *
			
 
				+     * Creates an `fs.Dir`, which contains all further functions for reading from
			
 
				+     * and cleaning up the directory.
			
 
				+     *
			
 
				+     * The `encoding` option sets the encoding for the `path` while opening the
			
 
				+     * directory and subsequent read operations.
			
 
				+     *
			
 
				+     * Example using async iteration:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * import { opendir } from 'fs/promises';
			
 
				+     *
			
 
				+     * try {
			
 
				+     *   const dir = await opendir('./');
			
 
				+     *   for await (const dirent of dir)
			
 
				+     *     console.log(dirent.name);
			
 
				+     * } catch (err) {
			
 
				+     *   console.error(err);
			
 
				+     * }
			
 
				+     * ```
			
 
				+     *
			
 
				+     * When using the async iterator, the `fs.Dir` object will be automatically
			
 
				+     * closed after the iterator exits.
			
 
				+     * @since v12.12.0
			
 
				+     * @return Fulfills with an {fs.Dir}.
			
 
				+     */
			
 
				+    function opendir(path: PathLike, options?: OpenDirOptions): Promise<Dir>;
			
 
				+    /**
			
 
				+     * Returns an async iterator that watches for changes on `filename`, where `filename`is either a file or a directory.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const { watch } = require('fs/promises');
			
 
				+     *
			
 
				+     * const ac = new AbortController();
			
 
				+     * const { signal } = ac;
			
 
				+     * setTimeout(() => ac.abort(), 10000);
			
 
				+     *
			
 
				+     * (async () => {
			
 
				+     *   try {
			
 
				+     *     const watcher = watch(__filename, { signal });
			
 
				+     *     for await (const event of watcher)
			
 
				+     *       console.log(event);
			
 
				+     *   } catch (err) {
			
 
				+     *     if (err.name === 'AbortError')
			
 
				+     *       return;
			
 
				+     *     throw err;
			
 
				+     *   }
			
 
				+     * })();
			
 
				+     * ```
			
 
				+     *
			
 
				+     * On most platforms, `'rename'` is emitted whenever a filename appears or
			
 
				+     * disappears in the directory.
			
 
				+     *
			
 
				+     * All the `caveats` for `fs.watch()` also apply to `fsPromises.watch()`.
			
 
				+     * @since v15.9.0, v14.18.0
			
 
				+     * @return of objects with the properties:
			
 
				+     */
			
 
				+    function watch(
			
 
				+        filename: PathLike,
			
 
				+        options:
			
 
				+            | (WatchOptions & {
			
 
				+                  encoding: 'buffer';
			
 
				+              })
			
 
				+            | 'buffer'
			
 
				+    ): AsyncIterable<FileChangeInfo<Buffer>>;
			
 
				+    /**
			
 
				+     * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
			
 
				+     * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the encoding for the filename provided to the listener, or an object optionally specifying encoding, persistent, and recursive options.
			
 
				+     * If `encoding` is not supplied, the default of `'utf8'` is used.
			
 
				+     * If `persistent` is not supplied, the default of `true` is used.
			
 
				+     * If `recursive` is not supplied, the default of `false` is used.
			
 
				+     */
			
 
				+    function watch(filename: PathLike, options?: WatchOptions | BufferEncoding): AsyncIterable<FileChangeInfo<string>>;
			
 
				+    /**
			
 
				+     * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
			
 
				+     * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
			
 
				+     * @param options Either the encoding for the filename provided to the listener, or an object optionally specifying encoding, persistent, and recursive options.
			
 
				+     * If `encoding` is not supplied, the default of `'utf8'` is used.
			
 
				+     * If `persistent` is not supplied, the default of `true` is used.
			
 
				+     * If `recursive` is not supplied, the default of `false` is used.
			
 
				+     */
			
 
				+    function watch(filename: PathLike, options: WatchOptions | string): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>>;
			
 
				+    /**
			
 
				+     * Asynchronously copies the entire directory structure from `src` to `dest`,
			
 
				+     * including subdirectories and files.
			
 
				+     *
			
 
				+     * When copying a directory to another directory, globs are not supported and
			
 
				+     * behavior is similar to `cp dir1/ dir2/`.
			
 
				+     * @since v16.7.0
			
 
				+     * @experimental
			
 
				+     * @param src source path to copy.
			
 
				+     * @param dest destination path to copy to.
			
 
				+     * @return Fulfills with `undefined` upon success.
			
 
				+     */
			
 
				+    function cp(source: string | URL, destination: string | URL, opts?: CopyOptions): Promise<void>;
			
 
				+}
			
 
				+declare module 'node:fs/promises' {
			
 
				+    export * from 'fs/promises';
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/globals.d.ts
+++ b/Asistent/node_modules/@types/node/globals.d.ts
@@ -0,0 +1,300 @@
 
				+// Declare "static" methods in Error
			
 
				+interface ErrorConstructor {
			
 
				+    /** Create .stack property on a target object */
			
 
				+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
			
 
				+
			
 
				+    /**
			
 
				+     * Optional override for formatting stack traces
			
 
				+     *
			
 
				+     * @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces
			
 
				+     */
			
 
				+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
			
 
				+
			
 
				+    stackTraceLimit: number;
			
 
				+}
			
 
				+
			
 
				+/*-----------------------------------------------*
			
 
				+ *                                               *
			
 
				+ *                   GLOBAL                      *
			
 
				+ *                                               *
			
 
				+ ------------------------------------------------*/
			
 
				+
			
 
				+// For backwards compability
			
 
				+interface NodeRequire extends NodeJS.Require { }
			
 
				+interface RequireResolve extends NodeJS.RequireResolve { }
			
 
				+interface NodeModule extends NodeJS.Module { }
			
 
				+
			
 
				+declare var process: NodeJS.Process;
			
 
				+declare var console: Console;
			
 
				+
			
 
				+declare var __filename: string;
			
 
				+declare var __dirname: string;
			
 
				+
			
 
				+declare var require: NodeRequire;
			
 
				+declare var module: NodeModule;
			
 
				+
			
 
				+// Same as module.exports
			
 
				+declare var exports: any;
			
 
				+
			
 
				+/**
			
 
				+ * Only available if `--expose-gc` is passed to the process.
			
 
				+ */
			
 
				+declare var gc: undefined | (() => void);
			
 
				+
			
 
				+//#region borrowed
			
 
				+// from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
			
 
				+/** A controller object that allows you to abort one or more DOM requests as and when desired. */
			
 
				+interface AbortController {
			
 
				+    /**
			
 
				+     * Returns the AbortSignal object associated with this object.
			
 
				+     */
			
 
				+
			
 
				+    readonly signal: AbortSignal;
			
 
				+    /**
			
 
				+     * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
			
 
				+     */
			
 
				+    abort(): void;
			
 
				+}
			
 
				+
			
 
				+/** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
			
 
				+interface AbortSignal extends EventTarget {
			
 
				+    /**
			
 
				+     * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
			
 
				+     */
			
 
				+    readonly aborted: boolean;
			
 
				+}
			
 
				+
			
 
				+declare var AbortController: typeof globalThis extends {onmessage: any; AbortController: infer T}
			
 
				+    ? T
			
 
				+    : {
			
 
				+        prototype: AbortController;
			
 
				+        new(): AbortController;
			
 
				+    };
			
 
				+
			
 
				+declare var AbortSignal: typeof globalThis extends {onmessage: any; AbortSignal: infer T}
			
 
				+    ? T
			
 
				+    : {
			
 
				+        prototype: AbortSignal;
			
 
				+        new(): AbortSignal;
			
 
				+        abort(reason?: any): AbortSignal;
			
 
				+        timeout(milliseconds: number): AbortSignal;
			
 
				+    };
			
 
				+//#endregion borrowed
			
 
				+
			
 
				+//#region ArrayLike.at()
			
 
				+interface RelativeIndexable<T> {
			
 
				+    /**
			
 
				+     * Takes an integer value and returns the item at that index,
			
 
				+     * allowing for positive and negative integers.
			
 
				+     * Negative integers count back from the last item in the array.
			
 
				+     */
			
 
				+    at(index: number): T | undefined;
			
 
				+}
			
 
				+interface String extends RelativeIndexable<string> {}
			
 
				+interface Array<T> extends RelativeIndexable<T> {}
			
 
				+interface ReadonlyArray<T> extends RelativeIndexable<T> {}
			
 
				+interface Int8Array extends RelativeIndexable<number> {}
			
 
				+interface Uint8Array extends RelativeIndexable<number> {}
			
 
				+interface Uint8ClampedArray extends RelativeIndexable<number> {}
			
 
				+interface Int16Array extends RelativeIndexable<number> {}
			
 
				+interface Uint16Array extends RelativeIndexable<number> {}
			
 
				+interface Int32Array extends RelativeIndexable<number> {}
			
 
				+interface Uint32Array extends RelativeIndexable<number> {}
			
 
				+interface Float32Array extends RelativeIndexable<number> {}
			
 
				+interface Float64Array extends RelativeIndexable<number> {}
			
 
				+interface BigInt64Array extends RelativeIndexable<bigint> {}
			
 
				+interface BigUint64Array extends RelativeIndexable<bigint> {}
			
 
				+//#endregion ArrayLike.at() end
			
 
				+
			
 
				+/**
			
 
				+ * @since v17.0.0
			
 
				+ *
			
 
				+ * Creates a deep clone of an object.
			
 
				+ */
			
 
				+declare function structuredClone<T>(
			
 
				+    value: T,
			
 
				+    transfer?: { transfer: ReadonlyArray<import('worker_threads').TransferListItem> },
			
 
				+): T;
			
 
				+
			
 
				+/*----------------------------------------------*
			
 
				+*                                               *
			
 
				+*               GLOBAL INTERFACES               *
			
 
				+*                                               *
			
 
				+*-----------------------------------------------*/
			
 
				+declare namespace NodeJS {
			
 
				+    interface CallSite {
			
 
				+        /**
			
 
				+         * Value of "this"
			
 
				+         */
			
 
				+        getThis(): unknown;
			
 
				+
			
 
				+        /**
			
 
				+         * Type of "this" as a string.
			
 
				+         * This is the name of the function stored in the constructor field of
			
 
				+         * "this", if available.  Otherwise the object's [[Class]] internal
			
 
				+         * property.
			
 
				+         */
			
 
				+        getTypeName(): string | null;
			
 
				+
			
 
				+        /**
			
 
				+         * Current function
			
 
				+         */
			
 
				+        getFunction(): Function | undefined;
			
 
				+
			
 
				+        /**
			
 
				+         * Name of the current function, typically its name property.
			
 
				+         * If a name property is not available an attempt will be made to try
			
 
				+         * to infer a name from the function's context.
			
 
				+         */
			
 
				+        getFunctionName(): string | null;
			
 
				+
			
 
				+        /**
			
 
				+         * Name of the property [of "this" or one of its prototypes] that holds
			
 
				+         * the current function
			
 
				+         */
			
 
				+        getMethodName(): string | null;
			
 
				+
			
 
				+        /**
			
 
				+         * Name of the script [if this function was defined in a script]
			
 
				+         */
			
 
				+        getFileName(): string | null;
			
 
				+
			
 
				+        /**
			
 
				+         * Current line number [if this function was defined in a script]
			
 
				+         */
			
 
				+        getLineNumber(): number | null;
			
 
				+
			
 
				+        /**
			
 
				+         * Current column number [if this function was defined in a script]
			
 
				+         */
			
 
				+        getColumnNumber(): number | null;
			
 
				+
			
 
				+        /**
			
 
				+         * A call site object representing the location where eval was called
			
 
				+         * [if this function was created using a call to eval]
			
 
				+         */
			
 
				+        getEvalOrigin(): string | undefined;
			
 
				+
			
 
				+        /**
			
 
				+         * Is this a toplevel invocation, that is, is "this" the global object?
			
 
				+         */
			
 
				+        isToplevel(): boolean;
			
 
				+
			
 
				+        /**
			
 
				+         * Does this call take place in code defined by a call to eval?
			
 
				+         */
			
 
				+        isEval(): boolean;
			
 
				+
			
 
				+        /**
			
 
				+         * Is this call in native V8 code?
			
 
				+         */
			
 
				+        isNative(): boolean;
			
 
				+
			
 
				+        /**
			
 
				+         * Is this a constructor call?
			
 
				+         */
			
 
				+        isConstructor(): boolean;
			
 
				+    }
			
 
				+
			
 
				+    interface ErrnoException extends Error {
			
 
				+        errno?: number | undefined;
			
 
				+        code?: string | undefined;
			
 
				+        path?: string | undefined;
			
 
				+        syscall?: string | undefined;
			
 
				+    }
			
 
				+
			
 
				+    interface ReadableStream extends EventEmitter {
			
 
				+        readable: boolean;
			
 
				+        read(size?: number): string | Buffer;
			
 
				+        setEncoding(encoding: BufferEncoding): this;
			
 
				+        pause(): this;
			
 
				+        resume(): this;
			
 
				+        isPaused(): boolean;
			
 
				+        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean | undefined; }): T;
			
 
				+        unpipe(destination?: WritableStream): this;
			
 
				+        unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
			
 
				+        wrap(oldStream: ReadableStream): this;
			
 
				+        [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
			
 
				+    }
			
 
				+
			
 
				+    interface WritableStream extends EventEmitter {
			
 
				+        writable: boolean;
			
 
				+        write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
			
 
				+        write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
			
 
				+        end(cb?: () => void): this;
			
 
				+        end(data: string | Uint8Array, cb?: () => void): this;
			
 
				+        end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
			
 
				+    }
			
 
				+
			
 
				+    interface ReadWriteStream extends ReadableStream, WritableStream { }
			
 
				+
			
 
				+    interface RefCounted {
			
 
				+        ref(): this;
			
 
				+        unref(): this;
			
 
				+    }
			
 
				+
			
 
				+    type TypedArray =
			
 
				+        | Uint8Array
			
 
				+        | Uint8ClampedArray
			
 
				+        | Uint16Array
			
 
				+        | Uint32Array
			
 
				+        | Int8Array
			
 
				+        | Int16Array
			
 
				+        | Int32Array
			
 
				+        | BigUint64Array
			
 
				+        | BigInt64Array
			
 
				+        | Float32Array
			
 
				+        | Float64Array;
			
 
				+    type ArrayBufferView = TypedArray | DataView;
			
 
				+
			
 
				+    interface Require {
			
 
				+        (id: string): any;
			
 
				+        resolve: RequireResolve;
			
 
				+        cache: Dict<NodeModule>;
			
 
				+        /**
			
 
				+         * @deprecated
			
 
				+         */
			
 
				+        extensions: RequireExtensions;
			
 
				+        main: Module | undefined;
			
 
				+    }
			
 
				+
			
 
				+    interface RequireResolve {
			
 
				+        (id: string, options?: { paths?: string[] | undefined; }): string;
			
 
				+        paths(request: string): string[] | null;
			
 
				+    }
			
 
				+
			
 
				+    interface RequireExtensions extends Dict<(m: Module, filename: string) => any> {
			
 
				+        '.js': (m: Module, filename: string) => any;
			
 
				+        '.json': (m: Module, filename: string) => any;
			
 
				+        '.node': (m: Module, filename: string) => any;
			
 
				+    }
			
 
				+    interface Module {
			
 
				+        /**
			
 
				+         * `true` if the module is running during the Node.js preload
			
 
				+         */
			
 
				+        isPreloading: boolean;
			
 
				+        exports: any;
			
 
				+        require: Require;
			
 
				+        id: string;
			
 
				+        filename: string;
			
 
				+        loaded: boolean;
			
 
				+        /** @deprecated since v14.6.0 Please use `require.main` and `module.children` instead. */
			
 
				+        parent: Module | null | undefined;
			
 
				+        children: Module[];
			
 
				+        /**
			
 
				+         * @since v11.14.0
			
 
				+         *
			
 
				+         * The directory name of the module. This is usually the same as the path.dirname() of the module.id.
			
 
				+         */
			
 
				+        path: string;
			
 
				+        paths: string[];
			
 
				+    }
			
 
				+
			
 
				+    interface Dict<T> {
			
 
				+        [key: string]: T | undefined;
			
 
				+    }
			
 
				+
			
 
				+    interface ReadOnlyDict<T> {
			
 
				+        readonly [key: string]: T | undefined;
			
 
				+    }
			
 
				+}
			
--- a/Asistent/node_modules/@types/node/globals.global.d.ts
+++ b/Asistent/node_modules/@types/node/globals.global.d.ts
@@ -0,0 +1 @@
 
				+declare var global: typeof globalThis;
		`@@ -0,0 +1 @@`
		`+Subproject commit d67c6d16572b2b2bf192d347aa913de3b988d8e1`