/* Native, implemented in Java
 * All enums extends this class.
 * Import with 'import Enum from '
 */
class Enum {
    /*
     * This allows you to get the name of the enum value
     * Returns - String: the name of the enum value
     */
    fun getName();

    /*
     * This allows you to get the ordinal of the enum value
     * Returns - Number: the ordinal of the enum value
     */
    fun ordinal();
}

/* Native, implemented in Java
 * This class cannot be constructed since null has a literal `null`.
 * Import with 'import Null from '
 */
class Null {
}

/* Native, implemented in Java
 * Sets are collections of unique values. Similar to maps, without the values.
 * An instance of the class can be created by using `Set.of(values...)`
 * Import with 'import Set from '
 */
class Set {
    /*
     * This allows you to add a value to the set
     * Parameter - Value (value): the value you want to add to the set
     * Returns - Boolean: whether the value was successfully added to the set
     */
    fun add(value);

    /*
     * This allows you to check whether a value is in the set
     * Parameter - Value (value): the value that you want to check in the set
     * Returns - Boolean: whether the value is in the set
     */
    fun contains(value);

    /*
     * This allows you to add all the values in a collection into the set
     * Parameter - Collection (collection): the collection of values you want to add
     * Returns - Set: the modified set
     * Throws - Error: ... is not a collection
     */
    fun addAll(collection);

    /*
     * This allows you to check whether a collection of values are all in the set
     * Parameter - Collection (collection): the collection of values you want to check in the set
     * Returns - Boolean: whether all the values are in the set
     * Throws - Error: ... is not a collection
     */
    fun containsAll(collection);

    /*
     * This allows you to get a value from in the set.
     * The reason this might be useful is if you want to retrieve something
     * from the set that will have the same hashcode but be in a different state
     * as the value you are passing in
     * Parameter - Value (value): the value you want to get from the set
     * Returns - Value: the value you wanted to get, null if it wasn't in the set
     */
    fun get(value);

    /*
     * This removes all values from inside the set
     */
    fun clear();

    /*
     * This allows you to check whether the set has no values
     * Returns - Boolean: whether the set is empty
     */
    fun isEmpty();

    /*
     * This converts the set to a string and evaluating any collections inside it
     * Returns - String: the string representation of the set
     */
    fun toString();

    /*
     * This allows you to remove a value from the set
     * Parameter - Value (value): the value you want to remove from the set
     * Returns - Boolean: whether the value was removed from the set
     */
    fun remove(value);

    /*
     * This creates an unordered set
     * Returns - Set: the unordered set
     */
    static fun unordered();

    /*
     * This allows you to create a set with an arbitrary number of values
     * Parameter - Value (values...): the values you want to add to the set
     * Returns - Set: the set you created
     */
    static fun of(values...);
}

/* Native, implemented in Java
 * This class is the only type that can be thrown
 * Import with 'import Error from '
 */
class Error {
    /*
     * This creates a new Error value with no message
     */
    Error();

    /*
     * This creates a new Error value with the given details as a message
     * Parameter - String (details): the details of the error
     */
    Error(details);

    /*
     * This creates a new Error value with the given details as a message and the given value
     * Parameter - String (details): the details of the error
     * Parameter - Value (value): the value that is related to the error
     */
    Error(details, value);

    /*
     * This returns the value that is related to the error
     * Returns - Value: the value that is related to the error
     */
    fun getValue();

    /*
     * This returns the raw message of the error
     * Returns - String: the details of the error
     */
    fun getDetails();

    /*
     * This returns the message of the error in a formatted string
     * Returns - String: the details of the error
     */
    fun getFormattedDetails();
}

/* Native, implemented in Java
 * This class cannot be constructed since strings have a literal. Strings are immutable.
 * Import with 'import String from '
 */
class String {
    /*
     * This makes the string uppercase
     * Returns - String: the uppercase string
     */
    fun uppercase();

    /*
     * This makes the string lowercase
     * Returns - String: the lowercase string
     */
    fun lowercase();

    /*
     * This formats the string with the given parameters, which replace '%s' in the string
     * Parameter - Value (values...): the values to add, these will be converted to strings
     * Returns - String: the formatted string
     * Throws - Error: You are missing values to be formatted
     */
    fun format(values...);

    fun containsString(arg1);

    /*
     * This makes a list of all the characters in the string
     * Returns - List: the list of characters
     */
    fun toList();

