@grey-ts/types 1.3.0 → 1.4.0

package/dist/index.d.ts

@@ -1,51 +1,212 @@
 declare namespace GreyHack {
     interface Coin {
         classID: "coin";
-        createSubWallet(walletID: string, pin: string, subwalletUser: string, subwalletPassword: string): string | true | null;
+        /**
+         * Registers a new account in the coin that can be used to manage services such as stores.
+         *
+         * It is necessary to provide the PIN of the owner's wallet that wants to register.
+         *
+         * In case of success, the method will return true. In case of an error, a string with the details is returned.
+         */
+        createSubWallet(walletID: string, pin: string, subwalletUser: string, subwalletPassword: string): string | true;
+        /** Returns the configured address that will be shown to users who do not have the currency, indicating where they have to register.
+         *
+         * In case of an error, it returns a string with details.
+         */
         getAddress(): string;
+        /**
+         * Returns a number representing the defined interval in which each user receives a coin reward when mining.
+         *
+         * In case of failure, the method will return a string with details.
+         */
         getCycleMining(): number | string;
+        /**
+         * Returns a number representing the amount of coins that have been mined so far.
+         *
+         * In case of an error, it returns a string with details.
+         */
         getMinedCoins(): number | string;
+        /**
+         * Returns a number representing the amount of coins that will be received as a reward after each mining cycle.
+         *
+         * In case of failure, the method will return a string with details.
+         */
         getReward(): number | string;
-        getSubwallet(subwalletUser: string): SubWallet | string | null;
+        /**
+         * Returns a {@link SubWallet} on success.
+         *
+         * In case of error, it returns a string with the details.
+         */
+        getSubwallet(subwalletUser: string): SubWallet | string;
+        /**
+         * Returns an array where each item is a {@link SubWallet}, including all the accounts registered in the cryptocurrency.
+         *
+         * In case of error, it returns a string with the details.
+         */
         getSubwallets(): SubWallet[] | string;
+        /** Resets the password of the coin. It returns true if resetting was successful; otherwise, it will return a string. */
         resetPassword(newPassword: string): true | string;
-        setAddress(address: string): true | string | null;
-        setCycleMining(rateHours: number): true | string | null;
-        setReward(coinAmount: number): true | string | null;
-        transaction(subwalletFrom: string, subwalletTo: string, amount: number): true | string | null;
+        /**
+         * Configures a valid address that will be shown to users who do not have the currency, indicating where to register.
+         *
+         * In case of an error, it returns a string with the details. In case of success, true will be returned.
+         */
+        setAddress(address: string): true | string;
+        /**
+         * Defines the interval (in-game hours) in which each user receives a coin reward when mining.
+         *
+         * The interval cannot be lower than 1 and not higher than 2160.
+         *
+         * On success, it will return true. In case of failure, the method will return a string with details.
+         */
+        setCycleMining(rateHours: number): true | string;
+        /**
+         * Assigns the reward that miners will receive after each mining cycle. The reward value has to be above one.
+         *
+         * On success, it will return true. In case of failure, the method will return a string with details.
+         */
+        setReward(coinAmount: number): true | string;
+        /**
+         * Facilitates a transaction of the currency between the indicated subwallets.
+         *
+         * In case of an error, a string with the details is returned. In case of success, true will be returned.
+         */
+        transaction(subwalletFrom: string, subwalletTo: string, amount: number): true | string;
     }
     interface SubWallet {
         classID: "subwallet";
-        walletUsername(): string;
+        /** Returns a boolean indicating if the credentials are correct. For some cases, this method will return a string with an error message. */
         checkPassword(password: string): true | string;
+        /** Returns a string with the name of the wallet to which this subwallet belongs. */
+        walletUsername(): string;
+        /** Deletes the account registered in the cryptocurrency.
+         *
+         * Returns a boolean indicating if the deletion was successful. In case of certain failures, this method may return a string with details.
+         */
         delete(): boolean | string;
+        /** Returns a number of coins of a given currency. In case of error, a string with the details is returned. */
         getBalance(): number | string;
+        /** Returns a string with the information stored by the coin creator. */
         getInfo(): string;
+        /** Returns a string with the username associated with this subwallet. On failure, this method returns a string with an error message. */
         getUser(): string;
+        /**
+         * Returns a list with the information of the last transaction.
+         *
+         * Index 0 is a string with the other subWallet. Index 1 is an integer with the amount. Index 2 is a number indicating the direction of the transaction (0 for Deposit, 1 for Withdrawal). Index 3 is a string indicating the date of the transaction.
+         *
+         * On failure, this method will either return false or a string with an error message.
+         */
         lastTransaction(): [string, number, 0 | 1, string] | false | string;
+        /**
+         * Starts the process of mining the cryptocurrency. The process leaves the terminal busy until a coin is mined.
+         *
+         * On success, this method will return true. On failure, this method will return a string with details.
+         */
         mining(): true | string;
+        /**
+         * Stores optional information in the Subwallet for any use.
+         *
+         * Upon success, true will be returned. In case of failure, a string with details will be returned.
+         */
         setInfo(info: string): true | string;
     }
     interface Wallet {
         classID: "wallet";
+        /**
+         * Publishes a purchase offer indicating the number of coins you wish to buy and the price ($) per unit you are willing to pay.
+         *
+         * The purchase will be finalized if there is any sale offer with a price less than or equal to the one proposed in the purchase.
+         *
+         * If there is no eligible offer to sell at that time, the offer to buy will remain publicly visible until a new offer to sell satisfies the requirements.
+         *
+         * If the publication has been successful, true is returned. In case of error, a string with the details is returned.
+         */
         buyCoin(coinName: string, coinAmount: number, unitPrice: number, subwalletUser: string): true | string;
-        cancelPendingTrade(coinName: string): string | null;
-        getBalance(coinName: string): number | string | null;
-        getGlobalOffers(coinName: string): string | Record<string, [string, number, number]> | null;
-        getPendingTrade(coinName: string): string | Record<string, [string, number, number]> | null;
+        /**
+         * Cancel any pending offer of a certain coin.
+         *
+         * On success, an empty string will be returned. On failure, a string with an error message will be returned.
+         */
+        cancelPendingTrade(coinName: string): string;
+        /** Returns a number of coins of a given currency. In case of error, a string with the details is returned. */
+        getBalance(coinName: string): number | string;
+        /**
+         * Returns a record with all the offers made by any player of a given currency.
+         *
+         * The key of the record represents the WalletID of the player who has made the offer, and the value of the record is an array where index 0 represents the type of offer with a string (Buy/Sell), index 1 represents the amount to sell or buy, and index 2 represents the price per unit.
+         *
+         * In case of failure, this method returns a string with details.
+         */
+        getGlobalOffers(coinName: string): string | Record<"Buy" | "Sell", [string, number, number]>;
+        /**
+         * Returns an array with the pending sale or purchase offer of this wallet for a certain currency.
+         *
+         * Index 0 of the array represents the type of offer with a string (Buy/Sell), index 1 represents the quantity to be sold or bought, and index 2 represents the price per unit.
+         *
+         * On failure, this method will return a string with details.
+         */
+        getPendingTrade(coinName: string): ["Buy" | "Sell", number, number] | string;
+        /** Returns a string with a PIN that refreshes every few minutes. This PIN is used to obtain an account in cryptocurrency services. */
         getPin(): string;
+        /**
+         * Returns a list where each item is a string with the names of the coins available in the wallet.
+         *
+         * On failure this method returns a string with an error message.
+         */
         listCoins(): string[] | string;
+        /**
+         * Returns a list where each item is a string containing the names of all the currencies that exist.
+         *
+         * In case of failure, this method returns a string with details.
+         */
         listGlobalCoins(): string[] | string;
-        resetPassword(newPassword: string): true | string | null;
+        /**
+         * Change the password of the wallet. Only the account owner can perform this action.
+         *
+         * If the process is completed successfully, true will be returned. In case of an error, a string with details will be returned.
+         */
+        resetPassword(newPassword: string): true | string;
+        /**
+         * Publishes a sale offer indicating the amount of coins you want to sell and the price ($) per unit you want to assign.
+         *
+         * The sale will be finalized if there is any purchase offer with a price greater than or equal to that proposed in the sale. If there is no existing offer to buy that matches the requirements at that time, the offer to sell will remain publicly visible until a new offer to buy satisfies the requirements.
+         *
+         * If the publication has been successful, true is returned. In case of error, a string with the details is returned.
+         */
         sellCoin(coinName: string, coinAmount: number, unitPrice: number, subwalletUser: string): true | string;
-        showNodes(coinName: string): string | number | null;
+        /**
+         * Returns a number representing the count of devices mining a specific coin for the same wallet.
+         *
+         * In case of an error, a string with details is returned.
+         */
+        showNodes(coinName: string): string | number;
     }
 }
 declare namespace GreyHack {
     interface BaseComputer<FileType extends GreyHack.File | GreyHack.FtpFile> {
         classID: "ftpComputer" | "computer";
+        /** Returns the hostname of the machine. */
         getName: () => string;
-        createFolder: (path: string, folderName?: string) => string | boolean;
+        /**
+         * Creates a folder at the path provided in the arguments.
+         *
+         * There are certain limitations to creating a folder: the folder name has to be alphanumeric and below 128 characters. Creation will fail if there is already a folder in place or if there are lacking permissions. Additionally, there is a folder limit of about 250 in each folder and 3125 folders in the computer overall.
+         *
+         * In case the folder creation fails, the method will return a string with details. In case of success, it will return true.
+         *
+         * Using this method in an SSH encryption process will cause an error to be thrown, aborting further script execution.
+         */
+        createFolder: (path: string, folderName?: string) => string | true;
+        /**
+         * Returns a file located at the path provided in the argument.
+         *
+         * The path can be either relative or absolute. It's important to note that any file object can represent a folder as well.
+         *
+         * If the provided path cannot be resolved, meaning that no file or folder exists, this method will return null.
+         *
+         * Providing an empty string for the path will result in an error, interrupting the script execution.
+         */
         file: (path: string) => FileType | null;
     }
     interface FtpComputer extends BaseComputer<FtpFile> {
@@ -53,95 +214,387 @@ declare namespace GreyHack {
     }
     interface Computer extends BaseComputer<File> {
         classID: "computer";
+        /** The local IP address of the computer */
         localIp: string;
+        /** The public IP address of the computer */
         publicIp: string;
-        activeNetCard: () => string;
-        changePassword: (username: string, password: string) => boolean | string | null;
-        closeProgram: (pid: number) => boolean | string | null;
+        /** Returns `WIFI` or `ETHERNET` depending on the connection type the computer is currently using */
+        activeNetCard: () => "WIFI" | "ETHERNET";
+        /**
+         * Changes the password of an existing user on the computer.
+         *
+         * Root access is necessary to successfully change the password. Passwords can only include alphanumeric characters and cannot exceed 15 characters. If the password change fails, this method will return a string containing information on why it failed. If the change succeeds, it will return true.
+         *
+         * If the provided username is empty, an error will be thrown, preventing any further script execution.
+         */
+        changePassword: (username: string, password: string) => boolean | string;
+        /**
+         * Closes a program associated with the provided PID.
+         *
+         * You can see the list of active programs by either using {@link showProcs} or typing ps into your terminal. To close a program, you need to either be the owner of the running process or root. If closing the program fails, this method will return a string containing details. On success, it will return true. If there is no process with the provided PID, this method will return false.
+         */
+        closeProgram: (pid: number) => boolean | string;
+        /**
+         * Sets up a new IP address on the computer through the Ethernet connection.
+         *
+         * It's not possible to set up a new IP address while being logged in as a guest. On failure, this method will either return a string with details or null. On success, it will return an empty string.
+         *
+         * If the computer is not connected to the internet, an error will be thrown, preventing any further script execution.
+         */
         connectEthernet: (netDevice: netDevice, address: string, gateway: string) => string | null;
-        connectWifi: (netDevice: netDevice, bssid: string, essid: string, password: string) => boolean | string | null;
-        createGroup: (username: string, group: string) => boolean | string | null;
-        createUser: (username: string, password: string) => boolean | string | null;
-        deleteGroup: (username: string, group: string) => boolean | string | null;
-        deleteUser: (username: string, removeHome?: boolean) => boolean | string | null;
+        /**
+         * Connects to the indicated Wi-Fi network.
+         *
+         * It's not possible to connect to a new Wi-Fi while being logged in as a guest. If connecting to a new Wi-Fi fails, this method will return a string containing details. On success, it will return true.
+         *
+         * Wi-Fi networks can be found via {@link wifiNetworks} or by typing iwlist as a command in the terminal.
+         */
+        connectWifi: (netDevice: netDevice, bssid: string, essid: string, password: string) => true | string;
+        /**
+         * Creates a new group associated with an existing user on the computer.
+         *
+         * Root access is necessary to successfully create a group. There are limitations when creating a group, such as a character limit of 15 and that the group name may only contain alphanumeric characters. If the group creation fails, this method will return a string containing the cause of failure. On success, it will return true. If the provided arguments are empty or the username exceeds 15 characters, an error will be thrown, interrupting further script execution.
+         */
+        createGroup: (username: string, group: string) => true | string;
+        /**
+         * Creates a user on the computer with the specified name and password.
+         *
+         * Root access is necessary to successfully create a user. Both the username and password cannot exceed more than 15 characters and must be alphanumeric. There cannot be more than 15 users created on the same computer. If the creation fails, this method will return a string containing the reason for the failure. On success, it will return true. If the provided username is empty or either of the values exceeds 15 characters, an error will be thrown, interrupting further script execution.
+         */
+        createUser: (username: string, password: string) => true | string;
+        /**
+         * Deletes an existing group associated with an existing user on the computer.
+         *
+         * Root access is necessary to successfully delete a group. If the group deletion fails, this method will return a string containing the cause of failure. On success, it will return true. If either of the provided values is empty, an error will be thrown, preventing further script execution.
+         */
+        deleteGroup: (username: string, group: string) => true | string;
+        /**
+         * Deletes the indicated user from the computer.
+         *
+         * Root access is necessary to successfully delete a user. Keep in mind that you cannot delete the root user.
+         *
+         * If the deletion fails, this method will return a string containing the cause of failure. On success, it will return true. If the provided username is empty, an error will be thrown, interrupting further script execution.
+         *
+         * @param username the user to remove
+         * @param removeHome remove the user's home folder as well
+         */
+        deleteUser: (username: string, removeHome?: boolean) => true | string;
+        /** Returns an array of ports on the computer that are active. */
         getPorts: () => Port[];
-        groups: (username: string) => string | null;
+        /**
+         * Returns a string containing groups associated with an existing user on the computer.
+         *
+         * If the user does not exist, a string with an error message will be returned. If the provided username is empty, an error will be thrown, preventing further script execution.
+         */
+        groups: (username: string) => string;
+        /** Returns a boolean indicating if the computer has internet access */
         isNetworkActive: () => boolean;
+        /**
+         * Returns a string containing information about all network devices available on the computer.
+         *
+         * Each item includes details about the interface name, chipset, and whether monitoring support is enabled.
+         */
         networkDevices: () => string;
+        /** Returns a string with the gateway IP address configured on the computer. */
         networkGateway: () => string;
-        reboot: (safeMode?: boolean) => boolean | string | null;
+        /**
+         * Reboots the computer. By default, it reboots in standard mode.
+         *
+         * On success, the method returns true. If the reboot fails, a descriptive error message is returned as a string.
+         *
+         * Calling this method in an SSH encryption process will trigger an error, halting further script execution.
+         *
+         * @param safeMode reboot the system in safe mode instead
+         */
+        reboot: (safeMode?: boolean) => true | string;
+        /**
+         * Returns a string with an overview of all active processes on the computer, including information about the user, PID, CPU, memory, and command.
+         *
+         * Using this method in an SSH encryption process will cause an error to be thrown, preventing any further script execution.
+         */
         showProcs: () => string;
-        touch: (destFolder: string, fileName: string) => boolean | string;
+        /**
+         * Creates an empty text file at the provided path.
+         *
+         * Certain limitations apply to file creation: the file name must be alphanumeric and below 128 characters. Creation will fail if there is already a file in place or if permissions are lacking. Additionally, there is a file limit of about 250 in each folder and 3125 files in the computer overall.
+         *
+         *
+         *
+         * Using this method in an SSH encryption process will cause an error to be thrown, preventing any further script execution.
+         */
+        touch: (destFolder: string, fileName: string) => true | string;
+        /**
+         * Returns a list of the Wi-Fi networks that are available for the provided interface.
+         *
+         * Each item in the list is a string containing information on the BSSID, PWR, and ESSID.
+         *
+         * If the active network card is not a Wi-Fi card, an error will be thrown, preventing any further script execution.
+         *
+         * @returns true on success
+         * @returns string with details on failure
+         * @returns null if no matching netDevice can be found
+         */
         wifiNetworks: (netDevice: netDevice) => string[] | null;
-        getName: () => string;
-        createFolder: (path: string, folderName?: string) => string | boolean;
     }
 }
 declare namespace GreyHack {
     interface FtpFile extends BaseFile {
         classID: "ftpFile";
+        /** The parent folder of the current file or folder */
         parent: FtpFile | null;
+        /**
+         * Returns an array of files inside this folder.
+         *
+         * In case the current entity is a file instead of a folder this method will return null, so it is advisable to first use the isFolder function before calling this method. In case the current folder gets deleted this method will return null as well.
+         */
         getFiles: () => FtpFile[] | null;
+        /**
+         * Returns an array of folders inside this folder.
+         *
+         * In case the current entity is a file instead of a folder this method will return null, so it is advisable to first use the isFolder function before calling this method. In case the current folder gets deleted this method will return null as well.
+         */
         getFolders: () => FtpFile[] | null;
     }
     interface File extends BaseFile {
         classID: "file";
+        /** The parent folder of the current file or folder */
         parent: File | null;
+        /** Indicates if the file is a binary and can be imported by other scripts */
         allowImport: boolean;
+        /**
+         * Returns an array of files inside this folder.
+         *
+         * In case the current entity is a file instead of a folder this method will return null, so it is advisable to first use the isFolder function before calling this method. In case the current folder gets deleted this method will return null as well.
+         */
         getFiles: () => File[] | null;
+        /**
+         * Returns an array of folders inside this folder.
+         *
+         * In case the current entity is a file instead of a folder this method will return null, so it is advisable to first use the isFolder function before calling this method. In case the current folder gets deleted this method will return null as well.
+         */
         getFolders: () => File[] | null;
+        /**
+         * Modifies the file permissions.
+         *
+         * The format for applying permissions is as follows: `[references][operator][modes]`. The references type is defined through three possible types: user `u`, group `g`, and other `o`. The operator is used to define if permissions get added "+" or removed "-". There are three different modes that can be modified: read `r`, write `w`, and execute `x`. So, for example, `o-wrx` would remove all possible permissions for others. To add all permissions for others again, `o+wrx` would be used.
+         *
+         * In case the modification fails, this method will return a string containing information about the reason. Otherwise, an empty string is returned.
+         *
+         * @param recursive set the permissions recursively to every file inside this folder
+         */
         chmod: (perms: string, recursive?: boolean) => string;
+        /**
+         * Returns a string representing the content of the file. To read a file, the user requires read access or being root.
+         *
+         * Note that you cannot read a binary file. In case of failure, null will be returned.
+         *
+         * If this method is used within an SSH encryption process, an error will be thrown, preventing any further script execution.
+         */
         getContent: () => string | null;
+        /**
+         * Saves text into a file. The content will not get appended to the file; therefore, existing content will be overridden.
+         *
+         * To set new content, the user requires write permissions or being root. Keep in mind that text files cannot exceed the character limit of 160,000. In case setting the content was successful, true will be returned. Otherwise, a string with details will be returned.
+         *
+         * If this method is used within an SSH encryption process, an error will be thrown, preventing any further script execution. If the permissions are lacking, this method will return false. In case the file gets deleted this method will return null.
+         */
         setContent: (content: string) => string | boolean | null;
+        /**
+         * Change the group related to this file.
+         *
+         * The group name cannot exceed 15 characters. Additionally either write permissions or being root is required. In case of failure, a string with details. On success, an empty string gets returned. In case the current file gets deleted, this method will return null.
+         *
+         * If the passed group value is empty, the group value is longer than 15 characters, or the passed recursive value deviates from its original type, an error will be thrown, preventing further script execution.
+         *
+         * @param recursive set the group recursively to every file inside this folder
+         */
         setGroup: (group: string, recursive?: boolean) => string | null;
+        /**
+         * Change the owner of this file.
+         *
+         * The owner's name cannot exceed 15 characters. Additionally either write permissions or being root is required. In case of failure a string gets returned containing the cause. Otherwise an empty string gets returned. In case the current file gets deleted, this method will return null.
+         *
+         * If the passed owner value is empty, the owner value is longer than 15 characters, or the passed recursive value deviates from its original type, an error will be thrown, interrupting further script execution.
+         *
+         * @param recursive set the owner recursively to every file inside this folder
+         */
         setOwner: (owner: string, recursive?: boolean) => string | null;
-        symlink: (path: string, newName?: string) => string | boolean | null;
+        /**
+         * Creates a symlink to the specified path.
+         *
+         * Symlinks can only be created if the user has write permissions or is root. The new filename must be alphanumeric and under 128 characters. Upon success, this method returns true. On failure, it returns a string with details.
+         *
+         * If used within an SSH encryption process, if the new name exceeds 128 characters, or if the path is too long, an error will be thrown, interrupting script execution. If the current file is deleted, this method will return null.
+         */
+        symlink: (path: string, newName?: string) => true | string | null;
     }
     interface BaseFile {
         classID: "ftpFile" | "file";
+        /** The name of the file. Is null if the file gets deleted before accessing this */
         name: string | null;
-        group: string;
+        /** The name of the group this file belongs to. Is null if the file gets deleted before accessing this */
+        group: string | null;
+        /** The name of the file owner. Is null if the file gets deleted before accessing this */
         owner: string | null;
+        /**
+         * The permissions of the file. Is null if the file gets deleted before accessing this
+         *
+         * The format for this permissions string is as follows: `[fileType][wrx](u)[wrx](g)[wrx](o)`. The file type is either `d` in case it's a directory or `-`. The user type gets defined through three possible types: user `u`, group `g`, and other `o`. There are three different permission types: read `r`, write `w`, and execute `x`. An example of a string returned by this method would be `-rwxr-xr-x`.
+         */
         permissions: string | null;
+        /**
+         * The size of the file in bytes. Is null if the file gets deleted before accessing this
+         *
+         * There is no correlation between file size and actual file content. Instead, the file size is depending on the name of the file
+         */
         size: string | null;
+        /**
+         * Copies the file to the provided path.
+         *
+         * Files can only be copied if the user has read and write permissions or is root. The new filename has to be below 128 characters and alphanumeric. After success, this method will return true. Otherwise, it will return a string containing information about the reason for failure.
+         *
+         * If this method is used within an SSH encryption process, the new name exceeds 128 characters, or the path is too long, an error will be thrown, causing an interruption of script execution. In case the current file gets deleted, this method will return null.
+         */
         copy: (destFolder?: string, newName?: string) => string | boolean | null;
+        /**
+         * Delete the current file.
+         *
+         * To delete files, write permissions are required or being root. In case of failure, a string with details will be returned. Otherwise, an empty string gets returned.
+         *
+         * Note that deleting a file will leave a log entry.
+         */
         delete: () => string;
+        /** Returns a boolean indicating if the user who launched the script has the requested permissions.
+         *
+         * In case the file gets deleted, this method will return null instead.
+         */
         hasPermission: (perms: "r" | "w" | "x") => boolean | null;
+        /** Returns a boolean indicating if the file is a binary. Returns null if the file gets deleted */
         isBinary: () => boolean | null;
+        /** Returns a boolean indicating if the file is a folder. Returns null if the file gets deleted */
         isFolder: () => boolean | null;
+        /** Returns a boolean indicating if the file is a symlink. Returns null if the file gets deleted */
         isSymlink: () => boolean | null;
+        /**
+         * Moves the file to the provided path.
+         *
+         * Files can only be moved if the user has read and write permissions or is root. The new filename has to be below 128 characters and alphanumeric. After success, this method will return true. Otherwise, this method will return a string with details.
+         *
+         * If this method is used within an SSH encryption process, the new name exceeds 128 characters, or the path is too long, an error will be thrown, causing an interruption of script execution. In case the current file gets deleted, this method will return null.
+         */
         move: (destFolder: string, newName?: string) => string | boolean | null;
+        /**
+         * Returns a string containing the file path. If the file has been deleted, this method will still return the path it had prior to deletion.
+         * @param symLinkOriginalPath return the original path of the linked file instead
+         */
         path: (symLinkOriginalPath?: boolean) => string;
-        rename: (name: string) => string | boolean;
+        /**
+         * Rename the file with the name provided.
+         *
+         * Files can only be renamed if the user has write permissions or is root. The new filename has to be below 128 characters and alphanumeric. On failure, this method will return a string with details. Otherwise, this method will return an empty string.
+         *
+         * If this method is used within an SSH encryption process, an error will be thrown, causing the script execution to be interrupted.
+         */
+        rename: (name: string) => string;
     }
 }
+/** Provides access to global variables of this script */
 declare var globals: any;
 /** The parameters given to this script on launch */
 declare var params: string[];
 declare namespace GreyHack {
-    function abs(value: number): number;
-    function acos(value: number): number;
+    /** Returns a string with the name of the user who is executing the current script. */
     function activeUser(): string;
-    function asin(value: number): number;
-    function atan(y: number, x?: number): number;
+    /** Performs a bitwise AND for the provided values. Warning: If either operand is >= `0x80000000`, it'll always return 0. */
     function bitAnd(a: number, b: number): number;
+    /** Performs a bitwise OR for the provided values. Warning: If either operand is >= `0x80000000`, it'll always return 0. */
     function bitOr(a: number, b: number): number;
+    /** Performs a bitwise XOR for the provided values. Warning: If either operand is >= `0x80000000`, it'll always return 0. */
     function bitXor(a: number, b: number): number;
-    function bitwise(operator: "~" | "&" | "|" | "^" | "<<" | ">>" | ">>>", a: number, b?: number): number;
+    /**
+     * Returns a number by performing bitwise operations.
+     *
+     * Warning: If either operand is >= `0x80000000`, it'll always returns 0.
+     */
+    function bitwise(operator: "~", a: number): number;
+    function bitwise(operator: "&" | "|" | "^" | "<<" | ">>" | ">>>", a: number, b: number): number;
+    /**
+     * Changes the current working directory of the active shell to the specified path.
+     *
+     * On success, an empty string is returned. If the operation fails, a descriptive error message is returned as a string.
+     *
+     * If this method is invoked during an SSH encryption process, a runtime error is thrown and further script execution is halted.
+     */
     function cd(path: string): string;
-    function ceil(value: number): number;
+    /**
+     * Returns the UTF-16 character string related to the provided unicode number.
+     *
+     * The provided number needs to be between 0 and 65535. Any number which is outside this range will cause the script to throw a runtime error.
+     *
+     * Beware when passing non-ASCII values to intrinsics as they will likely get re-encoded as UTF-8. For example, `md5(char(255))` will actually return the hash of the two-byte sequence `0xC3 0xBF`.
+     */
     function char(code: number): string;
+    /**
+     * Removes any text existing in a Terminal prior to this point.
+     *
+     * Utilizing this method in an SSH encryption process will trigger an error, halting further script execution.
+     */
     function clearScreen(): null;
+    /** Returns the Unicode number of the first character of the string. In case an empty string is provided the script execution will crash. */
     function code(char: string): number;
+    /**
+     * Returns a string value of a translation. Translations include commands, documentation and other game-related things.
+     *
+     * Checkout {@link https://github.com/LoadingHome/Grey-Texts/blob/main/EnglishLang.json|Grey-Texts} for an overview of all available keys.
+     *
+     * If the provided command name is empty this method will throw an error causing the script to stop.
+     */
     function commandInfo(commandName: string): string;
-    function cos(value: number): number;
+    /**
+     * Returns a string containing the current date and time. Ingame time passes 15 times as fast as real-time - 4 seconds per in-game minute.
+     *
+     * The initial time after every wipe will be the 1st of January 2000 at 6:00 AM. Additionally, the game time will not proceed while the server is offline.
+     *
+     * Output schema: `[day]/[month]/[year] - [hours]:[minutes]`
+     *
+     * Example output: `27/Jan/2000 - 08:19`
+     */
     function currentDate(): string;
+    /** Returns a string with the current active working directory. The working directory can be changed via the `cd` command. */
     function currentPath(): string;
+    /**
+     * Stops execution of the currently running script.
+     *
+     * Optionally a message can be provided which will be shown in the Terminal. There is also the possibility of styling output by using {@link https://docs.unity3d.com/Packages/com.unity.textmeshpro@4.0/manual/index.html|TextMeshPro rich-text tags}.
+     */
     function exit(message?: string): never;
-    function floor(value: number): number;
+    /**
+     * Returns a string which is the formatted version of the provided text.
+     *
+     * Keep in mind that {@link https://docs.unity3d.com/Packages/com.unity.textmeshpro@4.0/manual/index.html|TextMeshPro rich-text tags} might screw up the output. When using tags consider applying these after formatting.
+     */
     function formatColumns(columns: string): string;
+    /**
+     * Returns the absolute path of the given path string.
+     *
+     * If the path is already absolute, it is returned unchanged. Otherwise, it is resolved against the current working path by default, or against the provided base path if specified.
+     *
+     * If the path exceeds 1024 characters, the base path exceeds 64 characters, a runtime exception is thrown.
+     */
     function getAbsPath(path: string, basePath?: string): string;
+    /**
+     * Returns {@link CtfEvent} if there is one available.
+     *
+     * In case of failure this method will return a string with details.
+     */
     function getCtf(user: string, password: string, eventName: string): CtfEvent | string;
+    /**
+     * Returns an object which is shared throughout script execution.
+     *
+     * Can be helpful if it desired to pass or receive values when using {@link Shell.launch}.
+     *
+     * Using this method in a SSH encryption process will cause an error to be thrown preventing further script execution.
+     */
     function getCustomObject<T = object>(): T & Record<string, any>;
     /** Returns by default the {@link Router router} to which the executing computer is connected to.
      *
@@ -171,38 +624,132 @@ declare namespace GreyHack {
      * if (switch) print("This device is a switch!");
      */
     function getSwitch(ip: string): Router | null;
+    /**
+     * Returns numeric hash for the provided data.
+     *
+     * Using this method within a SSH encryption process will cause an error to be thrown causing the script execution to stop.
+     */
     function hash(value: any): number;
+    /** Returns a string with the home folder path of the user who is executing the current script. */
     function homeDir(): string;
+    /** Enables to import code from different sources into one file. */
     function importCode(path: string): null;
+    /**
+     * Enables the inclusion of library binaries, which can be used inside your script.
+     *
+     * If successful, an object related to the provided library will be returned; otherwise, null is returned.
+     *
+     * This function is exclusively for importing library binaries. If you want to import custom scripts or binaries into your project, use {@link importCode} instead. That is only for files ingame. For files in your editor, use {@link include}
+     *
+     * Leaving the path empty will cause an error to be thrown, interrupting further script execution.
+     */
     function includeLib(path: string): LibTypes[keyof LibTypes] | null;
+    /** Returns a boolean indicating if the given IP is a valid LAN address */
     function isLanIp(ip: string): boolean;
+    /** Returns a boolean indicating if the given IP is valid */
     function isValidIp(ip: string): boolean;
+    /** Returns a string containing the path of the script that was initially executed, meaning that even when using {@link Shell.launch}, it will still return the path of the initially executed script. */
     function launchPath(): string;
-    function log(value: number, base?: number): number;
-    function mailLogin(user: string, pass: string): MetaMail | string | null;
+    /**
+     * Returns a {@link MetaMail} entity if the login was successful.
+     *
+     * On failure a string with details gets returned.
+     *
+     * Utilizing this method in an SSH encryption process will trigger an error, halting further script execution.
+     */
+    function mailLogin(user: string, pass: string): MetaMail | string;
+    /**
+     * Returns the MD5 hash string of the provided string.
+     *
+     * Using this method within an SSH encryption process will cause an error to be thrown, stopping any further script execution.
+     */
     function md5(value: string): string;
+    /**
+     * Returns the IP address for the provided web address.
+     *
+     * In case the web address cannot be found a string gets returned containing the following message: `Not found`.
+     *
+     * If the provided web address is empty this method will throw an error preventing further script execution.
+     */
     function nslookup(webAddress: string): string;
+    /**
+     * Returns a string which is the parent path of the provided path.
+     *
+     * The path provided needs to be properly formatted. If the path is empty, this method will throw an error interrupting further script execution.
+     */
     function parentPath(path: string): string;
-    function pi(): number;
+    /**
+     * Print a message on the Terminal.
+     *
+     * There is also the possibility of styling output by using {@link https://docs.unity3d.com/Packages/com.unity.textmeshpro@4.0/manual/index.html|TextMeshPro rich-text tags}.
+     *
+     * @param replaceText Clear the terminal before printing. This can be useful for creating a loading bar for example.
+     */
     function print(value: any, replaceText?: boolean): null;
+    /** Returns a string containing the path of the script that is currently executing. It will update when using {@link Shell.launch|launch}, which makes it different from {@link launchPath}. */
     function programPath(): string;
+    /**
+     * Generates an array where each item is a number. By default, if only one argument is provided, the list starts at the given value and decrements by one for each item.
+     *
+     * You can optionally define a start and end value, as well as customize the incremental value. However, if the incremental value is zero, or if the list exceeds `16777215L` items, the function will throw a runtime error.
+     */
     function range(start: number, end?: number, increment?: number): number[];
+    /**
+     * Resets the password of your CTF account.
+     *
+     * Returns true if resetting was successful; otherwise, it will return a string containing the reason for failure.
+     */
     function resetCtfPassword(newPassword: string): true | string;
-    function rnd(seed?: number): number;
-    function round(value: number, fixed?: number): number;
-    function sign(value: number): number;
-    function sin(value: number): number;
+    /**
+     * Returns a sliced version of the passed object.
+     *
+     * The returned object will contain all elements related to the provided start and end index. If no start or end index is provided this method will essentially return a shallow copy of the passed object.
+     */
     function slice<T extends Array<any> | string>(value: T, startIndex?: number, endIndex?: number): T extends string ? string : T;
-    function sqrt(value: number): number;
+    /** Returns the string value of provided data. */
     function str(value: any): string;
-    function tan(value: number): number;
+    /** Returns a number of seconds representing the elapsed time since the script started. */
     function time(): number;
+    /**
+     * Returns a string containing the bank account number of the player who is executing the script.
+     *
+     * If the user does not have a bank this method will return null.
+     */
     function userBankNumber(): string | null;
+    /**
+     * Pauses script execution to receive input from the user.
+     *
+     * The prompt message can include {@link https://docs.unity3d.com/Packages/com.unity.textmeshpro@4.0/manual/index.html|TextMeshPro rich-text tags} for styling. Input is submitted by pressing Enter.
+     *
+     * Using this function during an SSH encryption process will throw a runtime error and halt further script execution.
+     *
+     * @param message A message to display on the terminal
+     * @param isPassword hide what's being typed
+     * @param anyKey capture a single key press and return
+     * @param addToHistory saves the input to the input history, allowing it to be recalled with the arrow keys
+     */
     function userInput(message?: string, isPassword?: boolean, anyKey?: boolean, addToHistory?: boolean): string;
+    /**
+     * Returns a string containing the email address of the player who is executing the script.
+     *
+     * If the user does not have an email address this method will return null.
+     */
     function userMailAddress(): string | null;
-    function wait(seconds: number): null;
+    /**
+     * Pauses the script execution. Optionally, the duration can be provided via the time argument. By default, the duration will be 1 second.
+     *
+     * The duration cannot be below 0.01 or above 300; otherwise, this method will throw a runtime exception.
+     */
+    function wait(seconds?: number): null;
+    /**
+     * Returns a string containing the administrator information behind an IP address provided.
+     *
+     * In case of failure the returned string will contain an error message instead. If the provided ip is empty this method will throw an error causing the script to stop.
+     */
     function whois(ip: string): string;
+    /** Waits for the next tick. */
     function yield(): null;
+    /** Returns the type of the object */
     function getType(value: any): keyof GameTypeMap;
     /** Checks if the given object is of a specific type
      * @example
@@ -320,96 +867,359 @@ type GameTypeMap = ClassIDMap & OtherTypeMap;
 declare namespace GreyHack {
     interface Service {
         classID: "service";
+        /**
+         * Installs the necessary files for the correct functioning of the service and starts it.
+         *
+         * If the installation is completed successfully, it returns true. In case of an error, it returns a string with details.
+         */
         installService(): true | string;
+        /**
+         * Starts the service and opens its associated port on the local machine.
+         *
+         * The service requires a port forwarded to the router to be accessible from the outside.
+         *
+         * If the service starts correctly, it returns true. In case of an error, it returns a string with details.
+         */
         startService(): true | string;
-        stopService(): true | string;
+        /**
+         * Stops the service and closes its associated port on the local machine.
+         *
+         * If the service is stopped successfully, it returns true.
+         *
+         * If an error occurs during the process, it returns a string with details. In some cases, the returned value might be false, indicating that the service removal failed.
+         */
+        stopService(): boolean | string;
     }
     interface Metaxploit {
         classID: "MetaxploitLib";
+        /**
+         * Returns a {@link MetaLib} object for the provided path to the library binary. Keep in mind that this can only be used on library files.
+         *
+         * On failure, this method will return null. If the provided path is empty, this method will throw a runtime exception, preventing further script execution.
+         */
         load(path: string): MetaLib | null;
+        /**
+         * Returns a {@link NetSession} object for the provided IP address and port.
+         *
+         * Note that if the port is set to zero, it will return a {@link NetSession} related to the kernel router.
+         *
+         * The main purpose of this method is to gain a {@link NetSession} and then use {@link NetSession.dumpLib} to receive a {@link MetaLib} object to exploit vulnerabilities.
+         *
+         * In case of failure, this method will return null. If this method is used within an SSH encryption process or with disabled internet, or if an invalid target IP is provided, this method will throw a runtime exception. */
         netUse(ip: string, port: number): NetSession | null;
+        /**
+         * Launches a process on the victim's computer, silently attempting to continuously connect in the background to the specified address and port.
+         *
+         * For the reverse shell to run successfully, the rshell service must be installed, and the port forward must be configured correctly on the machine where the server is waiting for the victim's connection.
+         *
+         * If the launch was successful, true will be returned. In case of failure, a string with details will be returned.
+         */
         rshellClient(ip: string, port: number, processName?: string): true | string;
+        /** This method returns an array of {@link Shell} objects that have been reverse shell connected to this computer.
+         *
+         * To manage the connections received, the rshell service must be installed on the machine that receives the victims' connections.
+         *
+         * In case of failure a string will be returned with details. */
         rshellServer(): Shell[] | string;
+        /** Returns an array where each item is a string representing a memory area which has vulnerabilities related to the provided library.
+         *
+         * These memory areas can be used to make further scans via {@link Metaxploit.scanAddress}.
+         *
+         * In case of failure, this method returns null instead.
+         *
+         * An example of a memory area would be `0x7BFC1EAA`.
+         *
+         * Using this method within a SSH encryption process will throw a runtime exception. */
         scan(metaLib: MetaLib): string[] | null;
+        /**
+         * Returns a string containing information about each vulnerability in the provided library and memory area.
+         *
+         * In case the scanning fails this method will return null.
+         *
+         * Using this method within a SSH encryption process will throw a runtime exception.
+         */
         scanAddress(metaLib: MetaLib, memoryAddress: string): string | null;
+        /**
+         * The terminal listens to the network packets of any connection that passes through the computer.
+         *
+         * When any connection information gets captured, it will print a string with the obtained data.
+         *
+         * In case saving of encryption source is enabled it will download the source code of the script responsible for encryption.
+         *
+         * In case the operation fails this method will return null.
+         *
+         * Using this method within a SSH encryption process will throw a runtime exception.
+         */
         sniffer(saveEncSource?: boolean): string | null;
     }
     interface MetaLib {
         classID: "MetaLib";
+        /** The name of the library. An example of a name would be `init.so`. */
         libName: string;
+        /** Version number of the library. An example of a version number would be `1.0.0`. */
         version: string;
-        debugTools(user: string, password: string): string | DebugLibrary | null;
-        isPatched(getDate?: boolean): boolean | string | null;
+        /**
+         * Returns a library in debug mode as a {@link DebugLibrary} object.
+         *
+         * A valid Neurobox engineer's username and password are required to access this mode.
+         *
+         * If successful, the {@link DebugLibrary} object is returned; in case of an error, a string with details is provided. */
+        debugTools(user: string, password: string): DebugLibrary | string;
+        /**
+         * Returns by default a boolean indicating whether the library has been patched.
+         *
+         * True indicates that the library has been patched, while false indicates that it has not.
+         *
+         * If the getdate parameter is set to true, the function will return a string containing the date of the last patch. The data format is as follows: `dd/MM/yyyy`.
+         *
+         * Additionally if there is any error the return value will be a string.
+         */
+        isPatched(getDate?: boolean): boolean | string;
+        /**
+         * Exploits vulnerabilities in target systems by executing various attack vectors against libraries located in the `/lib` folder.
+         *
+         * The function requires a memory address, vulnerability identifier, and optional arguments that are mandatory for password changes (new password) and computer exploits (LAN IP address).
+         *
+         * The system validates that the target library exists and is properly located in the `/lib` directory before proceeding otherwise it will return null.
+         *
+         * If the network where the library is located is disabled, the function returns a string indicating the network status.
+         *
+         * The exploit will fail and return null if the target is behind a firewall or if any of the specific vulnerability requirements aren't met, such as insufficient registered users, missing required libraries with correct versions, inadequate port forwards, absence of required user types like active guests or root users, or invalid file paths.
+         *
+         * If the target vulnerability is identified as a zero-day exploit, the system will load the appropriate zero-day vulnerability before execution.
+         *
+         * During execution, if a super admin intercepts the exploit attempt, user privileges are automatically lowered to guest level.
+         *
+         * Shell exploits, once all requirements are met, always return a shell object.
+         *
+         * Random folder exploits return a file object if the specified path exists or null if the folder cannot be found.
+         *
+         * Password change exploits return true for successful password modification or false for failure due to guest user restrictions, invalid alphanumeric format, or exceeding the 15-character limit.
+         *
+         * Settings override exploits work only on smart appliances like fridges or microwaves and return true for success or false for failure.
+         *
+         * Traffic light exploits require targets on the police station's network and return true for success or false for failure.
+         *
+         * Firewall exploits need router targets and return true for success or false for failure.
+         *
+         * Computer exploits return a computer object when successful or false if the LAN IP is invalid, the computer doesn't exist, or no non-root user is available.
+         *
+         * Using {@link isType} or {@link getType} to verify return value types is essential before processing results due to the variety of possible return types.
+         */
         overflow(memoryAddress: string, unsecZone: string, optArgs?: string): Shell | Computer | File | string | boolean | null;
     }
     interface DebugLibrary {
         classID: "debugLibrary";
-        applyPatch(path: string): string | null;
-        payload<T extends string | undefined>(memZone: string, filePath?: T): string | null | (T extends string ? [Partial<Computer>, Partial<File>, MetaLib] : [Partial<Computer>]);
+        /** Applies a patch containing corrected code to the specified text file at the provided path.
+         *
+         * Returns a string with the result of the operation. */
+        applyPatch(path: string): string;
+        /** Returns a list containing a single partial computer object if zero-day vulnerabilities are detected within the specified memory zone.
+         *
+         * If a file path is provided, a partial file object associated with this path will also be included in the array.
+         *
+         * Additionally, if this file is a library, its corresponding metaLib object is added to the returned array.
+         *
+         * In case of an error, a string with details is returned. */
+        payload(memZone: string): string | [Partial<Computer>];
+        payload(memZone: string, filePath: string): string | [Partial<Computer>, Partial<File>] | [Partial<Computer>, Partial<File>, MetaLib];
+        /** Scans the library in debug mode to identify potential code errors that may lead to vulnerabilities.
+         *
+         * If issues are detected, the relevant code snippets are printed. In case of an error, a string containing the error message is returned. */
         scan(): string;
-        unitTesting(errorLines: number[]): string | null;
+        /** Conducts automated tests on the specified lines of code.
+         *
+         * If potential vulnerabilities are detected due to errors in these lines, this method will print partial objects that could be obtained by exploiting the vulnerability, along with the affected memory zone and detailed vulnerability information.
+         *
+         * In case of failure, this function returns a string with an error message. */
+        unitTesting(errorLines: number[]): string;
     }
     interface Crypto {
         classID: "cryptoLib";
+        /** Returns a string containing the password based on the file which was generated via aireplay.
+         *
+         * In case of failure, it will return null instead. If the provided path is empty, an error will be thrown, interrupting the script execution. */
         aircrack(path: string): string | null;
+        /** Used to inject frames on wireless interfaces.
+         *
+         * Once the command with `Control+C` is stopped, it will save the captured information in a text file called `file.cap` in the path where the terminal is currently located.
+         *
+         * Alternatively, a maximum of captured acks can be specified for the command to stop automatically, saving the `file.cap` file as described above.
+         *
+         * To figure out how many ACKs are required, you can use the following formula: `300000 / (Power + 15)`.
+         *
+         * If there is an error, a string will be returned with the message indicating the problem. On success, it will return null, it is advised though to verify that the capture file actually exists.
+         *
+         * In case any of the provided values deviate from the signature types or bssid/essid is empty, an error will be thrown preventing any further script execution. */
         aireplay(bssid: string, essid: string, maxAcks?: number): string | null;
+        /** Enables or disables the monitor mode of a network device.
+         *
+         * Monitor mode can only be enabled on Wifi cards.
+         *
+         * If it wasn't possible to enable or disable the monitor mode, this method will return either false or a string with details. In case of success, it will return true. */
         airmon(option: "start" | "stop", device: netDevice): boolean | string;
+        /** Returns a decrypted password via the provided password MD5 hash.
+         *
+         * Keep in mind that this method is not decrypting a password but rather checking for existing passwords within the game world with a matching MD5 hash.
+         *
+         * So in case a password does not exist in the game world, the decryption will fail.
+         *
+         * On failure, this method will return null. Using this method in an SSH encryption process will cause an error to be thrown, aborting further script execution. */
         decipher(hash: string): string | null;
-        decrypt(filePath: string, password: string): true | string | null;
-        encrypt(filePath: string, password: string): true | string | null;
-        isEncrypted(filePath: string): boolean | string | null;
-        smtpUserList(ip: string, port: number): string[] | string | null;
+        /** Decrypts the specified file using the provided key.
+         *
+         * On success, the method returns true. If decryption fails, a descriptive error message is returned as a string. */
+        decrypt(filePath: string, password: string): true | string;
+        /** Encrypts the specified file using the provided key.
+         *
+         * On success, the method returns true. If encryption fails, a descriptive error message is returned as a string. */
+        encrypt(filePath: string, password: string): true | string;
+        /** Checks whether the specified file is encrypted.
+         *
+         * Returns true if the file is encrypted, or zero if it is not. If the check fails (e.g., due to a missing or unreadable file), a descriptive error message is returned as a string. */
+        isEncrypted(filePath: string): boolean | string;
+        /** Returns an array of the existing users on the computer where the SMTP service is running.
+         *
+         * If these users also have an email account registered on the SMTP server, it will be indicated in the array.
+         *
+         * SMTP services are usually running on port 25. In case of failure, this method will return a string containing the cause.  */
+        smtpUserList(ip: string, port: number): string[] | string;
     }
     interface BlockChain {
         classID: "blockchainLib";
-        amountMined(coinName: string): number | string | null;
-        coinPrice(coinName: string): number | string | null;
-        createWallet(user: string, password: string): Wallet | string | null;
-        deleteCoin(coinName: string, user: string, password: string): true | string | null;
-        getCoin(coinName: string, user: string, password: string): Coin | string | null;
-        getCoinName(user: string, password: string): string | null;
-        loginWallet(user: string, password: string): Wallet | string | null;
+        /**  Returns a number representing the total amount of mined coins.
+         *
+         * In case of an error, it will return a string with the details.
+         * @example
+         * const blockChain = includeLib("/lib/blockchain.so");
+         * if (!isType(blockChain, "blockchainLib"))
+         * 	exit("Failed to get blockchain.so");
+         *
+         * const mined = blockChain.amountMined("bitcoin");
+         * if (isType(mined, "string"))
+         * 	exit(`Coudn't get the amount of mined coin: ${mined}`);
+         *
+         * print(`There are ${mined} coins mined for this coin`);
+         */
+        amountMined(coinName: string): number | string;
+        /** Returns a number representing the current unit value of the cryptocurrency.
+         *
+         * In case of an error, a string with the error details will be returned. */
+        coinPrice(coinName: string): number | string;
+        /** Creates a wallet and returns a wallet object on success, which can be used to manage cryptocurrencies.
+         *
+         * In case of an error, it will return a string with the details. */
+        createWallet(user: string, password: string): Wallet | string;
+        /** Removes a cryptocurrency from the world. The credentials used in the creation of the cryptocurrency are required.
+         *
+         * On success, it will return a true.
+         *
+         * On failure, it will return a string containing details. */
+        deleteCoin(coinName: string, user: string, password: string): true | string;
+        /** Returns a coin object used to manage the currency.
+         *
+         * In case of an error, it will return a string with the details. */
+        getCoin(coinName: string, user: string, password: string): Coin | string;
+        /** Returns a string with the name of the coin owned by the player.
+         *
+         * In case of an error, it returns a string with details. */
+        getCoinName(user: string, password: string): string;
+        /** Returns a wallet object on success. In case of an error, it will return a string indicating the reason. */
+        loginWallet(user: string, password: string): Wallet | string;
+        /** Returns an object with the latest changes in the value of a specific cryptocurrency.
+         *
+         * The key of the object is an index represented by a number. The value is an array, where index 0 is the historical price of the coin and index 1 is the date when the price change occurred.
+         *
+         * If no coin exists with this name, the method will return null. */
         showHistory(coinName: string): Record<number, [number, string]> | string | null;
     }
     interface AptClient {
         classID: "aptClientLib";
-        addRepo(repositoryAddress: string, port?: number): string | null;
-        checkUpgrade(filePath: string): boolean | string | null;
-        delRepo(repositoryAddress: string): string | null;
-        install(package: string, installPath?: string): true | string | null;
-        search(package: string): string | null;
-        show(repositoryAddress: string): string | null;
+        /** Inserts a repository address into the `/etc/apt/sources.txt` file.
+         *
+         * On success, it will return an empty string. In case of failure, it will return a string with an error message.
+        */
+        addRepo(repositoryAddress: string, port?: number): string;
+        /** Checks if there is a newer version of the program or library in the repository.
+         *
+         * On success, it will return a boolean, with false indicating that there is no new version, while true indicates that there is a new version available.
+         *
+         * In case of failure, it will return a string containing an error message. */
+        checkUpgrade(filePath: string): boolean | string;
+        /** Deletes a repository address from the `/etc/apt/sources.txt` file.
+         *
+         * On success, it will return an empty string. In case of failure, it will return a string with an error message. */
+        delRepo(repositoryAddress: string): string;
+        /** Installs a program or library from a remote repository listed in `/etc/apt/sources.txt`.
+         *
+         * If no path is specified, the program installs in `/lib` if it is a library or in `/bin` otherwise.
+         *
+         * On success, this method will return true. In case of failure, it will return a string containing an error message. */
+        install(package: string, installPath?: string): true | string;
+        /** Search specifically looks for a package in any of the repositories listed in `/etc/apt/sources.txt`.
+         *
+         * On success, it will return a string containing all packages that partially match the provided search value.
+         *
+         * On failure, it will return a string with various error messages. */
+        search(package: string): string;
+        /** Show displays all the packages available in a repository. The repository must be listed in the `/etc/apt/sources.txt` file.
+         *
+         * If it cannot find a repository, it will return various error messages.
+         *
+         * On success, it will return a string containing all packages and their descriptions, with each entry separated by a newline. */
+        show(repositoryAddress: string): string;
+        /** Update refreshes the list of available packages after adding a new repository in `/etc/apt/sources.txt`, or if the remote repository has updated its information in `/server/conf/repod.conf`.
+         *
+         * If the update is successful, an empty string will be returned. In case of failure, a string with an error message will be returned.
+         *
+         * If for some reason the `/etc/apt/sources.txt` is malformed this method will return false. */
         update(): string | false;
     }
     interface SmartAppliance {
         classID: "SmartAppliance";
+        /** Returns a string with the appliance model ID. */
         model(): string;
-        overrideSettings(power: number, temperature: number): true | string | null;
-        setAlarm(enable: boolean): true | string | null;
+        /** Overrides the power and temperature settings of the appliance.
+         *
+         * If successful, true is returned; otherwise, it returns a string detailing the error. */
+        overrideSettings(power: number, temperature: number): true | string;
+        /** Activates or deactivates the sound alarm indicating any appliance malfunction.
+         *
+         * If successful, true is returned; otherwise, a string containing error details is returned. */
+        setAlarm(enable: boolean): true | string;
     }
     interface TrafficNet {
         classID: "TrafficNet";
+        /** Accesses the traffic camera system, opening a window with controls to switch between different cameras.
+         *
+         * If the window opens successfully, this method returns true. In case of an error, it returns a string with details. */
         cameraLinkSystem(): true | string;
+        /** Returns string which contains job and name of a NPC. If an error occurs, a string with details is returned. */
         getCredentialsInfo(): string;
-        locateVehicle(licensePlate: string, password: string): true | string | null;
+        /** Performs a search for the specified license plate to locate the vehicle.
+         *
+         * If the vehicle is visible on any camera, the viewer will switch to the camera currently displaying it and return true.
+         *
+         * If the vehicle cannot be located or the license plate is incorrect, a string indicating the error is returned. */
+        locateVehicle(licensePlate: string, password: string): true | string;
     }
 }
 interface Math {
     readonly PI: number;
-    readonly abs: typeof GreyHack.abs;
-    readonly acos: typeof GreyHack.acos;
-    readonly asin: typeof GreyHack.asin;
-    readonly atan: typeof GreyHack.atan;
-    readonly ceil: typeof GreyHack.ceil;
-    readonly floor: typeof GreyHack.floor;
-    readonly cos: typeof GreyHack.cos;
-    readonly sin: typeof GreyHack.sin;
-    readonly tan: typeof GreyHack.tan;
-    readonly sqrt: typeof GreyHack.sqrt;
-    readonly sign: typeof GreyHack.sign;
-    readonly round: typeof GreyHack.round;
-    readonly random: typeof GreyHack.rnd;
-    readonly log: typeof GreyHack.log;
+    readonly abs: (value: number) => number;
+    readonly acos: (value: number) => number;
+    readonly asin: (value: number) => number;
+    readonly atan: (y: number, x?: number | undefined) => number;
+    readonly ceil: (value: number) => number;
+    readonly floor: (value: number) => number;
+    readonly cos: (value: number) => number;
+    readonly sin: (value: number) => number;
+    readonly tan: (value: number) => number;
+    readonly sqrt: (value: number) => number;
+    readonly sign: (value: number) => number;
+    readonly round: (value: number, fixed?: number | undefined) => number;
+    readonly random: (seed?: number | undefined) => number;
+    readonly log: (value: number, base?: number | undefined) => number;
     readonly min: (...values: number[]) => number;
     readonly max: (...values: number[]) => number;
 }
