diff --git a/modules/commands/admin-only-auth.lua b/config/command_auth_admin.lua
similarity index 100%
rename from modules/commands/admin-only-auth.lua
rename to config/command_auth_admin.lua
diff --git a/expcore/common_parse.lua b/config/command_parse_general.lua
similarity index 100%
rename from expcore/common_parse.lua
rename to config/command_parse_general.lua
diff --git a/config/permission_groups.lua b/config/permission_groups.lua
new file mode 100644
index 00000000..d171bdcc
--- /dev/null
+++ b/config/permission_groups.lua
@@ -0,0 +1,135 @@
+local Event = require 'utils.event'
+local Game = require 'utils.game'
+local Permission_Groups = require 'expcore.permission_groups'
+
+Permission_Groups.new_group('Admin')
+:allow_all()
+:disallow{
+    'add_permission_group', -- admin
+    'delete_permission_group',
+    --'edit_permission_group', -- removed for admin till role script added
+    'import_permissions_string',
+    'map_editor_action',
+    'toggle_map_editor',
+    'change_multiplayer_config',
+    'set_heat_interface_mode',
+    'set_heat_interface_temperature',
+    'set_infinity_container_filter_item',
+    'set_infinity_container_remove_unfiltered_items',
+    'set_infinity_pipe_filter'
+}
+
+Permission_Groups.new_group('Trusted')
+:allow_all()
+:disallow{
+    'add_permission_group', -- admin
+    'delete_permission_group',
+    'edit_permission_group',
+    'import_permissions_string',
+    'map_editor_action',
+    'toggle_map_editor',
+    'change_multiplayer_config',
+    'set_heat_interface_mode',
+    'set_heat_interface_temperature',
+    'set_infinity_container_filter_item',
+    'set_infinity_container_remove_unfiltered_items',
+    'set_infinity_pipe_filter',
+    'admin_action' -- trusted
+}
+
+Permission_Groups.new_group('Standard')
+:allow_all()
+:disallow{
+    'add_permission_group', -- admin
+    'delete_permission_group',
+    'edit_permission_group',
+    'import_permissions_string',
+    'map_editor_action',
+    'toggle_map_editor',
+    'change_multiplayer_config',
+    'set_heat_interface_mode',
+    'set_heat_interface_temperature',
+    'set_infinity_container_filter_item',
+    'set_infinity_container_remove_unfiltered_items',
+    'set_infinity_pipe_filter',
+    'admin_action', -- trusted
+    'change_programmable_speaker_alert_parameters', -- standard
+    'drop_item',
+    'reset_assembling_machine',
+    'set_auto_launch_rocket',
+    'cancel_research'
+}
+
+Permission_Groups.new_group('Guest')
+:allow_all()
+:disallow{
+    'add_permission_group', -- admin
+    'delete_permission_group',
+    'edit_permission_group',
+    'import_permissions_string',
+    'map_editor_action',
+    'toggle_map_editor',
+    'change_multiplayer_config',
+    'set_heat_interface_mode',
+    'set_heat_interface_temperature',
+    'set_infinity_container_filter_item',
+    'set_infinity_container_remove_unfiltered_items',
+    'set_infinity_pipe_filter',
+    'admin_action', -- trusted
+    'change_programmable_speaker_alert_parameters', -- standard
+    'drop_item',
+    'reset_assembling_machine',
+    'set_auto_launch_rocket',
+    'cancel_research',
+    'change_programmable_speaker_parameters', -- guest
+    'change_train_stop_station',
+    'deconstruct',
+    'remove_cables',
+    'remove_train_station',
+    'reset_assembling_machine',
+    'rotate_entity',
+    'use_artillery_remote',
+    'launch_rocket'
+}
+
+Permission_Groups.new_group('Restricted')
+:disallow_all()
+:allow('write_to_console')
+
+--- These events are used until a role system is added to make it easier for our admins
+
+local trusted_time = 60*60*60*10 -- 10 hour
+local standard_time = 60*60*60*3 -- 3 hour
+local function assign_group(player)
+    if player.admin then
+        Permission_Groups.set_player_group(player,'Admin')
+    elseif player.online_time > trusted_time then
+        Permission_Groups.set_player_group(player,'Trusted')
+    elseif player.online_time > standard_time then
+        Permission_Groups.set_player_group(player,'Standard')
+    else
+        Permission_Groups.set_player_group(player,'Guest')
+    end
+end
+
+Event.add(defines.events.on_player_joined_game,function(event)
+    local player = Game.get_player_by_index(event.player_index)
+    assign_group(player)
+end)
+
+Event.add(defines.events.on_player_promoted,function(event)
+    local player = Game.get_player_by_index(event.player_index)
+    assign_group(player)
+end)
+
+Event.add(defines.events.on_player_demoted,function(event)
+    local player = Game.get_player_by_index(event.player_index)
+    assign_group(player)
+end)
+
+local check_interval = 60*60*15 -- 15 minutes
+Event.on_nth_tick(check_interval,function(event)
+    for _,player in pairs(game.connected_players) do
+        assign_group(player)
+    end
+end)
\ No newline at end of file
diff --git a/control.lua b/control.lua
index fa24c311..aff18c15 100644
--- a/control.lua
+++ b/control.lua
@@ -24,6 +24,7 @@ local files = {
     'modules.commands.cheat-mode',
     'modules.commands.interface',
     'modules.commands.help',
+    'config.permission_groups'
 }
 
 -- Loads all files in array above and logs progress