    /*
     * This checks if the string matches the given regex
     * Parameter - String (regex): the regex to check the string with
     * Returns - Boolean: true if the string matches the given regex
     */
    fun matches(regex);

    /*
     * This replaces all the instances of a regex with the replace string
     * Parameter - String (regex): the regex you want to replace
     * Parameter - String (replace): the string you want to replace it with
     * Returns - String: the modified string
     */
    fun replaceAll(regex, replace);

    /*
     * This capitalises the first letter of the string
     * Returns - String: the capitalised string
     */
    fun capitalise();

    /*
     * This checks if the string contains the given string
     * Parameter - String (string): the string you want to check for
     * Returns - Boolean: true if the string contains the given string
     */
    fun contains(string);

    /*
     * This splits the string into a list of strings based on a regex
     * Parameter - String (regex): the regex to split the string with
     * Returns - List: the list of strings
     */
    fun split(regex);

    /*
     * This strips the whitespace from the string
     * Returns - String: the stripped string
     */
    fun strip();

    /*
     * This returns a substring of the string
     * Parameter - Number (from): the start index
     * Parameter - Number (to): the end index
     * Returns - String: the substring
     */
    fun subString(from, to);

    /*
     * This finds all instances of the regex in the string
     * Parameter - String (regex): the regex to search the string with
     * Returns - List: the list of all instances of the regex in the string
     */
    fun find(regex);

    /*
     * This checks if the string ends with the given string
     * Parameter - String (string): the string to check the string with
     * Returns - Boolean: true if the string ends with the given string
     */
    fun endsWith(string);

    /*
     * This tries to convert the string to a number
     * Returns - Number: the number value
     * Throws - Error: Cannor parse ... as a number
     */
    fun toNumber();

    /*
     * This checks if the string starts with the given string
     * Parameter - String (string): the string to check the string with
     * Returns - Boolean: true if the string starts with the given string
     */
    fun startsWith(string);
}

/* Native, implemented in Java
 * Provides many basic math functions. This is a utility class, and cannot be constructed.
 * Import with 'import Math from '
 */
class Math {
    /*
     * The value of e
     * The type of the field is Number
     * This field is not assignable
     */
    static var e;
    /*
     * The value of pi
     * The type of the field is Number
     * This field is not assignable
     */
    static var pi;
    /*
     * The value of root 2
     * The type of the field is Number
     * This field is not assignable
     */
    static var root2;

    /*
     * Returns the sign of a number, 1 if the number is positive, -1 if the number is negative, and 0 if the number is 0
     * Parameter - Number (num): the number to get the sign of
     * Returns - Number: the sign of the number
     */
    static fun signum(num);

    /*
     * Returns the tangent of a number
     * Parameter - Number (num): the number to get the tangent of
     * Returns - Number: the tangent of the number
     */
    static fun tan(num);

    /*
     * Returns the cosecant of a number
     * Parameter - Number (num): the number to get the cosecant of
     * Returns - Number: the cosecant of the number
     */
    static fun cosec(num);

    /*
     * Returns the modulus of a division
     * Parameter - Number (num1): the number to divide
     * Parameter - Number (num2): the divisor
     * Returns - Number: the modulus of the division
     */
    static fun mod(num1, num2);

    /*
     * Returns the largest number
     * Parameter - Number (num1): the first number to compare
     * Parameter - Number (num2): the second number to compare
     * Returns - Number: the largest number
     */
    static fun max(num1, num2);

    /*
     * Linear interpolation between two numbers
     * Parameter - Number (start): the first number
     * Parameter - Number (end): the second number
     * Parameter - Number (delta): the interpolation factor
     * Returns - Number: the interpolated number
     */
    static fun lerp(start, end, delta);

    /*
     * Returns the natural logarithm of a number
     * Parameter - Number (num): the number to get the logarithm of
     * Returns - Number: the natural logarithm of the number
     */
    static fun log(num);

    /*
     * Returns the logarithm of a number with a specified base
     * Parameter - Number (base): the base
     * Parameter - Number (num): the number to get the logarithm of
     * Returns - Number: the logarithm of the number
     */
    static fun log(base, num);

    /*
     * Returns the base 10 logarithm of a number
     * Parameter - Number (num): the number to get the logarithm of
     * Returns - Number: the base 10 logarithm of the number
     */
    static fun log10(num);

    /*
     * Returns the cosine of a number
     * Parameter - Number (num): the number to get the cosine of
     * Returns - Number: the cosine of the number
     */
    static fun cos(num);

