@tlua/gmod 1.0.1

package/table.d.tlua

@@ -0,0 +1,533 @@
+// AUTO-GENERATED tlua declarations. Do not edit by hand.
+
+/**
+ * The [table](https://wiki.facepunch.com/gmod/Beginner_Tutorial_Tables) **type** is an object that can store multiple values.
+ *
+ * The table **library** is a standard Lua library which provides functions to manipulate tables. In Garry's Mod there are several extra useful functions added to this library.
+ *
+ * This category lists the functions available in the table `library`.
+ * @source https://wiki.facepunch.com/gmod/table
+ */
+interface TableLib {
+    /**
+     * Adds all values from `source` table into the `target` table. This is most useful for sequential tables, not "dictionary" or "map" tables. See [table.Merge](https://wiki.facepunch.com/gmod/table.Merge) if you want to merge 2 tables into one.
+     *
+     * See [table.insert](https://wiki.facepunch.com/gmod/table.insert) for a function that adds a single value, and [table.Inherit](https://wiki.facepunch.com/gmod/table.Inherit) for a function that inherits keys from one table to another.
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Add
+     */
+    Add(target: table, source: table): table;
+}
+
+interface TableLib {
+    /**
+     * Changes all keys to sequential integers. This creates a new table object and does not affect the original.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.ClearKeys
+     */
+    ClearKeys(table: table, saveKeys?: boolean): table;
+}
+
+interface TableLib {
+    /**
+     * Collapses a table with keyvalue structure
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.CollapseKeyValue
+     */
+    CollapseKeyValue(input: table): table;
+}
+
+interface TableLib {
+    /**
+     * Creates and returns a deep copy of a table.
+     *
+     * WARNING: this function is very slow, and does NOT copy userdata such as
+     * Vectors and Angles.
+     * @realm shared
+     * @realm menu
+     * @source https://wiki.facepunch.com/gmod/table.Copy
+     */
+    Copy<T extends table>(originalTable: T): T;
+}
+
+
+interface TableLib {
+    /**
+     * Empties the target table, and merges all values from the source table into it.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.CopyFromTo
+     */
+    CopyFromTo(source: table, target: table): void;
+}
+
+interface TableLib {
+    /**
+     * Counts the amount of keys in a table. This should only be used when a table is not numerically and sequentially indexed. For those tables, consider the length (**#**) operator.
+     *
+     * If you only want to test if the table is empty or not, use [table.IsEmpty](https://wiki.facepunch.com/gmod/table.IsEmpty) instead as it is a lot faster.
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Count
+     */
+    Count(tbl: table): number;
+}
+
+interface TableLib {
+    /**
+     * Converts a table that has been sanitised with [table.Sanitise](https://wiki.facepunch.com/gmod/table.Sanitise) back to its original form
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.DeSanitise
+     */
+    DeSanitise(tbl: table): table;
+}
+
+interface TableLib {
+    /**
+     * Removes all values from a table. If your table is not a metatable, it is almost always better to use `tab = {}` to preserve performance.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Empty
+     */
+    Empty(tbl: table): void;
+}
+
+interface TableLib {
+    /**
+     * Returns the value positioned after the supplied value in a table. If it isn't found then the first element in the table is returned
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.FindNext
+     * @deprecated Instead, iterate the table using ipairs or increment from the previous index using Global.next. Non-numerically indexed tables are not ordered.
+     */
+    FindNext(tbl: table, value: any): any;
+}
+
+interface TableLib {
+    /**
+     * Returns the value positioned before the supplied value in a table. If it isn't found then the last element in the table is returned
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.FindPrev
+     * @deprecated Instead, iterate your table with ipairs, storing the previous value and checking for the target. Non-numerically indexed tables are not ordered.
+     */
+    FindPrev(tbl: table, value: any): any;
+}
+
+interface TableLib {
+    /**
+     * Flips key-value pairs of each element within a table, so that each value becomes the key, and each key becomes the value.
+     *
+     * **WARNING**: Take care when using this function, as a Lua table cannot contain multiple instances of the same key. As such, data loss is possible when using this function on tables with duplicate values.
+     *
+     * ```
+     * local test = { test = 1, test2 = 1 }
+     * local f = table.Flip( test )
+     * PrintTable( f )
+     * -- Outputs "1	=	test2"
+     * ```
+     *
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Flip
+     */
+    Flip(input: table): table;
+}
+
+interface TableLib {
+    /**
+     * Inserts a value in to the given table even if the table is non-existent
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.ForceInsert
+     */
+    ForceInsert(tab?: table, value?: any): table;
+}
+
+interface TableLib {
+    /**
+     * Returns the first key found in the given table
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.GetFirstKey
+     * @deprecated Instead, expect the first key to be 1.  Non-numerically indexed tables are not ordered and do not have a first key.
+     */
+    GetFirstKey(tab: table): any;
+}
+
+interface TableLib {
+    /**
+     * Returns the first value found in the given table
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.GetFirstValue
+     * @deprecated Instead, index the table with a key of 1.  Non-numerically indexed tables are not ordered and do not have a first key.
+     */
+    GetFirstValue(tab: table): any;
+}
+
+interface TableLib {
+    /**
+     * Returns all keys of a table.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.GetKeys
+     */
+    GetKeys(tabl: table): table;
+}
+
+interface TableLib {
+    /**
+     * Returns the last key found in the given table
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.GetLastKey
+     * @deprecated Instead, use the result of the length (#) operator, ensuring it is not zero. Non-numerically indexed tables are not ordered and do not have a last key.
+     */
+    GetLastKey(tab: table): any;
+}
+
+interface TableLib {
+    /**
+     * Returns the last value found in the given table
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.GetLastValue
+     * @deprecated Instead, index the table with the result of the length (#) operator, ensuring it is not zero. Non-numerically indexed tables are not ordered and do not have a last key.
+     */
+    GetLastValue(tab: table): any;
+}
+
+interface TableLib {
+    /**
+     * Returns a key of the supplied table with the highest number value.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.GetWinningKey
+     */
+    GetWinningKey(inputTable: table): any;
+}
+
+interface TableLib {
+    /**
+     * Checks if a table has a value.
+     * **WARNING**: This function is **very inefficient for large tables** (O(n)) and should probably not be called in things that run each frame. Instead, consider a table structure such as example 2 below. Also see: [Tables: Bad Habits](https://wiki.facepunch.com/gmod/Tables:_Bad_Habits)
+     *
+     * **NOTE**: For optimization, functions that look for a value by sorting the table should never be needed if you work on a table that you built yourself.
+     *
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.HasValue
+     */
+    HasValue(tbl: table, value: any): boolean;
+}
+
+interface TableLib {
+    /**
+     * Copies any missing data from `base` to `target`, and sets the `target`'s `BaseClass` member to the `base` table's pointer.
+     *
+     * See [table.Merge](https://wiki.facepunch.com/gmod/table.Merge), which overrides existing values and doesn't add a BaseClass member.
+     *
+     *
+     * See also [table.Add](https://wiki.facepunch.com/gmod/table.Add), which simply adds values of one table to another.
+     *
+     * Sub-tables aren't inherited. The target's table value will take priority.
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Inherit
+     */
+    Inherit(target: table, base: table): table;
+}
+
+interface TableLib {
+    /**
+     * Returns whether or not the given table is empty.
+     *
+     * This works on both sequential and non-sequential tables, and is a lot faster for non-sequential tables than `table.Count(tbl) == 0`.
+     *
+     * For sequential tables it is better to use `tab[1] == nil`.
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.IsEmpty
+     */
+    IsEmpty(tab: table): boolean;
+}
+
+interface TableLib {
+    /**
+     * Returns whether or not the table's keys are sequential
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.IsSequential
+     */
+    IsSequential(tab: table): boolean;
+}
+
+interface TableLib {
+    /**
+     * Returns the first key found to be containing the supplied value
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.KeyFromValue
+     */
+    KeyFromValue(tab: table, value: any): any;
+}
+
+interface TableLib {
+    /**
+     * Returns a table of keys containing the supplied value
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.KeysFromValue
+     */
+    KeysFromValue(tab: table, value: any): table;
+}
+
+interface TableLib {
+    /**
+     * Returns a copy of the input table with all string keys converted to be lowercase recursively
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.LowerKeyNames
+     */
+    LowerKeyNames(tbl: table): table;
+}
+
+interface TableLib {
+    /**
+     * Returns an array of values of given with given key from each table of given table.
+     *
+     * See also [table.KeysFromValue](https://wiki.facepunch.com/gmod/table.KeysFromValue).
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.MemberValuesFromKey
+     */
+    MemberValuesFromKey(inputTable: table, keyName: any): table;
+}
+
+interface TableLib {
+    /**
+     * **NOTE**: This function can cause a stack overflow under certain circumstances.
+     *
+     * Recursively merges the key-value pairs of the `source` table with the key-value pairs in the `destination` table.
+     *
+     * See [table.Inherit](https://wiki.facepunch.com/gmod/table.Inherit), which doesn't override existing values.
+     *
+     *
+     * See also [table.Add](https://wiki.facepunch.com/gmod/table.Add), which simply adds values of one table to another.
+     *
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Merge
+     */
+    Merge(destination: table, source: table, forceOverride?: boolean): table;
+}
+
+interface TableLib {
+    /**
+     * Packs a set of items into a table and returns the new table. It is meant as an alternative implementation of `table.pack` from newer versions of Lua.
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Pack
+     */
+    Pack(...: any): (table, number);
+}
+
+interface TableLib {
+    /**
+     * Returns a random value from the supplied table.
+     *
+     * **WARNING**: This function iterates over the given table **twice**, therefore with sequential tables you should instead use following:
+     *
+     * ```
+     * mytable[ math.random( #mytable ) ]
+     * ```
+     *
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Random
+     */
+    Random(haystack: table): (any, any);
+}
+
+interface TableLib {
+    /**
+     * Removes the first instance of a given value from the specified table with [table.remove](https://wiki.facepunch.com/gmod/table.remove), then returns the key that the value was found at.
+     *
+     * **WARNING**: Avoid usage of this function. It does not remove all instances of given value in the table, only the first found, and it does not work with non sequential tables!
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.RemoveByValue
+     */
+    RemoveByValue(tbl: table, val: any): any;
+}
+
+interface TableLib {
+    /**
+     * Returns a reversed copy of a sequential table. Any non-sequential and non-numeric keyvalue pairs will not be copied.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Reverse
+     */
+    Reverse(tbl: table): table;
+}
+
+interface TableLib {
+    /**
+     * Converts [Vector](https://wiki.facepunch.com/gmod/Vector)s, [Angle](https://wiki.facepunch.com/gmod/Angle)s and [boolean](https://wiki.facepunch.com/gmod/boolean)s to be able to be converted to and from key-values via [util.TableToKeyValues](https://wiki.facepunch.com/gmod/util.TableToKeyValues).
+     *
+     * [table.DeSanitise](https://wiki.facepunch.com/gmod/table.DeSanitise) performs the opposite transformation.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Sanitise
+     */
+    Sanitise(tab: table): table;
+}
+
+interface TableLib {
+    /**
+     * Performs an inline [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle) on the table in `O(n)` time
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.Shuffle
+     */
+    Shuffle(target: table): void;
+}
+
+interface TableLib {
+    /**
+     * Returns a list of keys sorted based on values of those keys.
+     *
+     * For normal sorting see [table.sort](https://wiki.facepunch.com/gmod/table.sort).
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.SortByKey
+     */
+    SortByKey(tab: table, descending?: boolean): table;
+}
+
+interface TableLib {
+    /**
+     * Sorts a table by a named member.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.SortByMember
+     */
+    SortByMember(tab: table, memberKey: any, ascending?: boolean): void;
+}
+
+interface TableLib {
+    /**
+     * 		Sorts a table in reverse order from [table.sort](https://wiki.facepunch.com/gmod/table.sort).
+     * **NOTE**: This function modifies the table you give to it. Like table.sort, it does not return anything.
+     *
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.SortDesc
+     */
+    SortDesc(tbl: table): void;
+}
+
+interface TableLib {
+    /**
+     * Converts a table into a string
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.ToString
+     */
+    ToString(tbl: table, displayName?: string, niceFormatting?: boolean): string;
+}
+
+interface TableLib {
+    /**
+     * Concatenates the contents of a table to a string.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.concat
+     */
+    concat(tbl: table, concatenator?: string, startPos?: number, endPos?: number): string;
+}
+
+interface TableLib {
+    /**
+     *  Iterates for each key-value pair in the table, calling the function with the key and value of the pair. If the function returns anything, the loop is broken.
+     *
+     * The GLua interpretation of this is [table.ForEach](https://wiki.facepunch.com/gmod/table.ForEach).
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.foreach
+     * @deprecated This was deprecated in Lua 5.1 and removed in 5.2. You should use Global.pairs instead.
+     */
+    ForEach(tbl: table, callback: (key: any, val: any) => void): void;
+}
+
+interface TableLib {
+    /**
+     *  Iterates for each numeric index in the table in order.
+     *
+     * This is inherited from the original Lua implementation and is deprecated in Lua as of 5.1; see [here](http://lua-users.org/wiki/TableLibraryTutorial). You should use [Global.ipairs](https://wiki.facepunch.com/gmod/Global.ipairs)() instead.
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.foreachi
+     * @deprecated This was deprecated in Lua 5.1 and removed in 5.2. You should use Global.ipairs() instead.
+     */
+    foreachi(table: table, func: function): void;
+}
+
+interface TableLib {
+    /**
+     *  Returns the length of the table.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.getn
+     * @deprecated This function was deprecated in Lua 5.1 and is removed in 5.2. Use the length (#) operator instead.
+     */
+    getn(tbl: table): number;
+}
+
+interface TableLib {
+    /**
+     * Inserts a value at the end of the table.
+     * @realm shared
+     * @realm menu
+     * @source https://wiki.facepunch.com/gmod/table.insert
+     */
+    insert(tbl: table, value: any): number;
+    /**
+     * Inserts a value into a table at the given position.
+     *
+     * NOTE: does not call the `__newindex` metamethod.
+     * @realm shared
+     * @realm menu
+     */
+    insert(tbl: table, position: number, value: any): number;
+}
+
+
+interface TableLib {
+    /**
+     * Returns the highest numerical key.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.maxn
+     */
+    maxn(tbl: table): number;
+}
+
+interface TableLib {
+    /**
+     * Moves elements from one part of a table to another part a given table. This is similar to assigning elements from the source table to the destination table in multiple assignments.
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.move
+     */
+    move(sourceTbl: table, from: number, to: number, dest: number, destTbl?: table): table;
+}
+
+interface TableLib {
+    /**
+     * Removes a value from a table and shifts any other values down to fill the gap.
+     * **NOTE**: Does nothing if index is less than 1 or greater than `#tbl`
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.remove
+     */
+    remove(tbl: table, index?: number): any;
+}
+
+interface TableLib {
+    /**
+     * Sorts a sequential table either ascending or by the given sort function.
+     * **NOTE**: This function modifies the table you give to it and internally uses the [quick sort algorithm](http://www.lua.org/source/5.2/ltablib.c.html#sort).
+     *
+     *
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/table.sort
+     */
+    sort(tbl: table, sorter?: (a: any, b: any) => boolean): void;
+}
+