@@ -417,62 +1227,188 @@ declare var Math: Math;
 declare namespace GreyHack {
     interface CtfEvent {
         classID: "ctfEvent";
+        /** Returns string with the name of the CTF event creator. */
         getCreatorName(): string;
+        /** Returns string with the CTF event description. */
         getDescription(): string;
+        /** Returns string with the mail content of the CTF event. */
         getMailContent(): string;
+        /** Returns string with the CTF event template. */
         getTemplate(): string;
+        /** Returns a boolean indicating if the CTF event got completed successfully */
         playerSuccess(): boolean;
     }
     interface MetaMail {
         classID: "MetaMail";
-        delete(mailId: string): true | string | null;
+        /**
+         * Delete the email corresponding to the provided email ID.
+         *
+         * Returns true if the email removal was successful. Otherwise, a string with an error message will be returned.
+         */
+        delete(mailId: string): true | string;
+        /**
+         * Returns an array where each item is a string containing mail id, from, subject and a small preview of the content consisting of the first 125 characters.
+         *
+         * If there is any issue a string will be returned with details.
+         */
         fetch(): string[] | string;
-        read(mailId: string): string | null;
-        send(emailAddress: string, subject: string, message: string): string | true | null;
+        /**
+         * Returns a string containing the content of a mail related to the provided mail id.
+         *
+         * The mail id argument can be obtained with fetch. In case the mail cannot be found this method will return `Mail not found`.
+         */
+        read(mailId: string): string;
+        /**
+         * Send a new mail to the provided email address.
+         *
+         * Keep in mind that the subject can not exceed 128 characters and the message size should not exceed 2500 characters.
+         *
+         * @returns true indicating that the mail has been sent correctly, or a string with an error
+         */
+        send(emailAddress: string, subject: string, message: string): string | true;
     }
     interface NetSession {
         classID: "NetSession";
+        /**
+         * Returns the {@link MetaLib} associated with the remote service.
+         *
+         * For example if the {@link Metaxploit} method netUse was used on a ssh port it will return the MetaLib related to the ssh service. In case the port was zero is will return a MetaLib related to the kernel router.
+         */
         dumpLib(): MetaLib;
+        /**
+         * Initiates a DDoS attack targeting the computer associated with the currently active NetSession object.
+         *
+         * To successfully force a reboot, there must be at least 4 concurrent floodConnection calls for every 1 unit of net speed on the target computer. Keep in mind that these calls need to come from different IPs. So for example PackS would require 12 active floodConnection calls. If the threshold is met, the target computer will be forced to reboot, and the terminal will output: `remote connection interrupted`.
+         *
+         * This method always returns null and only prints a message upon a successful attack.
+        */
         floodConnection(): null;
+        /** Returns the number of devices using this router as a gateway. If you obtained your NetSession from a computer, it will fetch and return the value from its gateway router. */
         getNumConnGateway(): number;
+        /** Returns the number of ports forwarded by this router. If you obtained your NetSession from a computer, it will fetch and return the value from its gateway router. */
         getNumPortforward(): number;
+        /** Returns the number of user accounts on the system. */
         getNumUsers(): number;
+        /** Return a boolean indicating if there is an active user on the system */
         isAnyActiveUser(): boolean;
+        /** Return a boolean indicating if there is an active root user on the system */
         isRootActiveUser(): boolean;
     }
     interface Port {
         classID: "port";
+        /** Port number used by this port */
         portNumber: number;
+        /** Returns a boolean, where true indicates that the specified port is closed and false indicates that the port is open. */
         isClosed: () => boolean;
+        /** Returns a string containing the local IP address of the computer to which the port is pointing. */
         getLanIp: () => string;
     }
     interface Router {
         classID: "router";
+        /** BSSID value of the router */
         bssidName: string;
+        /** ESSID value of the router */
         essidName: string;
+        /** Version of the `kernel_router.so` library */
         kernelVersion: string;
+        /** Local IP address of the router. */
         localIp: string;
+        /** Public IP address of the router. */
         publicIp: string;
+        /**
+         * Returns an array where each item is an open port related to the device of the provided LAN IP address. The device needs to be within the network of the router.
+         *
+         * In case of failure, this method will return null or a string with details. In case an empty ip is provided this method will throw a runtime exception. */
         devicePorts(ip: string): Port[] | string | null;
+        /**
+         * Returns an array where each item is a string representing a LAN IP address.
+         *
+         * All devices are within the network of the router and can be reached by using the ping method. Some of the devices might be behind a firewall.
+        */
         devicesLanIp(): string[];
+        /** Returns an array where each item is a string containing a firewall rule. */
         firewallRules(): string[];
+        /** Returns a {@link Port} that is behind the port number provided. In case the port does not exist null gets returned. */
         pingPort(portNumber: number): Port | null;
+        /**
+         * Returns a string with information about the provided port, including details about the running service and its version.
+         *
+         * For example, the output could be `http 1.0.0`. If the operation fails, null will be returned.
+         */
         portInfo(port: Port): string | null;
+        /** Returns an array where each item is a {@link Port} used inside the router. */
         usedPorts(): Port[];
     }
     interface FtpShell {
         classID: "ftpShell";
+        /** Returns a computer related to the shell. */
         hostComputer: FtpComputer;
+        /**
+         * Send a file to the computer related to the provided shell.
+         *
+         * You require permission to read the file on the computer from which you are uploading and write permissions in the folder of the computer you are trying to upload to.
+         *
+         * Via the optional isUpload parameter you can define the direction.
+         *
+         * In case of failure, this method will return a string with the cause. Otherwise, true will be returned. In case the string for sourceFile or destinationFolder is empty, an error will be thrown, preventing further script execution. Utilizing this method in an SSH encryption process will trigger an error, halting further script execution.
+         */
         scp: Shell["scp"];
     }
     interface Shell {
         classID: "shell";
+        /** Returns a computer related to the shell. */
         hostComputer: Computer;
+        /**
+         * Compiles a plain code file provided in the arguments to a binary.
+         *
+         * On success, the new binary will be available under the provided build folder. The binary name will be the same as the source file just without the file extension. Optionally, an allowImport flag can be set which enables the use of import_code on the binary. All provided paths must be absolute. Returns an empty string on success. On failure, it will return a string containing details about the reason for failure.
+         *
+         * In case any provided values deviate from the defined signature a runtime exception will be thrown.
+         */
         build: (sourcePath: string, binaryPath: string, allowImport?: boolean) => string;
+        /**
+         * Returns a shell if the connection attempt to the provided IP was successful.
+         *
+         * This method can only connect to ports running an SSH or FTP service. SSH services usually run on port 22 and FTP services usually on port 21. Keep in mind to pass the right service value depending on which service is going to be used. By default, it will use SSH as the service. Please note that connecting will leave a log entry.
+         *
+         * In case of failure, a string is returned containing details. If this method is run in an SSH encryption process, or if the computer is not connected to the internet, a runtime exception will be thrown.
+         */
         connectService: (ip: string, port: number, user: string, password: string, service?: "ssh" | "ftp") => Shell | FtpShell | string | null;
+        /**
+         * Launches the binary located at the provided path.
+         *
+         * Optionally, parameters can be passed. Returns a boolean indicating the success of the launch. In some cases, a string will be returned containing an error message.
+         *
+         * If you need to share variables between a launched script and the current process, consider using {@link getCustomObject}.
+         *
+         * Note that launching a script is not asynchronous, meaning that the current script will pause its execution until the launched script finishes. If any provided values deviate from the method signature or it is used within an SSH encryption process, a runtime exception will be thrown.
+         *
+         * There is a cooldown of 2 seconds between launches to prevent abuse. If you attempt to launch a script during this cooldown period, the method will return false.
+         */
         launch: (program: string, params?: string) => string | boolean;
+        /**
+         * Pings an IP address.
+         *
+         * Return a boolean indicating if the remote address could be reached. Firewalls do not block ping requests. Passing an invalid ip will cause the method to return a string with an error message.
+         */
         ping: (ip: string) => string | boolean;
-        scp: (file: string, folder: string, remoteShell: Shell, isUpload?: boolean) => boolean | string | null;
+        /**
+         * Send a file to the computer related to the provided shell.
+         *
+         * You require permission to read the file on the computer from which you are uploading and write permissions in the folder of the computer you are trying to upload to.
+         *
+         * Via the optional isUpload parameter you can define the direction.
+         *
+         * In case of failure, this method will return a string with the cause. Otherwise, true will be returned. In case the string for sourceFile or destinationFolder is empty, an error will be thrown, preventing further script execution. Utilizing this method in an SSH encryption process will trigger an error, halting further script execution.
+         */
+        scp: (file: string, folder: string, remoteShell: Shell, isUpload?: boolean) => boolean | string;
+        /**
+         * Launches an active terminal.
+         *
+         * The terminal's color will change, displaying the IP of the connected shell. Script execution will be stopped upon starting a new terminal, unless this is called from another script that was executed via {@link Shell.launch}. In that case, you will enter the shell after closing your root-level script within that terminal window.
+         *
+         * Using this method within an SSH encryption process will cause an error to be thrown, preventing further script execution.
+         */
         startTerminal: () => never;
     }
 }