    /*
     * Returns the cotangent of a number
     * Parameter - Number (num): the number to get the cotangent of
     * Returns - Number: the cotangent of the number
     */
    static fun cot(num);

    /*
     * Converts a number from radians to degrees
     * Parameter - Number (num): the number to convert
     * Returns - Number: the number in degrees
     */
    static fun toDegrees(num);

    /*
     * Rounds a number up to the nearest integer
     * Parameter - Number (num): the number to round
     * Returns - Number: the rounded number
     */
    static fun ceil(num);

    /*
     * Converts a number from degrees to radians
     * Parameter - Number (num): the number to convert
     * Returns - Number: the number in radians
     */
    static fun toRadians(num);

    /*
     * Returns the arc cosine of a number
     * Parameter - Number (num): the number to get the arc cosine of
     * Returns - Number: the arc cosine of the number
     */
    static fun arccos(num);

    /*
     * Returns the secant of a number
     * Parameter - Number (num): the number to get the secant of
     * Returns - Number: the secant of the number
     */
    static fun sec(num);

    /*
     * Returns the absolute value of a number
     * Parameter - Number (num): the number to get the absolute value of
     * Returns - Number: the absolute value of the number
     */
    static fun abs(num);

    /*
     * Returns the smallest number
     * Parameter - Number (num1): the first number to compare
     * Parameter - Number (num2): the second number to compare
     * Returns - Number: the smallest number
     */
    static fun min(num1, num2);

    /*
     * Rounds a number to the nearest integer
     * Parameter - Number (num): the number to round
     * Returns - Number: the rounded number
     */
    static fun round(num);

    /*
     * Returns the arc tangent of a number
     * Parameter - Number (num): the number to get the arc tangent of
     * Returns - Number: the arc tangent of the number
     */
    static fun arctan(num);

    /*
     * Returns the square root of a number
     * Parameter - Number (num): the number to square root
     * Returns - Number: the square root of the number
     */
    static fun sqrt(num);

    /*
     * Returns the sine of a number
     * Parameter - Number (num): the number to get the sine of
     * Returns - Number: the sine of the number
     */
    static fun sin(num);

    /*
     * Returns the remainder of a division
     * Parameter - Number (num1): the number to divide
     * Parameter - Number (num2): the divisor
     * Returns - Number: the remainder of the division
     */
    static fun rem(num1, num2);

    /*
     * Rounds a number down to the nearest integer
     * Parameter - Number (num): the number to round
     * Returns - Number: the rounded number
     */
    static fun floor(num);

    /*
     * Returns the arc sine of a number
     * Parameter - Number (num): the number to get the arc sine of
     * Returns - Number: the arc sine of the number
     */
    static fun arcsin(num);

    /*
     * Clamps a value between a minimum and maximum
     * Parameter - Number (value): the value to clamp
     * Parameter - Number (min): the minimum
     * Parameter - Number (max): the maximum
     * Returns - Number: the clamped value
     */
    static fun clamp(value, min, max);
}

/* Native, implemented in Java
 * This class allows you to create threads for asynchronous execution.
 * Import with 'import Thread from '
 */
class Thread {
    /*
     * This gets the age of the thread in milliseconds
     * Returns - Number: the age of the thread
     */
    fun getAge();

    /*
     * This checks if the thread is alive (still running)
     * Returns - Boolean: true if the thread is alive, false if not
     */
    fun isAlive();

    /*
     * This gets the name of the thread
     * Returns - String: the name of the thread
     */
    fun getName();

    /*
     * This stops the thread from executing, anything that was running will be instantly stopped
     * Throws - Error: Thread is not alive
     */
    fun stop();

    /*
     * This freezes the current thread, stops anything else from executing on the thread
     */
    static fun freeze();

    /*
     * This starts a new thread and runs a function on it, the thread will 
     * terminate when it finishes executing the function, threads will stop automatically 
     * when the program stops, you are also able to stop threads by using the Thread value
     * Parameter - Function (function): the function you want to run on a new thread
     * Returns - Thread: the new thread
     */
    static fun runThreaded(function);

    /*
     * This starts a new thread with a specific name and runs a function on it
     * Parameter - String (name): the name of the thread
     * Parameter - Function (function): the function you want to run on a new thread
     * Returns - Thread: the new thread
     */
    static fun runThreaded(name, function);