diff --git a/expcore/common.lua b/expcore/common.lua
index 23d3678d..1f7f6448 100644
--- a/expcore/common.lua
+++ b/expcore/common.lua
@@ -1,11 +1,28 @@
+--- Adds some commonly used functions used in many modules
+-- @author cooldude2606
+-- @module Public
+--[[
+>>>>Functions List (see function for more detail):
+    Public.type_check(value,test_type) --- Compare types faster for faster validation of prams
+    Public.type_check_error(value,test_type,error_message,level) --- Raises an error if the value is of the incorrect type
+    Public.param_check(value,test_type,param_name,param_number) --- Raises an error when the value is the incorrect type, uses a consistent error message format
+
+    Public.extract_keys(tbl,...) --- Extracts certain keys from a table
+
+    Public.player_return(value,colour,player) --- Will return a value of any type to the player/server console, allows colour for in-game players
+
+    Public.opt_require(path) --- Calls a require that will not error if the file is not found
+    Public.ext_require(path,...) --- Calls a require and returns only the keys given, file must return a table
+]]
+
 local Colours = require 'resources.color_presets'
 local Game = require 'utils.game'
 
 local Public = {}
 
---- Compare types faster for faster validation of prams
--- @usage is_type('foo','string') -- return true
--- @usage is_type('foo') -- return false
+--- Compare types faster for faster validation of params
+-- @usage type_check('foo','string') -- return true
+-- @usage type_check('foo') -- return false
 -- @param v the value to be tested
 -- @tparam[opt=nil] string test_type the type to test for if not given then it tests for nil
 -- @treturn boolean is v of type test_type
@@ -13,6 +30,47 @@ function Public.type_check(value,test_type)
     return test_type and value and type(value) == test_type or not test_type and not value or false
 end
 
+--- Raises an error if the value is of the wrong type
+-- @usage type_check_error('foo','number','Value must be a number') -- will raise error "Value must be a number"
+-- @tparam value any the value that you want to test the type of
+-- @tparam test_type string the type that the value should be
+-- @tparam error_message string the error message that is returned
+-- @tparam level number the level to call the error on (level = 1 means the caller)
+-- @treturn boolean true if no error was called
+function Public.type_check_error(value,test_type,error_message,level)
+    level = level and level+1 or 2
+    return Public.test_type(value,test_type) or error(error_message,level)
+end
+
+--- Raises an error when the value is the incorrect type, uses a consistent error message format
+-- @usage param_check('foo','number','repeat_count',2) -- will raise error "Invalid param #02 given to <anon>; repeat_count is not of type number"
+-- @tparam value any the value that you want to test the type of
+-- @tparam test_type string the type that the value should be
+-- @tparam param_name string the name of the param
+-- @tparam param_number number the number param it is
+-- @treturn boolean true if no error was raised
+function Public.param_check(value,test_type,param_name,param_number)
+    if not Public.test_type(value,test_type) then
+        local function_name = debug.getinfo(2,'n').name or '<anon>'
+        local error_message = string.format('Invalid param #%2d given to %s; %s is not of type %s',param_number,function_name,param_name,test_type)
+        return error(error_message,3)
+    end
+    return true
+end
+
+--- Extracts certain keys from a table
+-- @usage local key_three, key_one = extract({key_one='foo',key_two='bar',key_three=true},'key_three','key_one')
+-- @tparam tbl table the table which contains the keys
+-- @tparam ... string the names of the keys you want extracted
+-- @return the keys in the order given
+function Public.extract_keys(tbl,...)
+    local values = {}
+    for _,key in pairs({...}) do
+        table.insert(values,tbl[key])
+    end
+    return unpack(values)
+end
+
 --- Will return a value of any type to the player/server console, allows colour for in-game players
 -- @usage player_return('Hello, World!') -- returns 'Hello, World!' to game.player or server console
 -- @usage player_return('Hello, World!','green') -- returns 'Hello, World!' to game.player with colour green or server console
