@grey-ts/types 1.4.0 → 2.0.0

package/dist/index.d.ts

@@ -187,7 +187,7 @@ declare namespace GreyHack {
     interface BaseComputer<FileType extends GreyHack.File | GreyHack.FtpFile> {
         classID: "ftpComputer" | "computer";
         /** Returns the hostname of the machine. */
-        getName: () => string;
+        getName(): string;
         /**
          * Creates a folder at the path provided in the arguments.
          *
@@ -197,7 +197,7 @@ declare namespace GreyHack {
          *
          * 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;
+        createFolder(path: string, folderName?: string): string | true;
         /**
          * Returns a file located at the path provided in the argument.
          *
@@ -206,8 +206,14 @@ declare namespace GreyHack {
          * 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.
+         * @example
+         * const computer = getShell().hostComputer;
+         * const passwd = computer.file("/etc/passwd");
+         * if (passwd) {
+         * 	print(`Content of passwd file\n${passwd.getContent()}`)
+         * }
          */
-        file: (path: string) => FileType | null;
+        file(path: string): FileType | null;
     }
     interface FtpComputer extends BaseComputer<FtpFile> {
         classID: "ftpComputer";
@@ -219,7 +225,7 @@ declare namespace GreyHack {
         /** The public IP address of the computer */
         publicIp: string;
         /** Returns `WIFI` or `ETHERNET` depending on the connection type the computer is currently using */
-        activeNetCard: () => "WIFI" | "ETHERNET";
+        activeNetCard(): "WIFI" | "ETHERNET";
         /**
          * Changes the password of an existing user on the computer.
          *
@@ -227,13 +233,13 @@ declare namespace GreyHack {
          *
          * If the provided username is empty, an error will be thrown, preventing any further script execution.
          */
-        changePassword: (username: string, password: string) => boolean | string;
+        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;
+        closeProgram(pid: number): boolean | string;
         /**
          * Sets up a new IP address on the computer through the Ethernet connection.
          *
@@ -241,7 +247,7 @@ declare namespace GreyHack {
          *
          * 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;
+        connectEthernet(netDevice: netDevice, address: string, gateway: string): string | null;
         /**
          * Connects to the indicated Wi-Fi network.
          *
@@ -249,25 +255,25 @@ declare namespace GreyHack {
          *
          * 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;
+        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;
+        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;
+        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;
+        deleteGroup(username: string, group: string): true | string;
         /**
          * Deletes the indicated user from the computer.
          *
@@ -278,25 +284,25 @@ declare namespace GreyHack {
          * @param username the user to remove
          * @param removeHome remove the user's home folder as well
          */
-        deleteUser: (username: string, removeHome?: boolean) => true | string;
+        deleteUser(username: string, removeHome?: boolean): true | string;
         /** Returns an array of ports on the computer that are active. */
-        getPorts: () => Port[];
+        getPorts(): Port[];
         /**
          * 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;
+        groups(username: string): string;
         /** Returns a boolean indicating if the computer has internet access */
-        isNetworkActive: () => boolean;
+        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;
+        networkDevices(): string;
         /** Returns a string with the gateway IP address configured on the computer. */
-        networkGateway: () => string;
+        networkGateway(): string;
         /**
          * Reboots the computer. By default, it reboots in standard mode.
          *
@@ -306,35 +312,31 @@ declare namespace GreyHack {
          *
          * @param safeMode reboot the system in safe mode instead
          */
-        reboot: (safeMode?: boolean) => true | string;
+        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;
+        showProcs(): 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;
+        touch(destFolder: string, fileName: string): true | string;
         /**
-         * Returns a list of the Wi-Fi networks that are available for the provided interface.
+         * Returns an array 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.
+         * Each item in the array 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
+         * @returns null if no matching netDevice can be found, otherwise the available networks
          */
-        wifiNetworks: (netDevice: netDevice) => string[] | null;
+        wifiNetworks(netDevice: netDevice): string[] | null;
     }
 }
 declare namespace GreyHack {
@@ -347,13 +349,13 @@ declare namespace GreyHack {
          *
          * 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;
+        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;
+        getFolders(): FtpFile[] | null;
     }
     interface File extends BaseFile {
         classID: "file";
@@ -366,13 +368,13 @@ declare namespace GreyHack {
          *
          * 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;
+        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;
+        getFolders(): File[] | null;
         /**
          * Modifies the file permissions.
          *
@@ -382,7 +384,7 @@ declare namespace GreyHack {
          *
          * @param recursive set the permissions recursively to every file inside this folder
          */
-        chmod: (perms: string, recursive?: boolean) => string;
+        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.
          *
@@ -390,7 +392,7 @@ declare namespace GreyHack {
          *
          * If this method is used within an SSH encryption process, an error will be thrown, preventing any further script execution.
          */
-        getContent: () => string | null;
+        getContent(): string | null;
         /**
          * Saves text into a file. The content will not get appended to the file; therefore, existing content will be overridden.
          *
@@ -398,7 +400,7 @@ declare namespace GreyHack {
          *
          * 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;
+        setContent(content: string): string | boolean | null;
         /**
          * Change the group related to this file.
          *
@@ -408,7 +410,7 @@ declare namespace GreyHack {
          *
          * @param recursive set the group recursively to every file inside this folder
          */
-        setGroup: (group: string, recursive?: boolean) => string | null;
+        setGroup(group: string, recursive?: boolean): string | null;
         /**
          * Change the owner of this file.
          *
@@ -418,7 +420,7 @@ declare namespace GreyHack {
          *
          * @param recursive set the owner recursively to every file inside this folder
          */
-        setOwner: (owner: string, recursive?: boolean) => string | null;
+        setOwner(owner: string, recursive?: boolean): string | null;
         /**
          * Creates a symlink to the specified path.
          *
@@ -426,7 +428,7 @@ declare namespace GreyHack {
          *
          * 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;
+        symlink(path: string, newName?: string): true | string | null;
     }
     interface BaseFile {
         classID: "ftpFile" | "file";
@@ -455,7 +457,7 @@ declare namespace GreyHack {
          *
          * 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;
+        copy(destFolder?: string, newName?: string): string | boolean | null;
         /**
          * Delete the current file.
          *
@@ -463,18 +465,18 @@ declare namespace GreyHack {
          *
          * Note that deleting a file will leave a log entry.
          */
-        delete: () => string;
+        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;
+        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;
+        isBinary(): boolean | null;
         /** Returns a boolean indicating if the file is a folder. Returns null if the file gets deleted */
-        isFolder: () => boolean | null;
+        isFolder(): boolean | null;
         /** Returns a boolean indicating if the file is a symlink. Returns null if the file gets deleted */
-        isSymlink: () => boolean | null;
+        isSymlink(): boolean | null;
         /**
          * Moves the file to the provided path.
          *
@@ -482,12 +484,12 @@ declare namespace GreyHack {
          *
          * 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;
+        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;
+        path(symLinkOriginalPath?: boolean): string;
         /**
          * Rename the file with the name provided.
          *
@@ -495,7 +497,7 @@ declare namespace GreyHack {
          *
          * 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;
+        rename(name: string): string;
     }
 }
 /** Provides access to global variables of this script */
@@ -761,12 +763,18 @@ declare namespace GreyHack {
      * }
      */
     function isType<T extends keyof GameTypeMap>(value: any, type: T): value is GameTypeMap[T];
-    /** FOR TRANSPILER ONLY
+    /**
+     * FOR TRANSPILER ONLY
      *
      * Includes the given source to this position. If the file was already transpiled then this does nothing
      *
      * Can be a folder if you want to include all the files inside
-     * @param file The absolute or relative path of the file */
+     *
+     * @param file The absolute or relative path of the file
+     *
+     * @example
+     * include("./commands");
+     */
     function include(file: string): void;
     type LibTypes = {
         "aptclient.so": GreyHack.AptClient;
@@ -1064,7 +1072,25 @@ declare namespace GreyHack {
          *
          * 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. */
+         * 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.
+         * @example
+         * const crypto = includeLib("/lib/crypto.so");
+         * if (!isType(crypto, "cryptoLib")) exit("Failed to load crypto.so");
+         *
+         * const computer = getShell().hostComputer;
+         * const passwdFile = computer.file("/etc/passwd");
+         * if (!passwdFile) exit("Failed to get passwd file");
+         *
+         * const lines = passwdFile.getContent()!.split(char(10));
+         * for (const line of lines) {
+         * 	const parsed = line.split(":");
+         * 	const username = parsed[0];
+         * 	const passwordhash = parsed[1];
+         *
+         * 	const password = crypto.decipher(passwordhash);
+         * 	print(`Password for user '${username}' is: ${password}`);
+         * }
+         */
         decipher(hash: string): string | null;
         /** Decrypts the specified file using the provided key.
          *
@@ -1205,23 +1231,44 @@ declare namespace GreyHack {
     }
 }
 interface Math {
+    /** Returns the value of pi to the precision of 6 */
     readonly PI: number;
-    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;
+    /** Returns the absolute value of number. */
+    abs(value: number): number;
+    /** Returns the inverse cosine (in radians) of a number. */
+    acos(value: number): number;
+    /** Returns the inverse sine (in radians) of a number. */
+    asin(value: number): number;
+    /** Returns the inverse tangent (in radians) of a number. */
+    atan(y: number, x?: number | undefined): number;
+    /** Returns number rounded up to the integer value of the provided number. */
+    ceil(value: number): number;
+    /** Returns number rounded down to the integer value of the provided number. */
+    floor(value: number): number;
+    /** Returns the cosine of a number in radians. */
+    cos(value: number): number;
+    /** Returns the sine of a number in radians. */
+    sin(value: number): number;
+    /** Returns the tangent of a number in radians. */
+    tan(value: number): number;
+    /** Returns the square root of a number. */
+    sqrt(value: number): number;
+    /** Returns 1 or -1 indicating the sign of the value passed or 0 if the value is 0 */
+    sign(value: number): -1 | 0 | 1;
+    /** Returns number rounded to the integer value of the provided number. */
+    round(value: number, fixed?: number | undefined): number;
+    /** Returns a random number between 0 and 1. Optionally a seed number can be provided. */
+    random(seed?: number | undefined): number;
+    /**
+     * Returns the natural logarithm of a number.
+     *
+     * By default, the base is 10. Optionally the base can be changed.
+     */
+    log(value: number, base?: number | undefined): number;
+    /** Returns the smallest number of the given values */
+    min(...values: number[]): number;
+    /** Returns the largest number of the given values */
+    max(...values: number[]): number;
 }
 declare var Math: Math;
 declare namespace GreyHack {
@@ -1299,9 +1346,9 @@ declare namespace GreyHack {
         /** 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;
+        isClosed(): boolean;
         /** Returns a string containing the local IP address of the computer to which the port is pointing. */
-        getLanIp: () => string;
+        getLanIp(): string;
     }
     interface Router {
         classID: "router";
@@ -1365,7 +1412,7 @@ declare namespace GreyHack {
          *
          * In case any provided values deviate from the defined signature a runtime exception will be thrown.
          */
-        build: (sourcePath: string, binaryPath: string, allowImport?: boolean) => string;
+        build(sourcePath: string, binaryPath: string, allowImport?: boolean): string;
         /**
          * Returns a shell if the connection attempt to the provided IP was successful.
          *
@@ -1373,7 +1420,7 @@ declare namespace GreyHack {
          *
          * 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;
+        connectService(ip: string, port: number, user: string, password: string, service?: "ssh" | "ftp"): Shell | FtpShell | string | null;
         /**
          * Launches the binary located at the provided path.
          *
@@ -1385,13 +1432,13 @@ declare namespace GreyHack {
          *
          * 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;
+        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;
+        ping(ip: string): string | boolean;
         /**
          * Send a file to the computer related to the provided shell.
          *
@@ -1401,7 +1448,7 @@ declare namespace GreyHack {
          *
          * 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;
+        scp(file: string, folder: string, remoteShell: Shell, isUpload?: boolean): boolean | string;
         /**
          * Launches an active terminal.
          *
@@ -1409,9 +1456,13 @@ declare namespace GreyHack {
          *
          * Using this method within an SSH encryption process will cause an error to be thrown, preventing further script execution.
          */
-        startTerminal: () => never;
+        startTerminal(): never;
     }
 }
+declare const console: {
+    readonly log: typeof GreyHack.print;
+    readonly clear: typeof GreyHack.clearScreen;
+};
 interface RegExp {
 }
 interface CallableFunction {
@@ -1423,6 +1474,7 @@ interface IArguments {
 interface Boolean {
 }
 interface String {
+    /** Returns the length of the string */
     readonly length: number;
     /** Returns the Unicode code of the first character of the string */
     code(): number;
@@ -1430,17 +1482,69 @@ interface String {
     indexOf(value: string, offset?: number): number | null;
     indexes(): number[];
     insert(index: number, value: string): string;
-    isMatch(pattern: string | RegExp, regexOptions?: string): number;
-    lastIndexOf(value: string): number;
-    lower(): string;
+    /**
+     * Uses regular expression to check if a string matches a certain pattern.
+     *
+     * If the pattern is empty, the provided {@link https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-options|regexOptions} are invalid, or if the regular expression times out, an error will be thrown, preventing further script execution.
+     */
+    isMatch(pattern: string | RegExp, regexOptions?: string): boolean;
+    /** Returns the last occurrence of a substring in the string. */
+    lastIndexOf(searchString: string): number;
+    /** Converts all the alphabetic characters in a string to lowercase. */
+    toLowerCase(): string;
+    /** Converts all the alphabetic characters in a string to uppercase. */
+    toUpperCase(): string;
+    /**
+     * Returns an object with all search results for the provided regular expression.
+     *
+     * Each key contains the index and the value contains the matching string.
+     *
+     * If the pattern is empty, the provided {@link https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-options|regexOptions} are invalid, or if the regular expression times out, an error will be thrown, preventing further script execution.
+     */
     matches(pattern: string | RegExp, regexOptions?: string): Record<number, string>;
+    /**
+     * Returns a new string with the provided value removed
+     * @example
+     * const myString = "I will not eat an ice cream!";
+     * const newString = myString.remove("not ");
+     * print(newString); // Prints "I will eat an ice cream!"
+     */
     remove(value: string): string;
+    /**
+     * Returns a string with the replaced content by using regular expressions.
+     *
+     * If the pattern is empty, the provided {@link https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-options|regexOptions} are invalid or if the regular expression times out, an error will be thrown, preventing further script execution.
+     *
+     * @example
+     * const myString = "I am now online";
+     * const newString = myString.replace("online", "offline");
+     * print(newString); // Prints "I am now offline"
+     */
     replace(pattern: string | RegExp, newValue: string, regexOptions?: string): string;
+    /**
+     * Returns an array where each item is a segment of the string, separated by the provided separator string.
+     *
+     * This method uses regular expressions for matching, so remember to escape special characters such as dots.
+     *
+     * In case the pattern is empty, the provided {@link https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-options|regexOptions} are invalid, or the regular expression times out, an error will be thrown, preventing further script execution.
+     *
+     * @example
+     * const csvString = "cat,turtle,dog,mouse";
+     * const animals = csvString.split(",");
+     * print(animals); // Prints ["cat", "turtle", "dog", "mouse"]
+     */
     split(pattern: string | RegExp, regexOptions?: string): string[];
+    /**
+     * Returns a number which is parsed from the string as an integer.
+     *
+     * In case the string is not numeric it will return the original string.
+     */
     toInt(): string | number;
+    /** Removes the leading and trailing white space and line terminator characters from a string. */
     trim(): string;
-    upper(): string;
+    /** Returns a number which is parsed from the string. In case the string is not numeric it will return a zero. */
     val(): number;
+    /** Returns an array where each item is a string representing all available characters in the string. Could be compared to using {@link String.split|split} but with empty separator. */
     values(): string[];
     /** Returns true if this string starts with the searchString. Otherwise returns false. */
     startsWith(searchString: string, position?: number): boolean;
@@ -1458,45 +1562,87 @@ interface 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;
+    /** Returns a string representation of a string. */
+    toString(): string;
     readonly [index: number]: string;
 }
 interface Number {
+    /** Returns a string representation of a number. */
+    toString(): string;
 }
 type PropertyKey = number | string | symbol;
 interface Object {
-    /** Returns the number of items inside the object */
-    readonly size: number;
-    hasIndex(key: PropertyKey): boolean;
-    indexOf(value: any): any;
-    indexes<T extends PropertyKey>(): T[];
-    pop(): any;
-    pull(): any;
-    push(key: PropertyKey): any;
-    remove(key: PropertyKey): boolean;
-    replace(oldValue: any, newValue: any, maxCount?: number): any;
-    shuffle(): null;
-    sum(): number;
-    values(): any[];
+    /** Returns a string representation of an object. */
+    toString(): string;
 }
 interface ObjectConstructor {
     new (value?: any): Object;
     readonly prototype: Object;
+    /** Determines whether an object has a property with the specified name. */
     hasOwn<T extends PropertyKey, U = object>(o: U, key: T): o is (T extends keyof U ? U : U & {
         [K in T]: unknown;
     });
+    /**
+     * Returns a key of the object that has a value equal to the given value
+     * @example
+     * const myObject = { test: 123, other: 222 };
+     * const key = Object.indexOf(myObject, 222);
+     * print(key); // Prints "other"
+     */
+    indexOf<T extends Record<any, any>>(o: T, value: T[keyof T]): keyof T | null;
     /** Copy the properties of the source to the target */
     assign<T extends {}, U>(target: T, source: U): T & U;
     assign<T extends {}, U, V>(target: T, source: U, source2: V): T & U & V;
     assign<T extends {}, U, V, W>(target: T, source: U, source2: V, source3: W): T & U & V & W;
     assign(target: object, ...sources: any[]): any;
+    /** Returns the number of items inside the object */
+    size<T extends Record<any, any>>(o: T): number;
+    /** Returns an array of keys of the object */
     keys<T extends Record<any, any>>(o: T): (Exclude<keyof T, symbol>)[];
+    /** Returns an array of values of the object */
+    values<T extends Record<any, any>>(o: T): (T[keyof T])[];
+    /** Returns sum of all values inside the given object. Any non-numeric values will be considered a zero. */
+    sum(o: Record<any, any>): number;
+    /** Shuffles all **values** in the object. This operation will mutate the map. */
+    shuffle(o: Record<any, any>): null;
+    /**
+     * Replaces each value of the object matching `oldValue` with `newValue`.
+     *
+     * This method will mutate the object
+     * @example
+     * const myObject = { status: "online" };
+     * Object.replace(myObject, "online", "offline");
+     * print(myObject); // Prints { "status": "offline" };
+     */
+    replace<T extends Record<any, any>>(o: T, oldValue: T[keyof T], newValue: T[keyof T], maxCount?: number): T;
+    /**
+     * Removes a key-value pair from the object. This method mutates the object.
+     *
+     * @returns a boolean indicating success
+     */
+    remove<T extends Record<any, any>>(o: T, key: keyof T): boolean;
+    /**
+     * Removes the first item of the object and returns it's key
+     *
+     * This method mutates the object.
+     */
+    shift<T extends Record<any, any>>(o: T): keyof T | null;
 }
 interface Array<T> {
     readonly length: number;
+    /** Returns a boolean indicating if the provided index exists in the array */
     hasIndex(index: number): boolean;
+    /** Returns the index of the first occurrence of a value in an array, or null if it is not present. */
     indexOf(value: T, offset?: number): number | null;
+    /** Returns an array containing the indexes of the array */
     indexes(): number[];
+    /** Inserts a value into the array at the provided index. This method mutates the array and returns a reference to the same array. */
     insert(index: number, value: T): T[];
+    /**
+     * Returns a concatenated string containing all stringified values inside the list. These values will be separated via the provided separator.
+     *
+     * In case the list exceeds `16777215L` items or the delimiter exceeds 128 characters, this method will throw an error, interrupting further script execution.
+     */
     join(delimiter: string): string;
     /** Removes the first element from an array and returns it. If the array is empty, null is returned. */
     shift(): T | null;
@@ -1506,11 +1652,33 @@ interface Array<T> {
     pop(): T | null;
     /** Appends new elements to the end of an array, and returns the new length of the array. */
     push(...items: T[]): number;
+    /**
+     * Removes an item from the list with the provided index. Due to the removal the list will get mutated.
+     */
     remove(index: number): null;
+    /**
+     * Changes every value of the array that matches `oldValue` into `newValue`
+     *
+     * This method mutates the array and returns a reference to the same array.
+     */
     replace(oldValue: T, newValue: T, maxCount?: number): T[];
-    reverse(): null;
+    /** Reverses the elements in an array in place. This method mutates the array and returns a reference to the same array. */
+    reverse(): T;
+    /** Shuffles all values in the array. This method mutates the array. */
     shuffle(): null;
-    sort(key: PropertyKey | null, ascending?: boolean): T[];
+    /**
+     * Sorts the values of an array alphanumerically.
+     *
+     * This operation mutates the original array. Optionally, a key can be provided, which is used if the items are objects or arrays. Finally, this method returns the updated array.
+     * @example
+     * const myArray = [{ key: 123 }, { key: 5 }, { key: 17 }];
+     * myArray.sort("key");
+     *
+     * const numbers = [1,2,3,4,5];
+     * numbers.sort()
+     */
+    sort(key?: PropertyKey | null, ascending?: boolean): T[];
+    /** Returns a sum of all values inside the array. Any non-numeric values will be considered a zero. */
     sum(): number;
     values(): T[];
     /** Combines two or more arrays. This method returns a new array without modifying any existing arrays.
@@ -1534,9 +1702,13 @@ interface Array<T> {
      * @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[];
+    /** Returns a string representation of an array. */
+    toString(): string;
     [n: number]: T;
 }
 interface Function {
+    /** Returns a string representation of a function. */
+    toString(): string;
 }
 declare var String: {
     new (value?: any): String;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@grey-ts/types",
-	"version": "1.4.0",
+	"version": "2.0.0",
 	"description": "TypeScript definitions for GreyHack's functions and objects",
 	"license": "MIT",
 	"types": "dist/index.d.ts",