@@ -506,6 +1442,22 @@ interface String {
     upper(): string;
     val(): number;
     values(): string[];
+    /** Returns true if this string starts with the searchString. Otherwise returns false. */
+    startsWith(searchString: string, position?: number): boolean;
+    /** Returns true if this string ends with the searchString. Otherwise returns false. */
+    endsWith(searchString: string, endPosition?: number): boolean;
+    /**
+     * Returns a string value that is made from count copies appended together.
+     *
+     * If count is 0, the empty string is returned.
+     */
+    repeat(count: number): string;
+    /**
+     * Returns a section of a string.
+     * @param start The index to the beginning of the specified portion of string.
+     * @param end The index to the end of the specified portion of string. The substring includes the characters up to, but not including, the character indicated by end. If this value is not specified, the substring continues to the end of string.
+     */
+    slice(start?: number, end?: number): string;
     readonly [index: number]: string;
 }
 interface Number {
@@ -546,9 +1498,14 @@ interface Array<T> {
     indexes(): number[];
     insert(index: number, value: T): T[];
     join(delimiter: string): string;
-    pop(): T;
-    pull(): T;
-    push(value: T): T[];
+    /** Removes the first element from an array and returns it. If the array is empty, null is returned. */
+    shift(): T | null;
+    /** Inserts new elements at the start of an array, and returns the new length of the array. */
+    unshift(...items: T[]): number;
+    /** Removes the last element from an array and returns it. If the array is empty, null is returned. */
+    pop(): T | null;
+    /** Appends new elements to the end of an array, and returns the new length of the array. */
+    push(...items: T[]): number;
     remove(index: number): null;
     replace(oldValue: T, newValue: T, maxCount?: number): T[];
     reverse(): null;
@@ -556,26 +1513,45 @@ interface Array<T> {
     sort(key: PropertyKey | null, ascending?: boolean): T[];
     sum(): number;
     values(): T[];
+    /** Combines two or more arrays. This method returns a new array without modifying any existing arrays.
+     * @param items Additional arrays and/or items to add to the end of the array.
+     */
     concat(...items: (T | T[])[]): T[];
+    /** Calls a defined callback function on each element of an array, and returns an array that contains the results. */
     map<U>(callbackfn: (value: T, index: number, array: T[]) => U): U[];
+    /** Returns the elements of an array that meet the condition specified in a callback function. */
     filter(predicate: (value: T, index: number, array: T[]) => unknown): T[];
+    /** Returns the value of the first element in the array where predicate is true, and null otherwise. */
     find(predicate: (value: T, index: number, array: T[]) => unknown): T | null;
+    /** Determines whether the specified callback function returns true for any element of an array. */
     some(predicate: (value: T, index: number, array: T[]) => unknown): boolean;
+    /** Determines whether all the members of an array satisfy the specified test. */
     every(predicate: (value: T, index: number, array: T[]) => unknown): boolean;
+    /** Returns a copy of a section of an array. For both start and end, a negative index can be used to indicate an offset from the end of the array.
+     *
+     * For example, -2 refers to the second to last element of the array.
+     * @param start The beginning index of the specified portion of the array. If start is undefined, then the slice begins at index 0.
+     * @param end The end index of the specified portion of the array. This is exclusive of the element at the index 'end'. If end is undefined, then the slice extends to the end of the array.
+     * */
+    slice(start?: number, end?: number): T[];
     [n: number]: T;
 }
 interface Function {
 }
 declare var String: {
-    new (value?: string): String;
+    new (value?: any): String;
     (value?: any): string;
     readonly prototype: String;
 };
 declare var Number: {
+    new (value?: any): Number;
+    (value?: any): number;
     readonly prototype: Number;
 };
 declare var Boolean: {
-    readonly prototype: Number;
+    new (value?: any): Boolean;
+    <T>(value?: T): boolean;
+    readonly prototype: Boolean;
 };
 declare var Array: {
     readonly prototype: Array<any>;