> For the complete documentation index, see [llms.txt](https://atiysus-organization.gitbook.io/aty-scripts/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://atiysus-organization.gitbook.io/aty-scripts/inventory/reference/commands.md).

# Commands

## Commands

{% hint style="warning" %}
Everything on this page except the player keys and commands, and the client-side development commands at the end, is **admin-gated or console-only**. The diagnostic and development sections are for a dev server — review them before opening a production console to staff.
{% endhint %}

#### Player

Registered as rebindable FiveM keybinds, changeable in **Settings → Key Bindings → FiveM**.

| Key     | Opens                                                                                                                                                                                      |
| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `F2`    | Your inventory — in a vehicle its glovebox, at a stash or shop point that point. Also closes it                                                                                            |
| `K`     | What is in front of you: the boot of the car behind you, the glovebox while seated, a bin or vending machine. Also closes the inventory                                                    |
| `TAB`   | Shows the quick slots (bag slots 1–5) for three seconds; press again to hide                                                                                                               |
| `1`–`5` | Use whatever is in bag slot 1–5 — a weapon is drawn, a second press holsters it. Nothing while the inventory is open, during a progress bar, or while dead, ragdolled, falling or shooting |
| —       | Search a person: unbound — bind it, or use `/search` / `/steal`                                                                                                                            |

`/inv` opens the inventory the way `F2` does, for when another resource has taken the key.

As in ox\_inventory, `F2` and `K` do not open anything during a progress bar (ox\_lib's `invBusy`, qb's `inv_busy`) or while the player is dead or cuffed, and an open inventory closes when one of those starts or the vehicle the player is sitting in changes. Cuffs are read from the framework as well as from the ped, so qb-policejob's cuffs count. The server also refuses every item move from a player who is down or cuffed, and closes their panel.

#### Everyday admin

| Command                                          | Does                                                                                           |
| ------------------------------------------------ | ---------------------------------------------------------------------------------------------- |
| `invadmin`                                       | Open the admin panel                                                                           |
| `giveitem <playerId> <item> [count]`             | Give an item (in game or console; registered only when qb-inventory is not running)            |
| `invgive <playerId\|inventoryId> <item> [count]` | Give an item through the export, from the console                                              |
| `invtake <playerId\|inventoryId> <item> [count]` | Take an item                                                                                   |
| `invtakeslot <inventoryId> <slot> [count]`       | Take one slot (the whole slot by default)                                                      |
| `clearinv <playerId\|inventoryId>`               | Empty an inventory; a snapshot file is written first (in game with no argument it clears you)  |
| `invsearch <playerId> [targetId]`                | What a search by that player would find: who is in front, their state, and the verdict         |
| `invweight <playerId>`                           | What their client says they carry, the move rate that costs, and whether it is held on the ped |
| `invwho [playerId]`                              | What this resource thinks a player is: identifier, job, money, and the standalone view         |

#### Audit & integrity

| Command                               | Does                                                                                                      |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------- |
| `invtrace <serial>`                   | One unit's whole life                                                                                     |
| `invaudit [full \| sweep]`            | Integrity scan: duplicates; `full` adds ghosts and orphaned bags; `sweep` removes empty orphaned bag rows |
| `invrollback <tx_id> confirm`         | Reverse one transaction                                                                                   |
| `invreport [hours]`                   | What exists, what is being made, what is being burned (24 h by default)                                   |
| `invcheck [inventoryId]`              | What the server holds in memory — every loaded container, or one container's slots                        |
| `invwriteoff <serial\|all> [confirm]` | Write off a ghost deliberately                                                                            |
| `invgains [hours]`                    | Containers that gained value from nowhere, at shop prices                                                 |
| `invstamp [confirm]`                  | Give every unique item that still has none its serial                                                     |

#### Items, shops, recipes

| Command                                          | Does                                                                                                                                                 |
| ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invitemdef <item>`                              | Show a definition — where it comes from, overrides, and for weapons and ammo what it takes, holds and loads as                                       |
| `invoverride`                                    | Definition overrides                                                                                                                                 |
| `invusables`                                     | List registered use handlers                                                                                                                         |
| `invroute <item>`                                | Who runs an item when it is used — this resource, a claim, or the framework handler — plus the clip, the prop and whether it has a condition         |
| `invrehash [confirm]`                            | Recompute every stored item's metadata hash, so identical metadata stacks again                                                                      |
| `invrecipes`                                     | The recipe book as the server holds it (`invcraft` and `invrecipewrite` are self-tests — see below)                                                  |
| `invclientrecipes <id>` · `invpanelrecipes <id>` | The recipe book as that player's CLIENT holds it, and as their open panel is showing it — for when the server knows a recipe and the screen does not |
| `invpricing [item]` · `invpricingrun`            | Dynamic pricing                                                                                                                                      |

#### Player state

| Command                                                                       | Does               |
| ----------------------------------------------------------------------------- | ------------------ |
| `invwear` · `invvariant` · `invoutfit`                                        | Clothing           |
| `invweapon` · `invammo` · `invspecialammo`                                    | Weapons            |
| `invlicence <playerId> [name]` · `invlicence <playerId> grant\|revoke <name>` | Licences           |
| `invpin`                                                                      | Pinning            |
| `invbag`                                                                      | Bags               |
| `invdecay`                                                                    | What is ageing     |
| `invskill` · `invneeds`                                                       | Skills and needs   |
| `invnote` · `invrename`                                                       | Notes and renaming |

#### World

| Command                                               | Does                                                                                    |
| ----------------------------------------------------- | --------------------------------------------------------------------------------------- |
| `invplace [del <shop\|stash> <id>]` · `invplacejson`  | Shops and stashes made from the panel (`invplacejson` is a self-test of the JSON paste) |
| `invplaced [remove <id>]` · `invplacelive <playerId>` | Placed objects                                                                          |
| `invairdrop [x y z]` · `invairdrops`                  | Airdrops (`invairdropwrite` is a self-test)                                             |
| `invlocks` · `invlockcheck <netId>`                   | Container locks held right now; what the server reads as a vehicle's lock               |

#### Setup & migration

| Command                                                                 | Does                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ----------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invdoctor`                                                             | **Full install check.** Run after any change                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `invmigrate items [write]`                                              | Import framework (or ox\_inventory) item definitions; `write` generates `data/items.generated.lua`                                                                                                                                                                                                                                                                                                                                                                                |
| `invmigrate scan` · `invmigrate run [allow-unknown] [force]`            | Migrate player data                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `invqbxkeys [confirm]`                                                  | Qbox only, once: move bags keyed on the licence to the citizenid                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `invammoconvert [confirm \| skip] [<item>=<rounds> …] [online] [force]` | Once, when moving from box to single ammunition: multiplies every stored ammo stack by the rounds one box held. Dry run without `confirm`. `confirm` writes `ammo_before_convert_<time>.json` first. A run the database stops halfway is finished by the next `confirm`, which converts only what it had not reached (`ammo_convert_unfinished.json`). `skip` records single mode without converting. `force <item>=<rounds>` is only for boxes that arrived after the conversion |
| `invimport [<id>] [run] [allow-unknown] [force]`                        | Import another inventory's tables                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `invimport export`                                                      | Dump what this inventory holds to `export_<time>.json`                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `invrestore <file> <inventoryId> confirm`                               | Put one container back from an export file — `export_…`, `export_before_force_…`, `ammo_before_convert_…` or `clear_…` (the `clearinv` snapshot). Dry run without `confirm`                                                                                                                                                                                                                                                                                                       |
| `invsettings [set <path> <value> \| clear <path>]`                      | Values saved from the admin panel, beside the file's; `clear` puts the file value back                                                                                                                                                                                                                                                                                                                                                                                            |
| `invlang <playerId>`                                                    | Which language packs that player's client loaded                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `invwebhook [test]`                                                     | Test Discord webhooks                                                                                                                                                                                                                                                                                                                                                                                                                                                             |

{% hint style="danger" %}
`invmigrate run` and `invimport <id> run` **write**. Their dry runs are `invmigrate scan` and `invimport <id>`; `run` is the word that commits. A forced `invimport` writes `export_before_force_<time>.json` first, which `invrestore` reads. An inventory migration is not reversible in any way a player would accept — read the dry run before you type the second word, and take a database backup first.
{% endhint %}

#### Diagnostics & self-tests

Safe to run, read-only unless noted. These are how you prove a bug rather than describe it.

| Command                                                                                                                                                                                                                           | Does                                                                                                                                                                                                                                    |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invchecklist`                                                                                                                                                                                                                    | Stateful 24-section manual test walkthrough                                                                                                                                                                                             |
| `invstress`                                                                                                                                                                                                                       | Conservation test over the dupe patterns (a resent request, rapid moves of one slot, two actors racing) — the last line ends `CONSERVED` or `LEAK`                                                                                      |
| `invstressdb` · `invstresstx`                                                                                                                                                                                                     | Database and transaction stress                                                                                                                                                                                                         |
| `invghosttest`                                                                                                                                                                                                                    | Ghost detection                                                                                                                                                                                                                         |
| `invperf`                                                                                                                                                                                                                         | Performance counters                                                                                                                                                                                                                    |
| `invmirror` · `invbridge` · `invforeign`                                                                                                                                                                                          | Framework bridge state                                                                                                                                                                                                                  |
| `invwallet <playerId> [account]`                                                                                                                                                                                                  | Which backend holds the money — the bridge's framework, Qbox, or the cash item — and what it reads                                                                                                                                      |
| `invmoneyadopt <item> on\|off`                                                                                                                                                                                                    | Overrides the money mirror's one-time choice for a server switching from `framework`: `on` adds each character's loose `<item>` to their account once, `off` lets the wallet win                                                        |
| `invqbmethods <playerId> [item]`                                                                                                                                                                                                  | The qb player methods a script finds on that player, and whether calling them works — a **dead reference** belongs to an older instance of this resource                                                                                |
| `invqbcall <playerId> <item>`                                                                                                                                                                                                     | Call the framework's own handler for an item and report whether it survived                                                                                                                                                             |
| `invprop <playerId> <model> [x y z rx ry rz] [bone] [clip]`                                                                                                                                                                       | Hold a model in that player's hand and nudge it into place; ENTER prints the values for `data/items.lua` and for the panel                                                                                                              |
| `invapi <playerId>`                                                                                                                                                                                                               | Exercises the ox and qb compat exports on that player                                                                                                                                                                                   |
| `invexport <playerId> [item]`                                                                                                                                                                                                     | Adds one item through the compat exports, as a foreign script would                                                                                                                                                                     |
| `invunload <playerId>`                                                                                                                                                                                                            | Saves a player's bag and drops it from memory, so the next read comes from the database                                                                                                                                                 |
| `invtarget <playerId>`                                                                                                                                                                                                            | Whether look-and-click works for that player: target script, zones registered, whether the key still opens                                                                                                                              |
| `invadmintest` · `invairdroptest` · `invbind` · `invcraft` · `invdeathtest` · `invevidence` · `invlicencetest` · `invoutfittest` · `invplacedtest` · `invpricingtest` · `invrestock` · `invstashreg` · `invtrade` · `invweartest` | Per-feature self-tests (`invrestock`: shelves refilling, on a test shop; `invtrade`: the trade table; `invbind`: items that stay with you)                                                                                              |
| `invrecipewrite` · `invairdropwrite`                                                                                                                                                                                              | Drive the recipe / loot-table editors through the panel's own endpoint. **They put back everything they change** despite the names — a form that posts perfectly to an endpoint that refuses is a form that looks fine and does nothing |

#### Development only

`camtest`, `drawtest`, `invbench`, `invbin`, `invbite`, `invdemo`, `invdemoconfirm`, `invconfirm`, `invmove`, `invrestack`, `invrestrict`, `invsort`, `invtarget`, `cfgshow`, `trunk`, `trunkcheck`, `weapcheck`, `wearcheck`.

`camtest`, `drawtest`, `cfgshow`, `trunk`, `trunkcheck`, `weapcheck`, `wearcheck` are client commands any player can type, and so is `invtarget` in a player's own F8 console (from the server console it takes a `<playerId>`). The rest are console only.

{% hint style="warning" %}
Remove or permission-lock this group before production. They exist to build and debug the resource, not to run a server.
{% endhint %}