@@ -54,4 +112,27 @@ function Public.player_return(value,colour,player)
     else rcon.print(returnAsString) end
 end
 
+--- Calls a require that will not error if the file is not found
+-- @usage local file = opt_require('file.not.present') -- will not cause any error
+-- @tparam path string the path that you want to require
+-- @return the returns from that file or nil, error if not loaded
+function Public.opt_require(path)
+    local success, rtn = pcall(require,path)
+    if success then return rtn
+    else return nil,rtn end
+end
+
+--- Calls a require and returns only the keys given, file must return a table
+-- @useage local extract, param_check = ext_require('expcore.common','extract','param_check')
+-- @tparam path string the path that you want to require
+-- @tparam ... string the name of the keys that you want returned
+-- @return the keys in the order given
+function Public.ext_require(path,...)
+    local rtn = require(path)
+    if type(rtn) ~= 'table' then
+        error('File did not return a table, can not extract keys.',2)
+    end
+    return Public.extract_keys(rtn,...)
+end
+
 return Public
\ No newline at end of file
diff --git a/expcore/permission_groups.lua b/expcore/permission_groups.lua
new file mode 100644
index 00000000..a237bf80
--- /dev/null
+++ b/expcore/permission_groups.lua
@@ -0,0 +1,283 @@
+--- Permission group making for factorio so you never have to make one by hand again
+-- @author Cooldude2606
+-- @module Permissions_Groups
+--[[
+>>>>Example Group (Allow All)
+
+    -- here we will create an admin group however we do not want them to use the map editor or mess with the permission groups
+    Permission_Groups.new_group('Admin') -- this defines a new group called "Admin"
+    :allow_all() -- this makes the default to allow any input action unless set other wise
+    :disallow{ -- here we disallow the input action we dont want them to use
+        'add_permission_group',
+        'delete_permission_group',
+        'import_permissions_string',
+        'map_editor_action',
+        'toggle_map_editor'
+    }
+
+>>>>Example Group (Disallow All)
+
+    -- here we will create a group that cant do anything but talk in chat
+    Permission_Groups.new_group('Restricted') -- this defines a new group called "Restricted"
+    :disallow_all() -- this makes the default to disallow any input action unless set other wise
+    :allow('write_to_console') -- here we allow them to chat, {} can be used here if we had more than one action
+
+>>>>Functions List (see function for more detail):
+    Permissions_Groups.new_group(name) --- Defines a new permission group that can have it actions set in the config
+    Permissions_Groups.get_group_by_name(name) --- Returns the group with the given name, case sensitive
+    Permissions_Groups.get_group_from_player(player) --- Returns the group that a player is in
+
+    Permissions_Groups.reload_permissions() --- Reloads/creates all permission groups and sets them to they configured state
+    Permissions_Groups.lockdown_permissions(exempt) --- Removes all permissions from every permission group except for "Default" and any passed as exempt
+
+    Permissions_Groups.set_player_group(player,group) --- Sets a player's group to the one given, a player can only have one group at a time
+
+    Permissions_Groups._prototype:set_action(action,state) --- Sets the allow state of an action for this group, used internally but is safe to use else where
+    Permissions_Groups._prototype:allow(actions) --- Sets an action or actions to be allowed for this group even with disallow_all triggered, Do not use in runtime
+    Permissions_Groups._prototype:disallow(actions) --- Sets an action or actions to be disallowed for this group even with allow_all triggered, Do not use in runtime
+    Permissions_Groups._prototype:allow_all() --- Sets the default state for any actions not given to be allowed, useful with :disallow
+    Permissions_Groups._prototype:disallow_all() --- Sets the default state for any action not given to be disallowed, useful with :allow
+    Permissions_Groups._prototype:is_allowed(action) --- Returns if an input action is allowed for this group
+
+    Permissions_Groups._prototype:get_raw() --- Returns the LuaPermissionGroup that was created with this group object, used internally
+    Permissions_Groups._prototype:create() --- Creates or updates the permission group with the configured actions, used internally
+
+    Permissions_Groups._prototype:add_player(player) --- Adds a player to this group
+    Permissions_Groups._prototype:remove_player(player) --- Removes a player from this group
+    Permissions_Groups._prototype:get_players(online) --- Returns all player that are in this group with the option to filter to online/offline only
+
+    Permissions_Groups._prototype:print(message) --- Prints a message to every player in this group
+]]
+
+
+local Game = require 'utils.game'
+local Event = require 'utils.event'
+
+local Permissions_Groups = {
+    groups={}, -- store for the different groups that are created
+    _prototype={} -- stores functions that are used on group instances
+}
+
+--- Defines a new permission group that can have it actions set in the config
+-- @tparam name string the name of the new group
+-- @treturn Permissions_Groups._prototype the new group made with function to allow and disallow actions
+function Permissions_Groups.new_group(name)
+    local group = setmetatable({
+        name=name,
+        actions={},
+        allow_all_actions=true
+    },{
+        __index= Permissions_Groups._prototype
+    })
+    Permissions_Groups.groups[name] = group
+    return group
+end
+
+--- Returns the group with the given name, case sensitive
+-- @tparam name string the name of the group to get
+-- @treturn ?Permissions_Groups._prototype|nil the group with that name or nil if non found
+function Permissions_Groups.get_group_by_name(name)
+    return Permissions_Groups.groups[name]
+end
+
+--- Returns the group that a player is in
+-- @tparam LuaPlayer the player to get the group of can be LuaPlayer name index etc
+-- @treturn ?Permissions_Groups._prototype|nil the group with that player or nil if non found
+function Permissions_Groups.get_group_from_player(player)
+    player = Game.get_player_from_any(player)
+    if not player then return end
+    local group = player.permission_group
+    if group then
+        return Permissions_Groups.groups[group.name]
+    end
+end
+
+--- Reloads/creates all permission groups and sets them to they configured state
+function Permissions_Groups.reload_permissions()
+    for _,group in pairs(Permissions_Groups.groups) do
+        group:create()
+    end
+end
+
+--- Removes all permissions from every permission group except for "Default" and any passed as exempt
+-- @tparam string|Array<string> any groups that you want to be except, "Default" is always exempt
+-- @treturn number the number of groups that had they permissions removed
+function Permissions_Groups.lockdown_permissions(exempt)
+    local count = 0
+    if type(exempt) ~= 'table' then
+        exempt = {exempt}
+    end
+    for _,group in pairs(exempt) do
+        if type(group) == 'string' then
+            exempt[group:lower()] = true
+        elseif type(group) == 'table' then
+            exempt[group.name:lower()] = true
+        end
+    end
+    for _,group in pairs(game.permissions.groups) do
+        if not exempt[group.name:lower()] and not group.name == 'Default' then
+            count = count +1
+            for _,action in pairs(defines.input_action) do
+                group.set_allows_action(action,false)
+            end
+        end
+    end
+    return count
+end
+
+--- Sets a player's group to the one given, a player can only have one group at a time
+-- @tparam LuaPlayer the player to effect can be LuaPlayer name index etc
+-- @tparam string the name of the group to give to the player
+-- @treturn boolean true if the player was added successfully, false other wise
+function Permissions_Groups.set_player_group(player,group)
+    player = Game.get_player_from_any(player)
+    local group = Permissions_Groups.get_group_by_name(group)
+    if not group or not player then return false end
+    group:add_player(player)
+    return true
+end
+
+--- Sets the allow state of an action for this group, used internally but is safe to use else where
+-- @tparam action ?string|defines.input_action the action that you want to set the state of
+-- @tparam state boolean the state that you want to set it to, true = allow, false = disallow
+-- @treturn Permissions_Groups._prototype returns self so function can be chained
+function Permissions_Groups._prototype:set_action(action,state)
+    if type(action) == 'string' then
+        action = defines.input_action[action]
+    end
+    self.actions[action] = state
+    return self
+end
+
+--- Sets an action or actions to be allowed for this group even with disallow_all triggered, Do not use in runtime
+-- @tparam string|Array<string> the action or actions that you want to allow for this group
+-- @treturn Permissions_Groups._prototype returns self so function can be chained
+function Permissions_Groups._prototype:allow(actions)
+    if type(actions) ~= 'table' then
+        actions = {actions}
+    end
+    for _,action in pairs(actions) do
+        self:set_action(action,true)
+    end
+    return self
+end
+
+--- Sets an action or actions to be disallowed for this group even with allow_all triggered, Do not use in runtime
+-- @tparam string|Array<string> the action or actions that you want to disallow for this group
+-- @treturn Permissions_Groups._prototype returns self so function can be chained
+function Permissions_Groups._prototype:disallow(actions)
+    if type(actions) ~= 'table' then
+        actions = {actions}
+    end
+    for _,action in pairs(actions) do
+        self:set_action(action,false)
+    end
+    return self
+end
+
+--- Sets the default state for any actions not given to be allowed, useful with :disallow
+-- @treturn Permissions_Groups._prototype returns self so function can be chained
+function Permissions_Groups._prototype:allow_all()
+    self.allow_all_actions = true
+    return self
+end
+
+--- Sets the default state for any action not given to be disallowed, useful with :allow
+-- @treturn Permissions_Groups._prototype returns self so function can be chained
+function Permissions_Groups._prototype:disallow_all()
+    self.allow_all_actions = false
+    return self
+end
+
+--- Returns if an input action is allowed for this group
+-- @tparam action ?string|defines.input_action the action that you want to test for
+-- @treturn boolean true if the group is allowed the action, false other wise
+function Permissions_Groups._prototype:is_allowed(action)
+    if type(action) == 'string' then
+        action = defines.input_action[action]
+    end
+    local state = self.actions[action]
+    if state == nil then
+        state = self.allow_all_actions
+    end
+    return state
+end
+
+--- Returns the LuaPermissionGroup that was created with this group object, used internally
+-- @treturn LuaPermissionGroup the raw lua permission group
+function Permissions_Groups._prototype:get_raw()
+    return game.permissions.get_group(self.name)
+end
+
+--- Creates or updates the permission group with the configured actions, used internally
+-- @treturn LuaPermissionGroup the permission group that was created
+function Permissions_Groups._prototype:create()
+    local group = self:get_raw()
+    if not group then
+        group = game.permissions.create_group(self.name)
+    end
+    for _,action in pairs(defines.input_action) do
+        group.set_allows_action(action,self:is_allowed(action))
+    end
+    return group
+end
+
+--- Adds a player to this group
+-- @tparam player LuaPlayer the player you want to add to this group can be LuaPlayer name or index etc
+-- @treturn boolean true if the player was added successfully, false other wise
+function Permissions_Groups._prototype:add_player(player)
+    player = Game.get_player_from_any(player)
+    local group = self:get_raw()
+    if not group or not player then return false end
+    group.add_player(player)
+    return true
+end
+
+--- Removes a player from this group
+-- @tparam player LuaPlayer the player you want to remove from this group can be LuaPlayer name or index etc
+-- @treturn boolean true if the player was removed successfully, false other wise
+function Permissions_Groups._prototype:remove_player(player)
+    player = Game.get_player_from_any(player)
+    local group = self:get_raw()
+    if not group or not player then return false end
+    group.remove_player(player)
+    return true
+end
+
+--- Returns all player that are in this group with the option to filter to online/offline only
+-- @tparam[opt] online boolean if nil returns all players, if true online players only, if false returns online players only
+-- @treturn table a table of players that are in this group; filtered if online param is given
+function Permissions_Groups._prototype:get_players(online)
+    local players = {}
+    local group = self:get_raw()
+    if group then
+        if online == nil then
+            return group.players
+        else
+            for _,player in pairs(group.players) do
+                if player.connected == online then
+                    table.insert(player,player)
+                end
+            end
+        end
+    end
+    return players
+end
+
+--- Prints a message to every player in this group
+-- @tparam message string the message that you want to send to the players
+-- @treturn number the number of players that received the message
+function Permissions_Groups._prototype:print(message)
+    local players = self:get_players(true)
+    for _,player in pairs(players) do
+        player.print(message)
+    end
+    return #players
+end
+
+-- when the game starts it will make the permission groups
+Event.on_init(function()
+    Permissions_Groups.reload_permissions()
+end)
+
+return Permissions_Groups
\ No newline at end of file
diff --git a/modules/commands/admin-chat.lua b/modules/commands/admin-chat.lua
index a178349c..00ae2d5d 100644
--- a/modules/commands/admin-chat.lua
+++ b/modules/commands/admin-chat.lua
@@ -1,6 +1,6 @@
 local Commands = require 'expcore.commands'