    /*
     * This gets the current thread that the code is running on
     * Returns - Thread: the current thread
     * Throws - Error: Thread is not safe to get
     */
    static fun getCurrentThread();

    /*
     * This runs a function asynchronously returning a lazy value which can be accessed once the function is complete
     * Parameter - Function (function): the function to run async
     * Returns - Value: the lazy value
     */
    static fun runAsync(function);
}

/* Native, implemented in Java
 * Adds utilities for delegating and calling functions.
 * Import with 'import Function from '
 */
class Function {
    /*
     * Calls the given delegate with the given arbitrary parameters
     * Parameter - Function (delegate): the delegate to call
     * Parameter - Value (parameters...): the parameters to pass to the delegate
     * Returns - Value: the return value of the delegate
     */
    static fun call(delegate, parameters...);

    /*
     * Returns a method delegate with the given name and parameter count
     * Parameter - Value (value): the value to call the method on
     * Parameter - String (methodName): the name of the method
     * Parameter - Number (parameterCount): the parameter count of the method
     * Returns - Function: the method delegate
     */
    static fun getMethod(value, methodName, parameterCount);

    /*
     * Calls the given delegate with the given parameters
     * Parameter - Function (delegate): the delegate to call
     * Parameter - List (parameters): the parameters to pass to the delegate
     * Returns - Value: the return value of the delegate
     */
    static fun callWithList(delegate, parameters);

    /*
     * Returns a built-in function delegate with the given name and parameter count
     * Parameter - String (functionName): the name of the function
     * Parameter - Number (parameterCount): the parameter count of the function
     * Returns - Function: the built-in function delegate
     */
    static fun getBuiltIn(functionName, parameterCount);
}

/* Native, implemented in Java
 * This class lets you get the type of a class or value.
 * Import with 'import Type from '
 */
class Type {
    /*
     * This gets the static method of the type
     * Parameter - String (name): the name of the method
     * Parameter - Number (parameters): the number of parameters for the method
     * Returns - Function: the static method of the type
     */
    fun getStaticMethod(name, parameters);

    /*
     * This gets the name of the type
     * Returns - String: the name of the type
     */
    fun getName();

    /*
     * This gets the constructor of the type
     * Parameter - Number (parameters): the number of parameters for the constructor
     * Returns - Function: the constructor of the type
     */
    fun getConstructor(parameters);

    /*
     * This checks whether a type is a subtype of another type
     * Parameter - Type (type): the other type you want to check against
     * Returns - Boolean: whether the type is of that type
     */
    fun instanceOf(type);

    /*
     * This gets the specific type of a value
     * Parameter - Value (value): the value you want to get the type of
     * Returns - Type: the type of the value
     */
    static fun of(value);
}

/* Native, implemented in Java
 * This class cannot be constructed as it has a literal representation. For math related functions see the Math class.
 * Import with 'import Number from '
 */
class Number {
    /*
     * This allows you to check if a number is infinite
     * Returns - Boolean: true if the number is infinite
     */
    fun isInfinite();

    /*
     * This allows you to round a number to the nearest integer
     * Returns - Number: the rounded number
     */
    fun round();

    /*
     * Deprecated: You should use `Math.abs(num)`
     * This allows you to get the absolute value of a number
     * Returns - Number: the absolute value of the number
     */
    fun absolute();

    /*
     * Deprecated: You should use `Math.toDegrees(num)`
     * This allows you to convert a number in radians to degrees
     * Returns - Number: the number in degrees
     */
    fun toDegrees();

    /*
     * Deprecated: You should use `Math.toRadians(num)`
     * This allows you to convert a number in degrees to radians
     * Returns - Number: the number in radians
     */
    fun toRadians();

    /*
     * This allows you to round a number up to the nearest integer
     * Returns - Number: the rounded number
     */
    fun ceil();

    /*
     * This allows you to check if a number is not a number
     * Returns - Boolean: true if the number is not a number
     */
    fun isNaN();

    /*
     * This allows you to round a number down to the nearest integer
     * Returns - Number: the rounded number
     */
    fun floor();

    /*
     * Deprecated: You should use `Math.mod(num1, num2)`
     * This allows you to get the modulus of two numbers
     * Parameter - Number (otherNumber): the divisor
     * Returns - Number: the modulus of the two numbers
     */
    fun modulus(otherNumber);
}

/* Native, implemented in Java
 * This is the base class for every other class in Arucas.
 * Import with 'import Object from '
 */
