routeros-command-tree
RouterOS command tree introspection via /console/inspect API. Use when: building tools that parse RouterOS commands, generating API schemas from RouterOS, working with /console/inspect, mapping CLI commands to REST verbs, traversing the RouterOS command hierarchy, or when the use
Install
npx skills add https://github.com/tikoci/routeros-skills/tree/main/routeros-command-tree
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install tikoci-routeros-skills@llmmart
git clone https://github.com/tikoci/routeros-skills.git
The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole tikoci/routeros-skills collection as a plugin from our marketplace. Git is the plain clone.
Skill manifest
RouterOS Command Tree & /console/inspect
Overview
RouterOS organizes all configuration and commands in a hierarchical tree. Every path in the CLI
(like /ip/address/add) corresponds to a node in this tree. The /console/inspect REST endpoint
lets you programmatically explore the entire tree — this is how tools like restraml (RAML/OpenAPI
schema generator) and rosetta (MCP command lookup) build their databases.
The Command Tree Structure
RouterOS's command hierarchy has four node types:
| Node Type | Meaning | Example |
|---|---|---|
dir |
Directory — contains child paths | /ip, /system |
path |
Path — a navigable level (often has commands) | /ip/address, /interface/bridge |
cmd |
Command — an executable action | add, set, print, remove, get, export |
arg |
Argument — a parameter to a command | address=, interface=, disabled= |
Tree Example
/ (root dir)
├── ip/ (dir)
│ ├── address/ (path)
│ │ ├── add (cmd)
│ │ │ ├── address (arg) — "IP address"
│ │ │ ├── interface (arg) — "Interface name"
│ │ │ └── disabled (arg) — "yes | no"
│ │ ├── set (cmd)
│ │ ├── remove (cmd)
│ │ ├── get (cmd)
│ │ ├── print (cmd)
│ │ └── export (cmd)
│ ├── route/ (path)
│ │ └── ...
│ └── dns/ (path)
│ ├── set (cmd)
│ ├── cache/ (path)
│ │ ├── print (cmd)
│ │ └── flush (cmd)
│ └── ...
├── interface/ (dir)
│ └── ...
├── system/ (dir)
│ └── ...
└── ...
/console/inspect API
Endpoint
POST /rest/console/inspect
Requires basic authentication. Available on all RouterOS 7.x versions.
Request Types
| Request | Purpose | Returns |
|---|---|---|
child |
List children of a path | Array of {type: "child", name, "node-type"} |
syntax |
Get help text for a node | Array of {type: "syntax", text} |
highlight |
Syntax highlighting data | Per-byte token classes — see the routeros-syntax-inspection skill |
completion |
Tab-completion suggestions | Completion candidates — see routeros-syntax-inspection for validity checking |
Listing Children
// List children of /ip
const children = await fetch(`${base}/console/inspect`, {
method: "POST",
headers: { ...authHeaders, "Content-Type": "application/json" },
body: JSON.stringify({
request: "child",
path: "ip",
}),
}).then(r => r.json());
// Response:
// [
// { "type": "child", "name": "address", "node-type": "path" },
// { "type": "child", "name": "arp", "node-type": "path" },
// { "type": "child", "name": "cloud", "node-type": "path" },
// { "type": "child", "name": "dhcp-client", "node-type": "path" },
// { "type": "child", "name": "dns", "node-type": "path" },
// { "type": "child", "name": "route", "node-type": "path" },
// ...
// ]
Getting Syntax Help
// Get description for /ip/address/add → address argument
const syntax = await fetch(`${base}/console/inspect`, {
method: "POST",
headers: { ...authHeaders, "Content-Type": "application/json" },
body: JSON.stringify({
request: "syntax",
path: "ip,address,add,address", // comma-separated path
}),
}).then(r => r.json());
// Response:
// [{ "type": "syntax", "text": "IP address" }]
Path Format
The path field uses comma-separated segments (not slashes):
- Root:
""(empty string) /ip:"ip"/ip/address:"ip,address"/ip/address/add:"ip,address,add"/ip/address/add → address arg:"ip,address,add,address"
When using the JavaScript Array.toString() method, this comma-separated format is produced
naturally from an array: ["ip", "address", "add"].toString() → "ip,address,add".
Tree Traversal Pattern
To walk the entire tree recursively:
async function walkTree(path = [], tree = {}) {
const children = await fetchInspect("child", path.toString());
for (const child of children) {
if (child.type !== "child") continue;
const childPath = [...path, child.name];
tree[child.name] = { _type: child["node-type"] };
// For args, fetch the syntax description — but NOT inside dangerous subtrees
if (child["node-type"] === "arg") {
if (DANGEROUS_PATHS.some(p => childPath.includes(p))) continue;
const syntax = await fetchInspect("syntax", childPath.toString());
if (syntax.length === 1 && syntax[0].text.length > 0) {
tree[child.name].desc = syntax[0].text;
}
}
// Recurse into this child (child enumeration is safe even in dangerous subtrees)
await walkTree(childPath, tree[child.name]);
}
return tree;
}
Dangerous Paths — Conservative Skip Policy
Old RouterOS versions can deadlock the REST server when scripting-keyword paths are
queried for syntax/completion via /console/inspect. Crawlers conservatively skip
syntax lookups inside subtrees containing any of these names:
where, do, else, rule, command, on-error
These are RouterOS scripting constructs. Treat the six-path list as a conservative
crawler skip policy, not a timeless crash invariant: live probing in
tikoci/restraml (MikroTik support case SUP-127641)
isolated the confirmed deadlock to bare do with request=syntax/completion on
RouterOS ≤7.20.8 — the other five paths return [] instantly there — and found it
fixed by 7.21.4. (The original six-path folklore came from sequential probing: once
do hangs the server, every path tested after it appears to crash too.) Enumerating
children (child request) is safe on all tested versions, as are nested paths like
["do","command"].
The conservative approach (used in the example above) skips the entire arg when any
ancestor matches a dangerous path, and pairs every request with a short timeout on old
or unknown versions. The actual rest2raml.js implementation matches this pattern.
const DANGEROUS_PATHS = ["where", "do", "else", "rule", "command", "on-error"];
CLI Command → REST Verb Mapping
RouterOS CLI commands map to HTTP verbs in the REST API:
| CLI Command | HTTP Verb | REST URL Pattern | Notes |
|---|---|---|---|
get (print) |
GET |
/rest/ip/address |
Returns array of all entries |
get (single) |
GET |
/rest/ip/address/*1 |
Single entry by ID |
add |
PUT |
/rest/ip/address |
Creates new entry (not POST!) |
set |
PATCH |
/rest/ip/address/*1 |
Updates existing entry |
remove |
DELETE |
/rest/ip/address/*1 |
Deletes entry by ID |
print |
POST |
/rest/ip/address/print |
Action-style (also works as GET) |
| Other commands | POST |
/rest/path/command |
Action — reboot, flush, etc. |
Key insight: REST PUT = create, PATCH = update. This is the opposite of many REST API conventions where PUT is idempotent update and POST is create.
RAML/OpenAPI Schema Generation
When generating API schemas from the command tree:
- Walk the tree to collect all paths, commands, and arguments
- For each
cmdnode:get→ generates bothGET /path(list) andGET /path/{id}(single)add→ generatesPUT /pathwith arg-based request bodyset→ generatesPATCH /path/{id}with arg-based request bodyremove→ generatesDELETE /path/{id}- Other commands →
POST /path/command
- For each
argunder a command, generate request body properties or query parameters - The
descfield from syntax lookups becomes the description
The .proplist and .query Parameters
All POST-based command endpoints accept two special parameters:
.proplist— selects which properties to return (like SQL SELECT).query— filter expression array (like SQL WHERE)
These are RouterOS REST API conventions, not standard REST patterns.
Output Formats
The inspect tree can be converted to multiple schema formats:
inspect.json (Raw Output)
The raw tree as returned by recursive /console/inspect calls. Each node has:
{
"address": {
"_type": "path",
"add": {
"_type": "cmd",
"address": { "_type": "arg", "desc": "IP address" },
"interface": { "_type": "arg", "desc": "Interface name" }
},
"set": { "_type": "cmd", ... },
"print": { "_type": "cmd", ... }
}
}
RAML 1.0 (schema.raml)
Converted to RAML 1.0 resource/method notation:
/ip:
/address:
get:
queryParameters: ...
responses: ...
put:
body:
application/json:
properties:
address: { type: any, description: "IP address" }
/{id}:
get: ...
patch: ...
delete: ...
OpenAPI 3.0 (openapi.json)
Standard OpenAPI 3.0 schema generated from the same inspect tree (7.21.1+).
The inspect.json Data Model
Each version's inspect.json is the canonical source of truth for that RouterOS version's
command tree. It captures:
- Every navigable path in the CLI hierarchy
- Every executable command at each path level
- Every argument (parameter) for each command
- Syntax descriptions for arguments
Tools can parse inspect.json offline without needing a live router — set INSPECTFILE env var
and the schema generator will use the cached file instead of querying a router.
Common Patterns for Working with the Tree
Finding Commands at a Path
// Given an inspect.json node for /ip/address
const node = inspectData.ip.address;
// Commands are children with _type === "cmd"
const commands = Object.entries(node)
.filter(([key, val]) => val._type === "cmd")
.map(([key]) => key);
// → ["add", "set", "remove", "get", "print", "export", ...]
Finding Arguments for a Command
// Arguments of /ip/address/add
const addCmd = inspectData.ip.address.add;
const args = Object.entries(addCmd)
.filter(([key, val]) => val._type === "arg")
.map(([key, val]) => ({ name: key, description: val.desc }));
// → [{name: "address", description: "IP address"}, ...]
Traversing Directories
// Directories and paths (navigable children)
const children = Object.entries(node)
.filter(([key, val]) => val._type === "dir" || val._type === "path")
.map(([key]) => key);
Performance Notes
- Full tree traversal takes many minutes against a live router (thousands of HTTP requests,
each a separate POST to
/console/inspect). With KVM acceleration the CHR responds quickly, but the sheer number of sequential requests adds up. - Each
/console/inspectcall is a separate HTTP request — no batch API - Use
INSPECTFILEfor development/testing to avoid repeated live queries - The tree is version-specific — different RouterOS versions have different command sets
- Extra packages (container, iot, zerotier, etc.) add additional command tree branches
- Over the native API,
request=completioncan silently omit candidates (measured on 7.22.1);=.proplist=completioncuts the drops but doesn't end them. Use REST when the list must be complete. See the hazard table inrouteros-syntax-inspection.
Architecture Changes the Tree
A tree taken from an x86 CHR is not the whole command set. Some packages are
not built for x86, so their menus never appear there. With all extra packages
installed on both, restraml's 7.23beta5 CHR crawl found 46,483 shared paths,
plus 1,433 only on arm64 and 37 only on x86. /zerotier and
/interface/ethernet/switch (the switch-marvell subtree, present even
without switch hardware) appeared in the arm64 crawl only.1
- Use the tree for the architecture you target, or compare both per-architecture
files as restraml does (
deep-inspect.x86.jsonanddeep-inspect.arm64.json, with a published diff per version underdocs/<version>/extra/). restraml deliberately doesn't merge them. - A path missing from an x86-only tree proves nothing about other architectures. rosetta keys its command data on version and architecture for this reason; its version check notes when a path is in its arm64 data only and which versions were extracted for x86 alone.
- Completion enums can differ between the two trees too (1,137 arguments differed in the same crawl).
Additional Resources
- MikroTik's new manual site has a browsable CLI Reference at
https://manual.mikrotik.com/docs/CLI%20Reference/. It exposes command menus,
flags, argument names, and types by package/path (for example,
/docs/CLI%20Reference/system/ip/address). Treat it as the human-readable companion to/console/inspect; when it disagrees with a live router,/console/inspectfrom that router wins. - For REST API details: see
routeros-fundamentalsskill → REST API patterns - For running a CHR to query: see the
routeros-qemu-chrskill - For /app YAML format (a feature visible in the tree under 7.22+): see the
routeros-app-yamlskill
-
tikoci/restraml
docs/deep-inspect.md, "Reference local baseline" (7.23beta5, all extra packages on both architectures). For a later version, see the published 7.26beta4 diff.↩
Files (routeros-skills)
-
SKILL.md 13.8 KB
--- name: routeros-command-tree description: "RouterOS command tree introspection via /console/inspect API. Use when: building tools that parse RouterOS commands, generating API schemas from RouterOS, working with /console/inspect, mapping CLI commands to REST verbs, traversing the RouterOS command hierarchy, or when the user mentions inspect, command tree, RAML, or OpenAPI generation for RouterOS." --- # RouterOS Command Tree & /console/inspect ## Overview RouterOS organizes all configuration and commands in a **hierarchical tree**. Every path in the CLI (like `/ip/address/add`) corresponds to a node in this tree. The `/console/inspect` REST endpoint lets you **programmatically explore the entire tree** — this is how tools like `restraml` (RAML/OpenAPI schema generator) and `rosetta` (MCP command lookup) build their databases. ## The Command Tree Structure RouterOS's command hierarchy has four node types: | Node Type | Meaning | Example | |---|---|---| | `dir` | Directory — contains child paths | `/ip`, `/system` | | `path` | Path — a navigable level (often has commands) | `/ip/address`, `/interface/bridge` | | `cmd` | Command — an executable action | `add`, `set`, `print`, `remove`, `get`, `export` | | `arg` | Argument — a parameter to a command | `address=`, `interface=`, `disabled=` | ### Tree Example ```text / (root dir) ├── ip/ (dir) │ ├── address/ (path) │ │ ├── add (cmd) │ │ │ ├── address (arg) — "IP address" │ │ │ ├── interface (arg) — "Interface name" │ │ │ └── disabled (arg) — "yes | no" │ │ ├── set (cmd) │ │ ├── remove (cmd) │ │ ├── get (cmd) │ │ ├── print (cmd) │ │ └── export (cmd) │ ├── route/ (path) │ │ └── ... │ └── dns/ (path) │ ├── set (cmd) │ ├── cache/ (path) │ │ ├── print (cmd) │ │ └── flush (cmd) │ └── ... ├── interface/ (dir) │ └── ... ├── system/ (dir) │ └── ... └── ... ``` ## /console/inspect API ### Endpoint ```text POST /rest/console/inspect ``` Requires basic authentication. Available on all RouterOS 7.x versions. ### Request Types | Request | Purpose | Returns | |---|---|---| | `child` | List children of a path | Array of `{type: "child", name, "node-type"}` | | `syntax` | Get help text for a node | Array of `{type: "syntax", text}` | | `highlight` | Syntax highlighting data | Per-byte token classes — see the `routeros-syntax-inspection` skill | | `completion` | Tab-completion suggestions | Completion candidates — see `routeros-syntax-inspection` for validity checking | ### Listing Children ```typescript // List children of /ip const children = await fetch(`${base}/console/inspect`, { method: "POST", headers: { ...authHeaders, "Content-Type": "application/json" }, body: JSON.stringify({ request: "child", path: "ip", }), }).then(r => r.json()); // Response: // [ // { "type": "child", "name": "address", "node-type": "path" }, // { "type": "child", "name": "arp", "node-type": "path" }, // { "type": "child", "name": "cloud", "node-type": "path" }, // { "type": "child", "name": "dhcp-client", "node-type": "path" }, // { "type": "child", "name": "dns", "node-type": "path" }, // { "type": "child", "name": "route", "node-type": "path" }, // ... // ] ``` ### Getting Syntax Help ```typescript // Get description for /ip/address/add → address argument const syntax = await fetch(`${base}/console/inspect`, { method: "POST", headers: { ...authHeaders, "Content-Type": "application/json" }, body: JSON.stringify({ request: "syntax", path: "ip,address,add,address", // comma-separated path }), }).then(r => r.json()); // Response: // [{ "type": "syntax", "text": "IP address" }] ``` ### Path Format The `path` field uses **comma-separated** segments (not slashes): - Root: `""` (empty string) - `/ip`: `"ip"` - `/ip/address`: `"ip,address"` - `/ip/address/add`: `"ip,address,add"` - `/ip/address/add → address arg`: `"ip,address,add,address"` When using the JavaScript `Array.toString()` method, this comma-separated format is produced naturally from an array: `["ip", "address", "add"].toString()` → `"ip,address,add"`. ## Tree Traversal Pattern To walk the entire tree recursively: ```typescript async function walkTree(path = [], tree = {}) { const children = await fetchInspect("child", path.toString()); for (const child of children) { if (child.type !== "child") continue; const childPath = [...path, child.name]; tree[child.name] = { _type: child["node-type"] }; // For args, fetch the syntax description — but NOT inside dangerous subtrees if (child["node-type"] === "arg") { if (DANGEROUS_PATHS.some(p => childPath.includes(p))) continue; const syntax = await fetchInspect("syntax", childPath.toString()); if (syntax.length === 1 && syntax[0].text.length > 0) { tree[child.name].desc = syntax[0].text; } } // Recurse into this child (child enumeration is safe even in dangerous subtrees) await walkTree(childPath, tree[child.name]); } return tree; } ``` ### Dangerous Paths — Conservative Skip Policy Old RouterOS versions can **deadlock the REST server** when scripting-keyword paths are queried for syntax/completion via `/console/inspect`. Crawlers conservatively skip syntax lookups inside subtrees containing any of these names: ```text where, do, else, rule, command, on-error ``` These are RouterOS scripting constructs. Treat the six-path list as a **conservative crawler skip policy, not a timeless crash invariant**: live probing in [tikoci/restraml](https://github.com/tikoci/restraml) (MikroTik support case SUP-127641) isolated the confirmed deadlock to bare `do` with `request=syntax`/`completion` on RouterOS ≤7.20.8 — the other five paths return `[]` instantly there — and found it **fixed by 7.21.4**. (The original six-path folklore came from sequential probing: once `do` hangs the server, every path tested after it appears to crash too.) Enumerating children (`child` request) is safe on all tested versions, as are nested paths like `["do","command"]`. The conservative approach (used in the example above) skips the entire arg when any ancestor matches a dangerous path, and pairs every request with a short timeout on old or unknown versions. The actual `rest2raml.js` implementation matches this pattern. ```typescript const DANGEROUS_PATHS = ["where", "do", "else", "rule", "command", "on-error"]; ``` ## CLI Command → REST Verb Mapping RouterOS CLI commands map to HTTP verbs in the REST API: | CLI Command | HTTP Verb | REST URL Pattern | Notes | |---|---|---|---| | `get` (print) | `GET` | `/rest/ip/address` | Returns array of all entries | | `get` (single) | `GET` | `/rest/ip/address/*1` | Single entry by ID | | `add` | `PUT` | `/rest/ip/address` | **Creates** new entry (not POST!) | | `set` | `PATCH` | `/rest/ip/address/*1` | Updates existing entry | | `remove` | `DELETE` | `/rest/ip/address/*1` | Deletes entry by ID | | `print` | `POST` | `/rest/ip/address/print` | Action-style (also works as GET) | | Other commands | `POST` | `/rest/path/command` | Action — reboot, flush, etc. | **Key insight:** REST `PUT` = create, `PATCH` = update. This is the **opposite** of many REST API conventions where PUT is idempotent update and POST is create. ### RAML/OpenAPI Schema Generation When generating API schemas from the command tree: 1. Walk the tree to collect all paths, commands, and arguments 2. For each `cmd` node: - `get` → generates both `GET /path` (list) and `GET /path/{id}` (single) - `add` → generates `PUT /path` with arg-based request body - `set` → generates `PATCH /path/{id}` with arg-based request body - `remove` → generates `DELETE /path/{id}` - Other commands → `POST /path/command` 3. For each `arg` under a command, generate request body properties or query parameters 4. The `desc` field from syntax lookups becomes the description ### The .proplist and .query Parameters All POST-based command endpoints accept two special parameters: - `.proplist` — selects which properties to return (like SQL SELECT) - `.query` — filter expression array (like SQL WHERE) These are RouterOS REST API conventions, not standard REST patterns. ## Output Formats The inspect tree can be converted to multiple schema formats: ### inspect.json (Raw Output) The raw tree as returned by recursive `/console/inspect` calls. Each node has: ```json { "address": { "_type": "path", "add": { "_type": "cmd", "address": { "_type": "arg", "desc": "IP address" }, "interface": { "_type": "arg", "desc": "Interface name" } }, "set": { "_type": "cmd", ... }, "print": { "_type": "cmd", ... } } } ``` ### RAML 1.0 (schema.raml) Converted to RAML 1.0 resource/method notation: ```yaml /ip: /address: get: queryParameters: ... responses: ... put: body: application/json: properties: address: { type: any, description: "IP address" } /{id}: get: ... patch: ... delete: ... ``` ### OpenAPI 3.0 (openapi.json) Standard OpenAPI 3.0 schema generated from the same inspect tree (7.21.1+). ## The inspect.json Data Model Each version's `inspect.json` is the **canonical source of truth** for that RouterOS version's command tree. It captures: - Every navigable path in the CLI hierarchy - Every executable command at each path level - Every argument (parameter) for each command - Syntax descriptions for arguments Tools can parse `inspect.json` offline without needing a live router — set `INSPECTFILE` env var and the schema generator will use the cached file instead of querying a router. ## Common Patterns for Working with the Tree ### Finding Commands at a Path ```typescript // Given an inspect.json node for /ip/address const node = inspectData.ip.address; // Commands are children with _type === "cmd" const commands = Object.entries(node) .filter(([key, val]) => val._type === "cmd") .map(([key]) => key); // → ["add", "set", "remove", "get", "print", "export", ...] ``` ### Finding Arguments for a Command ```typescript // Arguments of /ip/address/add const addCmd = inspectData.ip.address.add; const args = Object.entries(addCmd) .filter(([key, val]) => val._type === "arg") .map(([key, val]) => ({ name: key, description: val.desc })); // → [{name: "address", description: "IP address"}, ...] ``` ### Traversing Directories ```typescript // Directories and paths (navigable children) const children = Object.entries(node) .filter(([key, val]) => val._type === "dir" || val._type === "path") .map(([key]) => key); ``` ## Performance Notes - **Full tree traversal takes many minutes** against a live router (thousands of HTTP requests, each a separate POST to `/console/inspect`). With KVM acceleration the CHR responds quickly, but the sheer number of sequential requests adds up. - Each `/console/inspect` call is a separate HTTP request — no batch API - Use `INSPECTFILE` for development/testing to avoid repeated live queries - The tree is version-specific — different RouterOS versions have different command sets - Extra packages (container, iot, zerotier, etc.) add additional command tree branches - Over the native API, `request=completion` can silently omit candidates (measured on 7.22.1); `=.proplist=completion` cuts the drops but doesn't end them. Use REST when the list must be complete. See the hazard table in `routeros-syntax-inspection`. ## Architecture Changes the Tree A tree taken from an x86 CHR is not the whole command set. Some packages are not built for x86, so their menus never appear there. With all extra packages installed on both, restraml's 7.23beta5 CHR crawl found 46,483 shared paths, plus 1,433 only on arm64 and 37 only on x86. `/zerotier` and `/interface/ethernet/switch` (the `switch-marvell` subtree, present even without switch hardware) appeared in the arm64 crawl only.[^arch-diff] - Use the tree for the architecture you target, or compare both per-architecture files as restraml does (`deep-inspect.x86.json` and `deep-inspect.arm64.json`, with a published diff per version under `docs/<version>/extra/`). restraml deliberately doesn't merge them. - A path missing from an x86-only tree proves nothing about other architectures. rosetta keys its command data on version and architecture for this reason; its version check notes when a path is in its arm64 data only and which versions were extracted for x86 alone. - Completion enums can differ between the two trees too (1,137 arguments differed in the same crawl). ## Additional Resources - MikroTik's new manual site has a browsable **CLI Reference** at <https://manual.mikrotik.com/docs/CLI%20Reference/>. It exposes command menus, flags, argument names, and types by package/path (for example, `/docs/CLI%20Reference/system/ip/address`). Treat it as the human-readable companion to `/console/inspect`; when it disagrees with a live router, `/console/inspect` from that router wins. - For REST API details: see `routeros-fundamentals` skill → [REST API patterns](../routeros-fundamentals/references/rest-api-patterns.md) - For running a CHR to query: see the `routeros-qemu-chr` skill - For /app YAML format (a feature visible in the tree under 7.22+): see the `routeros-app-yaml` skill [^arch-diff]: [tikoci/restraml `docs/deep-inspect.md`](https://github.com/tikoci/restraml/blob/0893732e0e7860df696ba1203a9704e30e884fb4/docs/deep-inspect.md), "Reference local baseline" (7.23beta5, all extra packages on both architectures). For a later version, see the published [7.26beta4 diff](https://github.com/tikoci/restraml/blob/5f1e490037144d655c2c1ad503f4761043658f34/docs/7.26beta4/extra/diff-deep-inspect.json).
Comments (0)
Sign in to join the conversation.
Reviews (0)
No reviews yet.
No comments yet.