-require 'expcore.common_parse'
-require 'modules.commands.admin-only-auth'
+require 'config.command_parse_general'
+require 'config.command_auth_admin'
 
 Commands.new_command('admin-chat','Sends a message in chat that only admins can see.')
 :add_param('message',false) -- the message to send in the admin chat
diff --git a/modules/commands/cheat-mode.lua b/modules/commands/cheat-mode.lua
index c2a1b206..71ea9d15 100644
--- a/modules/commands/cheat-mode.lua
+++ b/modules/commands/cheat-mode.lua
@@ -1,6 +1,6 @@
 local Commands = require 'expcore.commands'
-require 'expcore.common_parse'
-require 'modules.commands.admin-only-auth'
+require 'config.command_parse_general'
+require 'config.command_auth_admin'
 
 Commands.new_command('toggle-cheat-mode','Toggles cheat mode for your player, or another player.')
 :add_param('player',true,'player') -- player to toggle chest mode of, can be nil for self
diff --git a/modules/commands/help.lua b/modules/commands/help.lua
index 432560f6..07e1c572 100644
--- a/modules/commands/help.lua
+++ b/modules/commands/help.lua
@@ -1,6 +1,6 @@
 local Commands = require 'expcore.commands'
 local Global = require 'utils.global'
-require 'expcore.common_parse'
+require 'config.command_parse_general'
 
 local results_per_page = 5
 