package/task.d.tlua

@@ -0,0 +1,92 @@
+// AUTO-GENERATED tlua declarations. Do not edit by hand.
+
+/**
+ * A single AI task. Returned by [ai_task.New](https://wiki.facepunch.com/gmod/ai_task.New).
+ * @source https://wiki.facepunch.com/gmod/Task
+ */
+interface Task {}
+
+interface Task {
+    /**
+     * **INTERNAL**: This is used internally - although you're able to use it you probably shouldn't.
+     *  Initialises the AI task. Called by [ai_task.New](https://wiki.facepunch.com/gmod/ai_task.New).
+     * @realm server
+     * @source https://wiki.facepunch.com/gmod/Task:Init
+     */
+    Init(self: Task): void;
+}
+
+interface Task {
+    /**
+     * Initialises the AI task as an engine task.
+     * @realm server
+     * @source https://wiki.facepunch.com/gmod/Task:InitEngine
+     */
+    InitEngine(self: Task, taskname: string, taskdata: number): void;
+}
+
+interface Task {
+    /**
+     * Initialises the AI task as NPC method-based.
+     * @realm server
+     * @source https://wiki.facepunch.com/gmod/Task:InitFunctionName
+     */
+    InitFunctionName(self: Task, startname: string, runname: string, taskdata: number): void;
+}
+
+interface Task {
+    /**
+     * Determines if the task is an engine task (`TYPE_ENGINE`, 1).
+     * @realm server
+     * @source https://wiki.facepunch.com/gmod/Task:IsEngineType
+     */
+    IsEngineType(self: Task): void;
+}
+
+interface Task {
+    /**
+     * Determines if the task is an NPC method-based task (`TYPE_FNAME`, 2).
+     * @realm server
+     * @source https://wiki.facepunch.com/gmod/Task:IsFNameType
+     */
+    IsFNameType(self: Task): void;
+}
+
+interface Task {
+    /**
+     * Runs the AI task.
+     * @realm server
+     * @source https://wiki.facepunch.com/gmod/Task:Run
+     */
+    Run(self: Task, target: NPC): void;
+}
+
+interface Task {
+    /**
+     * **INTERNAL**: This is used internally - although you're able to use it you probably shouldn't.
+     *  Runs the AI task as an NPC method. This requires the task to be of type `TYPE_FNAME`.
+     * @realm server
+     * @source https://wiki.facepunch.com/gmod/Task:Run_FName
+     */
+    Run_FName(self: Task, target: NPC): void;
+}
+
+interface Task {
+    /**
+     * Starts the AI task.
+     * @realm server
+     * @source https://wiki.facepunch.com/gmod/Task:Start
+     */
+    Start(self: Task, target: NPC): void;
+}
+
+interface Task {
+    /**
+     * **INTERNAL**: This is used internally - although you're able to use it you probably shouldn't.
+     *  Starts the AI task as an NPC method.
+     * @realm server
+     * @source https://wiki.facepunch.com/gmod/Task:Start_FName
+     */
+    Start_FName(self: Task, target: NPC): void;
+}
+