diff --git a/actiondoc.yml b/actiondoc.yml
index 18041ece..9fdaf695 100644
--- a/actiondoc.yml
+++ b/actiondoc.yml
@@ -32,149 +32,250 @@
 # 'name': str, 'complexity': str, 'accept': [str]
 # 'return': [str], 'syntax': [str], 'desc': str
 
-- name: GET
-  complexity: O(1)
-  accept: [AnyArray]
-  syntax: [GET <key>]
-  desc: Get the value of a key from the current table, if it exists
-  return: [Rcode 1, String, Binstr]
-- name: MGET
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [MGET <key1> <key2> ...]
-  desc: Get the value of 'n' keys from the current table, if they exist
-  return: [Typed Array]
-- name: SET
-  complexity: O(1)
-  accept: [AnyArray]
-  syntax: [SET <key> <value>]
-  desc: Set the value of a key in the current table, if it doesn't already exist
-  return: [Rcode 0, Rcode 2, Rcode 5]
-- name: MSET
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [MSET <key1> <value1> <key2> <value2> ...]
-  desc: |
-    Set the value of 'n' keys in the current table, if they don't already exist. This will
-    return the number of keys that were set as an unsigned integer.
-  return: [Integer, Rcode 5]
-- name: UPDATE
-  complexity: O(1)
-  accept: [AnyArray]
-  syntax: [UPDATE <key> <value>]
-  desc: Update the value of an existing key in the current table
-  return: [Rcode 0, Rcode 1, Rcode 5]
-- name: MUPDATE
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [MUPDATE <key1> <value1> <key2> <value2> ...]
-  desc: |
-    Update the value of 'n' keys in the current table, if they already exist. This will return
-    the number of keys that were updated as an unsigned integer.
-  return: [Integer, Rcode 5]
-- name: DEL
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [DEL <key1> <key2> ...]
-  desc: |
-    Delete 'n' keys from the current table. This will return the number of keys that were deleted
-    as an unsigned integer
-  return: [Integer, Rcode 5]
-- name: EXISTS
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [EXISTS <key1> <key2> ...]
-  desc: |
-    Check if 'n' keys exist in the current table. This will return the number of keys that exist
-    as an unsigned integer.
-  return: [Integer]
-- name: SSET
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [SSET <key1> <value1> <key2> <value2> ...]
-  desc: Set all keys to the given values only if all of them don't exist in the current table
-  return: [Rcode 0, Rcode 2, Rcode 5]
-- name: SDEL
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [SDEL <key1> <key2> ...]
-  desc: |
-    Delete all keys if all of the keys exist in the current table. Do note that if a single key doesn't
-    exist, then a `Nil` code is returned.
-  return: [Rcode 0, Rcode 1, Rcode 5]
-- name: SUPDATE
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [SUPDATE <key1> <value1> <key2> <value2> ...]
-  desc: |
-    Update all keys if all of the keys exist in the current table. Do note that if a single key doesn't
-    exist, then a `Nil` code is returned.
-  return: [Rcode 0, Rcode 1, Rcode 5]
-- name: DBSIZE
-  complexity: O(1)
-  accept: [AnyArray]
-  syntax: [DBSIZE, DBSIZE <entity>]
-  desc: Check the number of entries stored in the current table or in the provided entity
-  return: [Integer]
-- name: FLUSHDB
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [FLUSHDB, FLUSHDB <entity>]
-  desc: Removes all entries stored in the current table or in the provided entity
-  return: [Rcode 0, Rcode 5]
-- name: USET
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [USET <key1> <value1> <key2> <value2> ...]
-  desc: SET all keys if they don't exist, or UPDATE them if they do exist. This operation performs `USET`s in the current table
-  return: [Integer, Rcode 5]
-- name: KEYLEN
-  complexity: O(1)
-  accept: [AnyArray]
-  syntax: [KEYLEN <key>]
-  desc: Returns the length of the UTF-8 string, if it exists in the current table
-  return: [Integer, Rcode 1]
-- name: MKSNAP
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [MKSNAP, MKSNAP <SNAPNAME>]
-  desc: |
-    This action can be used to create a snapshot. Do note that this action **requires
-    snapshotting to be enabled on the server side**, before it can create snapshots.
-    If you want to create snapshots **without** snapshots being enabled on the server-side,
-    pass a second argument `<SNAPNAME>` to specify a snapshot name and a snapshot will
-    be create in a folder called `rsnap` under your data directory. For more
-    information on snapshots, read [this document](/snapshots)
-  return: [Rcode 0, err-snapshot-disabled, err-snapshot-busy]
-- name: LSKEYS
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [LSKEYS <limit>, LSKEYS <entity>, LSKEYS <entity> <limit>]
-  desc: |
-    Returns a flat string array of keys present in the current table or in the provided entity.
-    If no `<limit>` is given, then a maximum of 10 keys are returned. If a limit is specified,
-    then a maximum of `<limit>` keys are returned. The order of keys is meaningless.
-  return: [Typed Array]
-- name: POP
-  complexity: O(1)
-  accept: [AnyArray]
-  syntax: [POP <key>]
-  desc: |
-    Deletes and return the value of the provided key from the current table.
-    If the database is poisoned, this will return a server error.
-  return: [String, Binstr, Rcode 5]
-- name: MPOP
-  complexity: O(n)
-  accept: [AnyArray]
-  syntax: [MPOP <key1> <key2> ...]
-  desc: |
-    Deletes and returns the values of the provided 'n' keys from the current table.
-    If the database is poisoned, this will return a server error
-  return: [Typed Array, Rcode 5]
-- name: HEYA
-  complexity: O(1)
-  accept: [AnyArray]
-  syntax: [HEYA, HEYA <message>]
-  desc: |
-    Either returns a "HEY!" or returns the provided argument as an `str`
-  return: [String]
+global:
+  - name: HEYA
+    complexity: O(1)
+    accept: [AnyArray]
+    syntax: [HEYA, HEYA <message>]
+    desc: |
+      Either returns a "HEY!" or returns the provided argument as an `str`
+    return: [String]
+  - name: DBSIZE
+    complexity: O(1)
+    accept: [AnyArray]
+    syntax: [DBSIZE, DBSIZE <entity>]
+    desc: Check the number of entries stored in the current table or in the provided entity
+    return: [Integer]
+  - name: MKSNAP
+    complexity: O(n)
+    accept: [AnyArray]
+    syntax: [MKSNAP, MKSNAP <SNAPNAME>]
+    desc: |
+      This action can be used to create a snapshot. Do note that this action **requires
+      snapshotting to be enabled on the server side**, before it can create snapshots.
+      If you want to create snapshots **without** snapshots being enabled on the server-side,
+      pass a second argument `<SNAPNAME>` to specify a snapshot name and a snapshot will
+      be create in a folder called `rsnap` under your data directory. For more
+      information on snapshots, read [this document](/snapshots)
+    return: [Rcode 0, err-snapshot-disabled, err-snapshot-busy]
+  - name: FLUSHDB
+    complexity: O(n)
+    accept: [AnyArray]
+    syntax: [FLUSHDB, FLUSHDB <entity>]
+    desc: Removes all entries stored in the current table or in the provided entity
+    return: [Rcode 0, Rcode 5]
+keyvalue:
+  generic:
+    - name: DEL
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [DEL <key1> <key2> ...]
+      desc: |
+        Delete 'n' keys from the current table. This will return the number of keys that were deleted
+        as an unsigned integer
+      return: [Integer, Rcode 5]
+    - name: EXISTS
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [EXISTS <key1> <key2> ...]
+      desc: |
+        Check if 'n' keys exist in the current table. This will return the number of keys that exist
+        as an unsigned integer.
+      return: [Integer]
+    - name: LSKEYS
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [LSKEYS <limit>, LSKEYS <entity>, LSKEYS <entity> <limit>]
+      desc: |
+        Returns a flat string array of keys present in the current table or in the provided entity.
+        If no `<limit>` is given, then a maximum of 10 keys are returned. If a limit is specified,
+        then a maximum of `<limit>` keys are returned. The order of keys is meaningless.
+      return: [Typed Array]
+  string:
+    - name: GET
+      complexity: O(1)
+      accept: [AnyArray]
+      syntax: [GET <key>]
+      desc: Get the value of a key from the current table, if it exists
+      return: [Rcode 1, String, Binstr]
+    - name: MGET
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [MGET <key1> <key2> ...]
+      desc: Get the value of 'n' keys from the current table, if they exist
+      return: [Typed Array]
+    - name: SET
+      complexity: O(1)
+      accept: [AnyArray]
+      syntax: [SET <key> <value>]
+      desc: Set the value of a key in the current table, if it doesn't already exist
+      return: [Rcode 0, Rcode 2, Rcode 5]
+    - name: MSET
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [MSET <key1> <value1> <key2> <value2> ...]
+      desc: |
+        Set the value of 'n' keys in the current table, if they don't already exist. This will
+        return the number of keys that were set as an unsigned integer.
+      return: [Integer, Rcode 5]
+    - name: UPDATE
+      complexity: O(1)
+      accept: [AnyArray]
+      syntax: [UPDATE <key> <value>]
+      desc: Update the value of an existing key in the current table
+      return: [Rcode 0, Rcode 1, Rcode 5]
+    - name: MUPDATE
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [MUPDATE <key1> <value1> <key2> <value2> ...]
+      desc: |
+        Update the value of 'n' keys in the current table, if they already exist. This will return
+        the number of keys that were updated as an unsigned integer.
+      return: [Integer, Rcode 5]
+    - name: SSET
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [SSET <key1> <value1> <key2> <value2> ...]
+      desc: Set all keys to the given values only if all of them don't exist in the current table
+      return: [Rcode 0, Rcode 2, Rcode 5]
+    - name: SDEL
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [SDEL <key1> <key2> ...]
+      desc: |
+        Delete all keys if all of the keys exist in the current table. Do note that if a single key doesn't
+        exist, then a `Nil` code is returned.
+      return: [Rcode 0, Rcode 1, Rcode 5]
+    - name: SUPDATE
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [SUPDATE <key1> <value1> <key2> <value2> ...]
+      desc: |
+        Update all keys if all of the keys exist in the current table. Do note that if a single key doesn't
+        exist, then a `Nil` code is returned.
+      return: [Rcode 0, Rcode 1, Rcode 5]
+    - name: USET
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [USET <key1> <value1> <key2> <value2> ...]
+      desc: SET all keys if they don't exist, or UPDATE them if they do exist. This operation performs `USET`s in the current table
+      return: [Integer, Rcode 5]
+    - name: KEYLEN
+      complexity: O(1)
+      accept: [AnyArray]
+      syntax: [KEYLEN <key>]
+      desc: Returns the length of the UTF-8 string, if it exists in the current table
+      return: [Integer, Rcode 1]
+    - name: POP
+      complexity: O(1)
+      accept: [AnyArray]
+      syntax: [POP <key>]
+      desc: |
+        Deletes and return the value of the provided key from the current table.
+        If the database is poisoned, this will return a server error.
+      return: [String, Binstr, Rcode 5]
+    - name: MPOP
+      complexity: O(n)
+      accept: [AnyArray]
+      syntax: [MPOP <key1> <key2> ...]
+      desc: |
+        Deletes and returns the values of the provided 'n' keys from the current table.
+        If the database is poisoned, this will return a server error
+      return: [Typed Array, Rcode 5]
+  lists:
+    - name: LGET
+      desc: |
+        `LGET` can be used to access the items in a list. Through the sub-actions provided by `lget`,
+         you can access multiple or individual elements in lists.
+      subactions:
+        - name: LGET
+          complexity: O(n)
+          accept: [AnyArray]
+          syntax: [LGET <list>]
+          desc: |
+            Returns all the values contained in a the provided list, if it exists in the current
+            table.
+          return: [Typed Array, Rcode 1]
+        - name: limit
+          complexity: O(n)
+          accept: [AnyArray]
+          syntax: [LGET <list> limit <limit>]
+          desc: Returns a maximum of `limit` values from the provided list, if it exists in the current table
+          return: [Typed Array, Rcode 1]
+        - name: len
+          complexity: O(1)
+          accept: [AnyArray]
+          syntax: [LGET <list> len]
+          desc: Returns the length of the list
+          return: [Integer, Rcode 1]
+        - name: valueat
+          complexity: O(1)
+          accept: [AnyArray]
+          syntax: [LGET <list> valueat <index>]
+          desc: Returns the element present at the provided `index`, if it exists in the given list.
+          return: [String, binstr, Rcode 1, list-bad-index]
+        - name: first
+          complexity: O(1)
+          accept: [AnyArray]
+          syntax: [LGET <list> first]
+          desc: Returns the first element present in the list, if it exists.
+          return: [String, binstr, Rcode 1, list-is-empty]
+        - name: last
+          complexity: O(1)
+          accept: [AnyArray]
+          syntax: [LGET <list> last]
+          desc: Returns the last element present in the list, if it exists.
+          return: [String, binstr, Rcode 1, list-is-empty]
+    - name: LMOD
+      desc: |
+        `LMOD` can be used to mutate the elements in a list
+      subactions:
+        - name: push
+          complexity: O(1)
+          accept: [AnyArray]
+          syntax: [LMOD <list> push <value>]
+          desc: Appends the element to the end of the provided list
+          return: [Rcode 0, Rcode 1, Rcode 5]
+        - name: insert
+          complexity: O(1)
+          accept: [AnyArray]
+          syntax: [LMOD <list> insert <index> <value>]
+          desc: |
+            Inserts the element to the provided index, if it is valid while shifting elements
+            to the right if required
+          return: [Rcode 0, Rcode 1, Rcode 5, bad-list-index]
+        - name: pop
+          complexity: O(1)
+          accept: [AnyArray]
+          syntax: [LMOD <list> pop, LMOD <list> pop <index>]
+          desc: |
+            Removes the element from the end of the list if no index is provided or from the provided
+            index while shifting elements to the right if required.
+          return: [String, Binstr, Rcode 0, Rcode 1, Rcode 5, bad-list-index]
+        - name: remove
+          complexity: O(1)
+          accept: [AnyArray]
+          syntax: [LMOD <list> remove <index>]
+          desc: |
+            Removes the element at the provided index from the list, shifting elements to the right
+            if required.
+          return: [Rcode 0, Rcode 1, Rcode 5, bad-list-index]
+        - name: clear
+          complexity: O(n)
+          accept: [AnyArray]
+          syntax: [LMOD <list> clear]
+          desc: |
+            Removes all the elements present in the list
+          return: [Rcode 0, Rcode 1, Rcode 5]
+    - name: LSET
+      desc: |
+        `LSET` can be used to create empty lists or lists with the provided values.
+      subactions:
+        - name: LSET
+          complexity: O(n)
+          accept: [AnyArray]
+          syntax: [LSET <list>, LSET <list> <value1> <value2> ...]
+          desc: |
+            Creates a list with the provided values, or simply creates an empty list if it doesn't
+            already exist in the table.
+          return: [Rcode 0, Rcode 1, Rcode 5]