class Object {
    /*
     * This returns the unique hashcode of the value, this is different for every instance of a value
     * Returns - Number: the unique hashcode of the value
     */
    fun uniqueHash();

    /*
     * This returns the hashcode of the value, this is mainly used for maps and sets
     * Returns - Number: the hashcode of the value
     */
    fun hashCode();

    /*
     * Deprecated: You should use '=='
     * This checks whether the value is equal to another value
     * Parameter - Value (other): the other value you want to check against
     * Returns - Boolean: whether the values are equal
     */
    fun equals(other);

    /*
     * This returns the string representation of the value
     * Returns - String: the string representation of the value
     */
    fun toString();

    /*
     * This compares the value to another value
     * returns -1 if this is less than the other value, 0 if they are equal, 1 if this is greater than the other value
     * Parameter - Value (other): the other value you want to compare against
     * Returns - Number: the result of the comparison
     */
    fun compareTo(other);

    /*
     * This returns a copy of the value, some values might just return themselves
     * Returns - Value: the copy of the value
     */
    fun copy();

    /*
     * Deprecated: You should use 'Type.of(<Value>).getName()'
     * This returns the name of the type of the value
     * Returns - String: the name of the type of value
     */
    fun getValueType();

    /*
     * This checks whether this value is an instance of another type
     * Parameter - Type (type): the other type you want to check against
     * Returns - Boolean: whether the value is of that type
     */
    fun instanceOf(type);
}

/* Native, implemented in Java
 * This class cannot be constructed since it has a literal, []
 * Import with 'import List from '
 */
class List {
    /*
     * This allows you to set the value at a specific index
     * Parameter - Value (value): the value you want to set
     * Parameter - Number (index): the index you want to set the value at
     * Returns - List: the list
     * Throws - Error: Index is out of bounds
     */
    fun set(value, index);

    fun getIndex(arg1);

    /*
     * This allows you to check if the list contains all the values in a collection
     * Parameter - Collection (collection): the collection you want to check for
     * Returns - Boolean: true if the list contains all the values in the collection, false otherwise
     * Throws - Error: ... is not a collection
     */
    fun containsAll(collection);

    /*
     * This allows you to clear all the values the list
     */
    fun clear();

    /*
     * This allows you to check if the list is empty
     * Returns - Boolean: true if the list is empty, false otherwise
     */
    fun isEmpty();

    /*
     * This allows you to insert a value at a specific index
     * Parameter - Value (value): the value you want to insert
     * Parameter - Number (index): the index you want to insert the value at
     * Returns - List: the list
     * Throws - Error: Index is out of bounds
     */
    fun insert(value, index);

    fun removeIndex(arg1);

    /*
     * This allows you to sort the list based on the compareTo method of the values
     * Returns - List: the sorted list
     */
    fun sort();

    /*
     * This allows you to sort the list with a given function taking
     * two values then returning a comparing number
     * Parameter - Function (function): the function to use to compare the values
     * Returns - List: the sorted list
     */
    fun sort(function);

    /*
     * Deprecated: You should use <List>.addAll(collection) instead
     * This allows you to concatenate two lists
     * Parameter - List (otherList): the list you want to concatenate with
     * Returns - List: the concatenated list
     */
    fun concat(otherList);

    /*
     * This allows you to remove the value at a specific index
     * Parameter - Number (index): the index of the value you want to remove
     * Returns - Value: the value that was removed
     * Throws - Error: Index is out of bounds
     */
    fun remove(index);

    /*
     * This allows you to check if the list contains a value
     * Parameter - Value (value): the value you want to check for
     * Returns - Boolean: true if the list contains the value, false otherwise
     */
    fun contains(value);

    /*
     * This allows you to add all the values in a collection to the list
     * Parameter - Collection (collection): the collection you want to add
     * Returns - List: the list
     * Throws - Error: ... is not a collection
     */
    fun addAll(collection);

    /*
     * This allows you to get the value at a specific index
     * Parameter - Number (index): the index of the value you want to get
     * Returns - Value: the value at the index
     * Throws - Error: Index is out of bounds
     */
    fun get(index);

    /*
     * This converts the list to a string and evaluating any collections inside it
     * Returns - String: the string representation of the set
     */
    fun toString();

    /*
     * This allows you to get the index of a value in the list
     * Parameter - Value (value): the value you want to check for
     * Returns - Number: the index of the value, -1 if the value is not in the list
     */
    fun indexOf(value);