diff --git a/modules/commands/interface.lua b/modules/commands/interface.lua
index 43306a41..d4354721 100644
--- a/modules/commands/interface.lua
+++ b/modules/commands/interface.lua
@@ -1,13 +1,14 @@
 local Commands = require 'expcore.commands'
 local Global = require 'utils.global'
 local Common = require 'expcore.common'
-require 'modules.commands.admin-only-auth'
+require 'config.command_auth_admin'
 
 -- modules that are loaded into the interface env to be accessed
 local interface_modules = {
     ['Game']='utils.game',
     ['Commands']=Commands,
-    ['output']=Common.player_return
+    ['output']=Common.player_return,
+    ['Group']='expcore.permission_groups'
 }
 
 -- loads all the modules given in the above table
diff --git a/modules/commands/kill.lua b/modules/commands/kill.lua
index a5c990c3..7ecb5c90 100644
--- a/modules/commands/kill.lua
+++ b/modules/commands/kill.lua
@@ -1,6 +1,6 @@
 local Commands = require 'expcore.commands'
-require 'expcore.common_parse'
-require 'modules.commands.admin-only-auth'
+require 'config.command_parse_general'
+require 'config.command_auth_admin'
 
 Commands.new_command('kill','Kills yourself or another player.')
 :add_param('player',true,'player-alive') -- the player to kill, must be alive to be valid
diff --git a/modules/commands/tag.lua b/modules/commands/tag.lua
index f8f8d1d9..97ae6c21 100644
--- a/modules/commands/tag.lua
+++ b/modules/commands/tag.lua
@@ -1,5 +1,5 @@
 local Commands = require 'expcore.commands'
-require 'expcore.common_parse'
+require 'config.command_parse_general'
 
 Commands.new_command('tag','Sets your player tag.')
 :add_param('tag',false,'string-max-length',20) -- new tag for your player max 20 char
diff --git a/modules/commands/teleport.lua b/modules/commands/teleport.lua
index bcb64ee8..05f33a76 100644
--- a/modules/commands/teleport.lua
+++ b/modules/commands/teleport.lua
@@ -1,6 +1,6 @@
 local Commands = require 'expcore.commands'
-require 'expcore.common_parse'
-require 'modules.commands.admin-only-auth'
+require 'config.command_parse_general'
+require 'config.command_auth_admin'
 
 local function teleport(from_player,to_player)
     local surface = to_player.surface