    /*
     * This allows you to append a value to the end of the list
     * Parameter - Value (value): the value you want to append
     * Returns - List: the list
     */
    fun append(value);
}

/* Native, implemented in Java
 * This class cannot be constructed since Booleans have literals.
 * Import with 'import Boolean from '
 */
class Boolean {
}

/* Native, implemented in Java
 * This class cannot be constructed since it has a literal, `{}`
 * Import with 'import Map from '
 */
class Map {
    /*
     * This allows you to get the values in the map
     * Returns - List: a complete list of all the values
     */
    fun getValues();

    /*
     * This allows you to check if the map contains a specific key
     * Parameter - Value (key): the key you want to check
     * Returns - Boolean: true if the map contains the key, false otherwise
     */
    fun containsKey(key);

    /*
     * This allows you to put all the keys and values of another map into this map
     * Parameter - Map (another map): the map you want to merge into this map
     */
    fun putAll(another map);

    /*
     * This allows you to get the value of a key in the map
     * Parameter - Value (key): the key you want to get the value of
     * Returns - Value: the value of the key, will return null if non-existent
     */
    fun get(key);

    /*
     * This allows you to check if the map is empty
     * Returns - Boolean: true if the map is empty, false otherwise
     */
    fun isEmpty();

    /*
     * This allows you to clear the map of all the keys and values
     */
    fun clear();

    /*
     * This allows you to get the string representation of the map and evaluating any collections inside it
     * Returns - String: the string representation of the map
     */
    fun toString();

    /*
     * This allows you to get the keys in the map
     * Returns - List: a complete list of all the keys
     */
    fun getKeys();

    /*
     * This allows you to put a key and value in the map if it doesn't exist
     * Parameter - Value (key): the key you want to put
     * Parameter - Value (value): the value you want to put
     * Returns - Value: the previous value associated with the key, null if none
     */
    fun putIfAbsent(key, value);

    /*
     * This allows you to remove a key and its value from the map
     * Parameter - Value (key): the key you want to remove
     * Returns - Value: the value associated with the key, null if none
     */
    fun remove(key);

    /*
     * This allows you to put a key and value in the map
     * Parameter - Value (key): the key you want to put
     * Parameter - Value (value): the value you want to put
     * Returns - Value: the previous value associated with the key, null if none
     */
    fun put(key, value);

    /*
     * This function allows you to create an unordered map
     * Returns - Map: an unordered map
     */
    static fun unordered();
}

/* Native, implemented in Java
 * This class allows you to manipulate files.
 * Import with 'import File from '
 */
class File {
    /*
     * This creates a new File object with set path
     * Parameter - String (path): the path of the file
     */
    File(path);

    /*
     * This returns the parent directory of the file
     * Returns - File: the parent directory of the file
     */
    fun getParent();

    /*
     * This reads the file and returns the contents as a string
     * Returns - String: the contents of the file
     * Throws - Error: There was an error reading the file: ..., Out of Memory - The file you are trying to read is too large
     */
    fun read();

    /*
     * This returns the name of the file
     * Returns - String: the name of the file
     */
    fun getName();

    /*
     * This returns the absolute path of the file
     * Returns - String: the absolute path of the file
     */
    fun getAbsolutePath();

    fun getChild(arg1);

    /*
     * This returns the path of the file
     * Returns - String: the path of the file
     */
    fun getPath();

    /*
     * This returns if the file exists
     * Returns - Boolean: true if the file exists
     * Throws - Error: Could not check file: ...
     */
    fun exists();

    /*
     * This creates all parent directories of the file if they don't already exist
     * Returns - Boolean: true if the directories were created
     * Throws - Error: ...
     */
    fun createDirectory();

    /*
     * This returns a list of all the sub files in the directory
     * Returns - List: a list of all the sub files in the directory
     * Throws - Error: Could not find any files
     */
    fun getSubFiles();

    /*
     * This deletes the file
     * Returns - Boolean: true if the file was deleted
     * Throws - Error: Could not delete file: ...
     */
    fun delete();

    /*
     * This writes a string to a file
     * Parameter - String (string): the string to write to the file
     * Throws - Error: There was an error writing the file: ...
     */
    fun write(string);

    /*
     * This opens the file (as in opens it on your os)
     */
    fun open();

    /*
     * This returns the file of the working directory
     * Returns - File: the file of the working directory
     */
    static fun getDirectory();
}


