Printago API
PUT /v1/printers

Add multiple printers

Register multiple printers at once. If any `deviceId` is already registered (in any store), nothing is created and the request fails with `409`; the error body lists the conflicting `deviceId`s under `conflicts`.

Requires: printer.create

Request Body

Array of printer configurations

PrinterInsert[]
Array of PrinterInsert, each with:
commMethodrequirednullable
"bambu-global-mqtt" | "bambu-cloud-v2" | "octoprint-mqtt" | "fuse"
bambu-global-mqttbambu-cloud-v2octoprint-mqttfuse
customMetadataoptional
Record<string, any>
Construct a type with a set of properties K of type T
deviceIdrequirednullable
string
enabledrequired
boolean
integrationIdrequirednullable
string
integrationTyperequirednullable
enum
bambulabetsyshopifyebaytiktok-shopwoocommercegoogle-driveonedrive
metadatarequirednullable
object
Variant 1BambuPrinterMetadata
dev_access_coderequired
string
dev_idrequired
string
dev_model_namerequired
string
dev_product_namerequired
string
namerequired
string
nozzle_diameterrequired
number
onlinerequired
boolean
print_statusrequired
string
provideroptional
"bambu"
Variant 2KlipperMetadata
api_keyoptional
string
extruder_countrequired
number
kinematicsoptional
string
max_acceloptional
number
max_velocityoptional
number
mmu_slotsoptional
number
mmu_typeoptional
"none" | "ercf" | "mmu" | "toolchanger"
noneercfmmutoolchanger
moonraker_hostoptional
string
moonraker_portrequired
number
nozzle_diameterrequired
number
providerrequired
"klipper"
Variant 3PrusaMetadata
nozzle_diameterrequired
number
passwordrequired
string
poll_interval_msoptional
number
providerrequired
"prusa"
Variant 4SdcpMetadata
mainboard_idoptional
string
nozzle_diameterrequired
number
providerrequired
"sdcp"
Variant 5OctoPrintMetadata
api_keyrequired
string
hostrequired
string
nozzle_diameteroptional
number
poll_interval_msoptional
number
portrequired
number
providerrequired
"octoprint"
use_httpsoptional
boolean
modelNameoptionalnullable
string
Resolved server-side from `vendorModelId` when omitted.
namerequired
string
nozzleDiameterrequired
string
printerAdapterBindingsPatchoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
anycubicoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
bambuoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
commandsoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
selectTooloptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setBedTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setFanoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setLightoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setNozzleTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
Shape version. Present on v1 payloads; absent on legacy payloads that pre-date the refactor. Resolvers branch on this: v1 uses the adapter- level `commands` map + component kinds; legacy falls back to per-ref prefix conventions so old data keeps rendering.
elegoo-mqttoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
klipperoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
commandsoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
selectTooloptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setBedTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setChamberTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setFanoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setLightoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setNozzleTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
modulesoptionalnullable
string[]
Stable identifiers of fuse-lib Klipper modules that own vendor-specific parsing, subscriptions, side-channel pollers, and commands for this printer. Mixins declare their required modules here; the resolver unions across mixins (see `resolveAdapterBindings`). Names that the running fuse build doesn't recognize are non-fatal — fuse logs a warning and ignores them, matching the same drift-tolerance pattern as `getMixinsForVendorModel`'s `matchType`. Examples: `snapmaker_u1`, `creality_cfs`, `creality_filament_rack`, `creality_k2_commands`.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
octoprintoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
prusaoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
sdcpoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
printerCapabilityPatchoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
axesoptionalnullable
object[]
axisoptional
"x" | "y" | "z"
xyz
flippedoptional
boolean
homeoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
moveoptional
boolean
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
bedsoptionalnullable
object[]
hasMeshoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
temperatureoptional
object
readoptional
boolean
setoptional
boolean
camerasoptionalnullable
object[]
Cameras attached to the printer. Built-in (`mounting:'builtin'`) cameras come from the printer's capability set; external IP/RTSP cameras (`mounting:'external'`) are added via printer config. Replaces the legacy `getCameraProtocol(modelCode)` lookup — all camera config flows through this array.
authoptional
string
Auth credentials for the stream — `Bearer ...`, `user:pass`, or a query-string fragment. Bambu protocols ignore this; their auth is derived from `printer.accessCode`.
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
mountingoptional
"builtin" | "external"
`builtin`: seeded by the capability set, locked in the UI. `external`: user-attached; editable + removable via printer config.
builtinexternal
pathoptional
string
Override the URL path for `mjpeg-http` (default `/`). Used when the stream sits behind a fixed path on the printer's web server — e.g. Mainsail/Fluidd-style `/webcam/?action=stream` for camera-streamer or mjpg-streamer. Combined with `printer.ip + port` to build the full URL when `url` isn't set.
portoptional
number
Override default port for the protocol.
primaryoptional
boolean
When true, this is the printer's primary camera: it owns the bare `printer.id` go2rtc stream key, so the live dashboard/printer tile, periodic snapshots, the print-completion thumbnail, and timelapses all read from it instead of the built-in camera. At most one camera per printer should set this; when none do, the first camera (index 0, normally the built-in) is the implicit primary.
protocoloptional
enum
mjpeg-bamburtsps-bambuwebrtcrtsprtspsmjpeg-httphttp-flvhttp-snapshothttp-snapshot-poll
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
roleoptional
"overhead" | "bed" | "chamber" | "toolhead" | object
UX-only role for grouping/labeling.
Variant 1"overhead"
Variant 2"bed"
Variant 3"chamber"
Variant 4"toolhead"
Variant 5object
lengthoptional
number
Returns the length of a String object.
snapshotsoptional
boolean
Whether to capture periodic snapshots. Defaults true if unset.
timelapseoptional
boolean
Whether to record timelapses. Defaults true if unset.
urloptional
string
Literal stream URL. Required for non-Bambu protocols, EXCEPT for `mjpeg-http` cameras whose endpoint can be synthesized from `printer.ip + port` (path-agnostic MJPEG, e.g. Elegoo Centauri Carbon 2 on `:8080`). Set `url` when the camera is at a third-party absolute address; otherwise just set `port` and let the go2rtc generator build `http://${printer.ip}:${port}/`.
webrtcSignalingoptional
object
SDP-exchange config for `protocol: 'webrtc'`. Required when protocol is `'webrtc'`; ignored otherwise. The transport itself is always standard WebRTC; this only describes how the offer/answer get traded. For `creality-base64-json`, the signaling URL is built from `printer.ip:port` + `path` (e.g. http://192.168.1.26:8000/call/webrtc_local). For `whep`, `path` may be a full URL or a path appended to the camera's base URL.
flavoroptional
"whep" | "creality-base64-json" | "go2rtc-ws"
whepcreality-base64-jsongo2rtc-ws
pathoptional
string
Endpoint path or full URL for the signaling request.
chambersoptionalnullable
object[]
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
temperatureoptional
object
readoptional
boolean
setoptional
boolean
fansoptionalnullable
object[]
controllableoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
nozzleRefoptional
string
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
reportsSpeedoptional
boolean
Whether the printer reports back a live fan speed. Defaults to true (omitted). Set false for write-only fans (e.g. OctoPrint, whose REST API accepts M106 but never surfaces a speed) so diagnostics skip the readback verification instead of failing a check they can't perform.
roleoptional
"part" | "aux" | "chamber" | "hotend" | "exhaust" | object
Variant 1"part"
Variant 2"aux"
Variant 3"chamber"
Variant 4"hotend"
Variant 5"exhaust"
Variant 6object
lengthoptional
number
Returns the length of a String object.
toolRefoptional
string
filamentoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
dynamicSlotsoptionalnullable
boolean
readoptionalnullable
boolean
setInfooptionalnullable
boolean
filamentsoptionalnullable
object[]
Directly-fed filament sources. An array because some printers feed multiple positions simultaneously (Bambu external bay = 2, Snapmaker U1 = 4, Bambu H2D = 2+). Each entry is one loadable position. AMS / MMU / ERCF / CFS / toolchanger live separately under `peripherals` and are presented alongside these in the UI's Filaments view.
canLoadoptional
boolean
True if printer can auto-load filament into this source.
canReadFilamentoptional
boolean
True if printer hardware can read filament info from this source.
canUnloadoptional
boolean
True if printer can auto-unload filament.
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
filesoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
listoptionalnullable
boolean
uploadoptionalnullable
boolean
gcodeoptionalnullable
boolean
lightsoptionalnullable
object[]
dimmableoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
roleoptional
"chamber" | "work" | "indicator" | "strip" | object
Variant 1"chamber"
Variant 2"work"
Variant 3"indicator"
Variant 4"strip"
Variant 5object
lengthoptional
number
Returns the length of a String object.
nozzlesoptionalnullable
object[]
extrudeoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
temperatureoptional
object
readoptional
boolean
setoptional
boolean
toolRefoptional
string
peripheralsoptionalnullable
object[]
canLoadoptional
boolean
canReadFilamentoptional
boolean
canUnloadoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
maxSlotsPerUnitoptional
number
maxUnitsoptional
number
minSlotsPerUnitoptional
number
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
slotsPerUnitoptional
number
typeoptional
"ercf" | "mmu" | "toolchanger" | "ams" | object
Variant 1"ercf"
Variant 2"mmu"
Variant 3"toolchanger"
Variant 4"ams"
Variant 5object
lengthoptional
number
Returns the length of a String object.
printingoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
pauseoptionalnullable
boolean
resumeoptionalnullable
boolean
skipObjectsoptionalnullable
boolean
startoptionalnullable
boolean
stopoptionalnullable
boolean
printOptionsoptionalnullable
object[]
choicesoptional
object[]
For `kind: "enum"`: allowed values with display labels.
labeloptional
string
valueoptional
string
defaultoptional
string | boolean
UI default when the stored providerConfig is null / missing the key.
descriptionoptional
string
Tooltip help text rendered next to the label.
kindoptional
"boolean" | "enum"
booleanenum
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
sensorsoptionalnullable
object[]
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
nozzleRefoptional
string
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
roleoptional
"lidar" | "filament_runout" | "door" | "accelerometer" | "bed_mesh" | object
Variant 1"lidar"
Variant 2"filament_runout"
Variant 3"door"
Variant 4"accelerometer"
Variant 5"bed_mesh"
Variant 6object
lengthoptional
number
Returns the length of a String object.
toolRefoptional
string
toolsoptionalnullable
object[]
fanRefsoptional
string[]
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
nozzleRefsoptional
string[]
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
selectableoptional
boolean
sensorRefsoptional
string[]
providerrequired
enum
OctoPrintPrusaBambuKlipperSDCPElegooMqttAnycubic
tagsoptional
string[]
vendorModelIdoptionalnullable
number
Catalog vendor-model id. Provide this OR (`vendorName` + `modelName`).
vendorNameoptionalnullable
string
Resolved server-side from `vendorModelId` when omitted.

Example Request

application/json 
[
  {
    "vendorModelId": 1,
    "vendorName": "string",
    "modelName": "string",
    "printerCapabilityPatch": {
      "nozzles": [
        {
          "temperature": {
            "read": true,
            "set": true
          },
          "extrude": true,
          "toolRef": "string",
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "tools": [
        {
          "selectable": true,
          "nozzleRefs": [
            "string"
          ],
          "fanRefs": [
            "string"
          ],
          "sensorRefs": [
            "string"
          ],
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "fans": [
        {
          "role": "part",
          "controllable": true,
          "reportsSpeed": true,
          "nozzleRef": "string",
          "toolRef": "string",
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "lights": [
        {
          "role": "chamber",
          "dimmable": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "sensors": [
        {
          "role": "lidar",
          "nozzleRef": "string",
          "toolRef": "string",
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "beds": [
        {
          "temperature": {
            "read": true,
            "set": true
          },
          "hasMesh": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "chambers": [
        {
          "temperature": {
            "read": true,
            "set": true
          },
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "axes": [
        {
          "axis": "x",
          "move": true,
          "home": true,
          "flipped": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "filaments": [
        {
          "canReadFilament": true,
          "canLoad": true,
          "canUnload": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "cameras": [
        {
          "protocol": "mjpeg-bambu",
          "mounting": "builtin",
          "url": "string",
          "port": 1,
          "path": "string",
          "auth": "string",
          "role": "overhead",
          "snapshots": true,
          "timelapse": true,
          "primary": true,
          "webrtcSignaling": {
            "flavor": "whep",
            "path": "string"
          },
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "peripherals": [
        {
          "type": "ercf",
          "maxUnits": 1,
          "slotsPerUnit": 1,
          "minSlotsPerUnit": 1,
          "maxSlotsPerUnit": 1,
          "canReadFilament": true,
          "canLoad": true,
          "canUnload": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "printing": {
        "start": true,
        "pause": true,
        "resume": true,
        "stop": true,
        "skipObjects": true
      },
      "filament": {
        "setInfo": true,
        "read": true,
        "dynamicSlots": true
      },
      "files": {
        "upload": true,
        "list": true
      },
      "gcode": true,
      "printOptions": [
        {
          "kind": "boolean",
          "default": "string",
          "choices": [
            {
              "value": "string",
              "label": "string"
            }
          ],
          "description": "string",
          "ref": "string",
          "label": "string"
        }
      ]
    },
    "printerAdapterBindingsPatch": {
      "bambu": {
        "schemaVersion": 1,
        "commands": {
          "setNozzleTemperature": {},
          "setBedTemperature": {},
          "setFan": {},
          "setLight": {},
          "selectTool": {}
        },
        "components": {},
        "printOptions": {}
      },
      "klipper": {
        "schemaVersion": 1,
        "modules": [
          "string"
        ],
        "commands": {
          "setNozzleTemperature": {},
          "setBedTemperature": {},
          "setFan": {},
          "setLight": {},
          "selectTool": {},
          "setChamberTemperature": {}
        },
        "components": {},
        "printOptions": {}
      },
      "prusa": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      },
      "sdcp": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      },
      "elegoo-mqtt": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      },
      "anycubic": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      },
      "octoprint": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      }
    },
    "name": "string",
    "metadata": {
      "provider": "bambu",
      "name": "string",
      "dev_id": "string",
      "online": true,
      "print_status": "string",
      "dev_model_name": "string",
      "dev_access_code": "string",
      "nozzle_diameter": 1,
      "dev_product_name": "string"
    },
    "integrationId": "string",
    "integrationType": "bambulab",
    "customMetadata": {},
    "tags": [
      "string"
    ],
    "provider": "OctoPrint",
    "deviceId": "string",
    "nozzleDiameter": "string",
    "enabled": true,
    "commMethod": "bambu-global-mqtt"
  }
]

Response Schema

Printer[]
Array of Printer, each with:
bedSizerequirednullable
object
{x,y,z} mm build volume, denormalized from the machine profile's printable_area/printable_height. Cache only — refreshed whenever the printer's machine profile changes; the profile is the source of truth.
xrequired
number
yrequired
number
zrequired
number
commMethodrequirednullable
"bambu-global-mqtt" | "bambu-cloud-v2" | "octoprint-mqtt" | "fuse"
bambu-global-mqttbambu-cloud-v2octoprint-mqttfuse
confirmedReadyrequired
boolean
continuousPrintrequired
boolean
createdAtrequired
string
format: date-time
customMetadataoptional
Record<string, any>
Construct a type with a set of properties K of type T
deviceIdrequirednullable
string
enabledrequired
boolean
fabmaticRemainingJobsrequirednullable
number
idrequired
string
pattern: ^[a-z0-9]{24}$
integrationIdrequirednullable
string
integrationTyperequirednullable
enum
bambulabetsyshopifyebaytiktok-shopwoocommercegoogle-driveonedrive
isAvailablerequired
boolean
isInMaintenanceoptional
boolean
isOnlinerequired
boolean
lastMaintenanceOfflineAtrequirednullable
string
format: date-time
lastMaintenanceOnlineAtrequirednullable
string
format: date-time
lastPrintedAtrequirednullable
string
format: date-time
lifetimeJobCountrequired
number
lifetimePrintHoursrequired
number
machineSystemProfileIdrequirednullable
number
machineUserProfileIdrequirednullable
string
pattern: ^[a-z0-9]{24}$
metadatarequirednullable
object
Variant 1BambuPrinterMetadata
dev_access_coderequired
string
dev_idrequired
string
dev_model_namerequired
string
dev_product_namerequired
string
namerequired
string
nozzle_diameterrequired
number
onlinerequired
boolean
print_statusrequired
string
provideroptional
"bambu"
Variant 2KlipperMetadata
api_keyoptional
string
extruder_countrequired
number
kinematicsoptional
string
max_acceloptional
number
max_velocityoptional
number
mmu_slotsoptional
number
mmu_typeoptional
"none" | "ercf" | "mmu" | "toolchanger"
noneercfmmutoolchanger
moonraker_hostoptional
string
moonraker_portrequired
number
nozzle_diameterrequired
number
providerrequired
"klipper"
Variant 3PrusaMetadata
nozzle_diameterrequired
number
passwordrequired
string
poll_interval_msoptional
number
providerrequired
"prusa"
Variant 4SdcpMetadata
mainboard_idoptional
string
nozzle_diameterrequired
number
providerrequired
"sdcp"
Variant 5OctoPrintMetadata
api_keyrequired
string
hostrequired
string
nozzle_diameteroptional
number
poll_interval_msoptional
number
portrequired
number
providerrequired
"octoprint"
use_httpsoptional
boolean
modelNamerequirednullable
string
Human-readable model name (e.g. "P1S", "Snapmaker U1", "Prusa CORE One")
namerequired
string
nozzleDiameterrequired
string
printerAdapterBindingsPatchrequirednullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
anycubicoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
bambuoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
commandsoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
selectTooloptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setBedTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setFanoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setLightoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setNozzleTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
Shape version. Present on v1 payloads; absent on legacy payloads that pre-date the refactor. Resolvers branch on this: v1 uses the adapter- level `commands` map + component kinds; legacy falls back to per-ref prefix conventions so old data keeps rendering.
elegoo-mqttoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
klipperoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
commandsoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
selectTooloptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setBedTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setChamberTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setFanoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setLightoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
setNozzleTemperatureoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
modulesoptionalnullable
string[]
Stable identifiers of fuse-lib Klipper modules that own vendor-specific parsing, subscriptions, side-channel pollers, and commands for this printer. Mixins declare their required modules here; the resolver unions across mixins (see `resolveAdapterBindings`). Names that the running fuse build doesn't recognize are non-fatal — fuse logs a warning and ignores them, matching the same drift-tolerance pattern as `getMixinsForVendorModel`'s `matchType`. Examples: `snapmaker_u1`, `creality_cfs`, `creality_filament_rack`, `creality_k2_commands`.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
octoprintoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
prusaoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
sdcpoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
componentsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
printOptionsoptionalnullable
Record<string, object>
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
schemaVersionoptionalnullable
1
printerCapabilityPatchrequirednullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
axesoptionalnullable
object[]
axisoptional
"x" | "y" | "z"
xyz
flippedoptional
boolean
homeoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
moveoptional
boolean
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
bedsoptionalnullable
object[]
hasMeshoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
temperatureoptional
object
readoptional
boolean
setoptional
boolean
camerasoptionalnullable
object[]
Cameras attached to the printer. Built-in (`mounting:'builtin'`) cameras come from the printer's capability set; external IP/RTSP cameras (`mounting:'external'`) are added via printer config. Replaces the legacy `getCameraProtocol(modelCode)` lookup — all camera config flows through this array.
authoptional
string
Auth credentials for the stream — `Bearer ...`, `user:pass`, or a query-string fragment. Bambu protocols ignore this; their auth is derived from `printer.accessCode`.
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
mountingoptional
"builtin" | "external"
`builtin`: seeded by the capability set, locked in the UI. `external`: user-attached; editable + removable via printer config.
builtinexternal
pathoptional
string
Override the URL path for `mjpeg-http` (default `/`). Used when the stream sits behind a fixed path on the printer's web server — e.g. Mainsail/Fluidd-style `/webcam/?action=stream` for camera-streamer or mjpg-streamer. Combined with `printer.ip + port` to build the full URL when `url` isn't set.
portoptional
number
Override default port for the protocol.
primaryoptional
boolean
When true, this is the printer's primary camera: it owns the bare `printer.id` go2rtc stream key, so the live dashboard/printer tile, periodic snapshots, the print-completion thumbnail, and timelapses all read from it instead of the built-in camera. At most one camera per printer should set this; when none do, the first camera (index 0, normally the built-in) is the implicit primary.
protocoloptional
enum
mjpeg-bamburtsps-bambuwebrtcrtsprtspsmjpeg-httphttp-flvhttp-snapshothttp-snapshot-poll
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
roleoptional
"overhead" | "bed" | "chamber" | "toolhead" | object
UX-only role for grouping/labeling.
Variant 1"overhead"
Variant 2"bed"
Variant 3"chamber"
Variant 4"toolhead"
Variant 5object
lengthoptional
number
Returns the length of a String object.
snapshotsoptional
boolean
Whether to capture periodic snapshots. Defaults true if unset.
timelapseoptional
boolean
Whether to record timelapses. Defaults true if unset.
urloptional
string
Literal stream URL. Required for non-Bambu protocols, EXCEPT for `mjpeg-http` cameras whose endpoint can be synthesized from `printer.ip + port` (path-agnostic MJPEG, e.g. Elegoo Centauri Carbon 2 on `:8080`). Set `url` when the camera is at a third-party absolute address; otherwise just set `port` and let the go2rtc generator build `http://${printer.ip}:${port}/`.
webrtcSignalingoptional
object
SDP-exchange config for `protocol: 'webrtc'`. Required when protocol is `'webrtc'`; ignored otherwise. The transport itself is always standard WebRTC; this only describes how the offer/answer get traded. For `creality-base64-json`, the signaling URL is built from `printer.ip:port` + `path` (e.g. http://192.168.1.26:8000/call/webrtc_local). For `whep`, `path` may be a full URL or a path appended to the camera's base URL.
flavoroptional
"whep" | "creality-base64-json" | "go2rtc-ws"
whepcreality-base64-jsongo2rtc-ws
pathoptional
string
Endpoint path or full URL for the signaling request.
chambersoptionalnullable
object[]
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
temperatureoptional
object
readoptional
boolean
setoptional
boolean
fansoptionalnullable
object[]
controllableoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
nozzleRefoptional
string
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
reportsSpeedoptional
boolean
Whether the printer reports back a live fan speed. Defaults to true (omitted). Set false for write-only fans (e.g. OctoPrint, whose REST API accepts M106 but never surfaces a speed) so diagnostics skip the readback verification instead of failing a check they can't perform.
roleoptional
"part" | "aux" | "chamber" | "hotend" | "exhaust" | object
Variant 1"part"
Variant 2"aux"
Variant 3"chamber"
Variant 4"hotend"
Variant 5"exhaust"
Variant 6object
lengthoptional
number
Returns the length of a String object.
toolRefoptional
string
filamentoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
dynamicSlotsoptionalnullable
boolean
readoptionalnullable
boolean
setInfooptionalnullable
boolean
filamentsoptionalnullable
object[]
Directly-fed filament sources. An array because some printers feed multiple positions simultaneously (Bambu external bay = 2, Snapmaker U1 = 4, Bambu H2D = 2+). Each entry is one loadable position. AMS / MMU / ERCF / CFS / toolchanger live separately under `peripherals` and are presented alongside these in the UI's Filaments view.
canLoadoptional
boolean
True if printer can auto-load filament into this source.
canReadFilamentoptional
boolean
True if printer hardware can read filament info from this source.
canUnloadoptional
boolean
True if printer can auto-unload filament.
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
filesoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
listoptionalnullable
boolean
uploadoptionalnullable
boolean
gcodeoptionalnullable
boolean
lightsoptionalnullable
object[]
dimmableoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
roleoptional
"chamber" | "work" | "indicator" | "strip" | object
Variant 1"chamber"
Variant 2"work"
Variant 3"indicator"
Variant 4"strip"
Variant 5object
lengthoptional
number
Returns the length of a String object.
nozzlesoptionalnullable
object[]
extrudeoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
temperatureoptional
object
readoptional
boolean
setoptional
boolean
toolRefoptional
string
peripheralsoptionalnullable
object[]
canLoadoptional
boolean
canReadFilamentoptional
boolean
canUnloadoptional
boolean
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
maxSlotsPerUnitoptional
number
maxUnitsoptional
number
minSlotsPerUnitoptional
number
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
slotsPerUnitoptional
number
typeoptional
"ercf" | "mmu" | "toolchanger" | "ams" | object
Variant 1"ercf"
Variant 2"mmu"
Variant 3"toolchanger"
Variant 4"ams"
Variant 5object
lengthoptional
number
Returns the length of a String object.
printingoptionalnullable
object
JSON Merge Patch style type: - `null` removes a key - arrays replace the target value (or merge-by-ref for component arrays, handled at runtime in `applyCapabilitiesPatch`) Array elements use `DeepPartial<U>` so callers can supply just the fields they're changing (e.g. `{ ref: 'fan_part', controllable: false }` without restating `role` / `label`). `applyCapabilitiesPatch` merges component arrays by `ref` at runtime, so partial elements compose with the base shape correctly. Non-component arrays follow standard replace-the-whole-thing semantics — supply full elements for those. Tests `NonNullable<T[P]>` first so optional fields recurse correctly: the previous `T[P] extends Array<infer U>` check failed for optional arrays (the `undefined` union member kept the array branch from matching) and fell through to the object branch, producing `Array<string | null | undefined>` shapes that nestia rejects.
pauseoptionalnullable
boolean
resumeoptionalnullable
boolean
skipObjectsoptionalnullable
boolean
startoptionalnullable
boolean
stopoptionalnullable
boolean
printOptionsoptionalnullable
object[]
choicesoptional
object[]
For `kind: "enum"`: allowed values with display labels.
labeloptional
string
valueoptional
string
defaultoptional
string | boolean
UI default when the stored providerConfig is null / missing the key.
descriptionoptional
string
Tooltip help text rendered next to the label.
kindoptional
"boolean" | "enum"
booleanenum
labeloptional
string
Human-readable display name
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
sensorsoptionalnullable
object[]
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
nozzleRefoptional
string
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
roleoptional
"lidar" | "filament_runout" | "door" | "accelerometer" | "bed_mesh" | object
Variant 1"lidar"
Variant 2"filament_runout"
Variant 3"door"
Variant 4"accelerometer"
Variant 5"bed_mesh"
Variant 6object
lengthoptional
number
Returns the length of a String object.
toolRefoptional
string
toolsoptionalnullable
object[]
fanRefsoptional
string[]
kindoptional
string
Optional vendor/extensible subtype when the base role is not enough
labeloptional
string
Human-readable display name
nozzleRefsoptional
string[]
refoptional
string
Logical reference, unique within its array. ASCII, lowercase, deterministic.
selectableoptional
boolean
sensorRefsoptional
string[]
printingJobIdrequirednullable
string
pattern: ^[a-z0-9]{24}$
processSystemProfileIdrequirednullable
number
processUserProfileIdrequirednullable
string
pattern: ^[a-z0-9]{24}$
providerrequired
enum
OctoPrintPrusaBambuKlipperSDCPElegooMqttAnycubic
providerConfigrequirednullable
object
bed_typeoptional
"Cool Plate" | "Engineering Plate" | "High Temp Plate" | "Textured PEI Plate" | "Supertack Plate"
Cool PlateEngineering PlateHigh Temp PlateTextured PEI PlateSupertack Plate
do_bed_levelingoptional
boolean
do_flow_calioptional
boolean
do_vibration_compensationoptional
boolean
enable_timelapseoptional
boolean
print_platform_typeoptional
string
use_amsoptional
boolean
proxyClientIdrequirednullable
string
storeIdrequired
string
pattern: ^[a-z0-9]{24}$
tagsoptional
string[]
updatedAtrequired
string
format: date-time
vendorModelIdrequirednullable
number
vendorNamerequirednullable
string
Vendor/manufacturer name (e.g. "Bambu Lab", "Prusa", "Snapmaker")

Example Response

200 OK — application/json 
[
  {
    "provider": "OctoPrint",
    "deviceId": "string",
    "providerConfig": {
      "use_ams": true,
      "do_bed_leveling": true,
      "do_flow_cali": true,
      "do_vibration_compensation": true,
      "bed_type": "Cool Plate",
      "enable_timelapse": true,
      "print_platform_type": "string"
    },
    "machineUserProfileId": "string",
    "machineSystemProfileId": 1,
    "processUserProfileId": "string",
    "processSystemProfileId": 1,
    "name": "string",
    "nozzleDiameter": "string",
    "metadata": {
      "provider": "bambu",
      "name": "string",
      "dev_id": "string",
      "online": true,
      "print_status": "string",
      "dev_model_name": "string",
      "dev_access_code": "string",
      "nozzle_diameter": 1,
      "dev_product_name": "string"
    },
    "proxyClientId": "string",
    "commMethod": "bambu-global-mqtt",
    "enabled": true,
    "tags": [
      "string"
    ],
    "confirmedReady": true,
    "isAvailable": true,
    "isOnline": true,
    "printingJobId": "string",
    "lastPrintedAt": "2025-01-15T12:00:00.000Z",
    "integrationId": "string",
    "integrationType": "bambulab",
    "continuousPrint": true,
    "fabmaticRemainingJobs": 1,
    "bedSize": {
      "x": 1,
      "y": 1,
      "z": 1
    },
    "modelName": "string",
    "vendorName": "string",
    "vendorModelId": 1,
    "printerCapabilityPatch": {
      "nozzles": [
        {
          "temperature": {
            "read": true,
            "set": true
          },
          "extrude": true,
          "toolRef": "string",
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "tools": [
        {
          "selectable": true,
          "nozzleRefs": [
            "string"
          ],
          "fanRefs": [
            "string"
          ],
          "sensorRefs": [
            "string"
          ],
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "fans": [
        {
          "role": "part",
          "controllable": true,
          "reportsSpeed": true,
          "nozzleRef": "string",
          "toolRef": "string",
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "lights": [
        {
          "role": "chamber",
          "dimmable": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "sensors": [
        {
          "role": "lidar",
          "nozzleRef": "string",
          "toolRef": "string",
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "beds": [
        {
          "temperature": {
            "read": true,
            "set": true
          },
          "hasMesh": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "chambers": [
        {
          "temperature": {
            "read": true,
            "set": true
          },
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "axes": [
        {
          "axis": "x",
          "move": true,
          "home": true,
          "flipped": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "filaments": [
        {
          "canReadFilament": true,
          "canLoad": true,
          "canUnload": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "cameras": [
        {
          "protocol": "mjpeg-bambu",
          "mounting": "builtin",
          "url": "string",
          "port": 1,
          "path": "string",
          "auth": "string",
          "role": "overhead",
          "snapshots": true,
          "timelapse": true,
          "primary": true,
          "webrtcSignaling": {
            "flavor": "whep",
            "path": "string"
          },
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "peripherals": [
        {
          "type": "ercf",
          "maxUnits": 1,
          "slotsPerUnit": 1,
          "minSlotsPerUnit": 1,
          "maxSlotsPerUnit": 1,
          "canReadFilament": true,
          "canLoad": true,
          "canUnload": true,
          "ref": "string",
          "label": "string",
          "kind": "string"
        }
      ],
      "printing": {
        "start": true,
        "pause": true,
        "resume": true,
        "stop": true,
        "skipObjects": true
      },
      "filament": {
        "setInfo": true,
        "read": true,
        "dynamicSlots": true
      },
      "files": {
        "upload": true,
        "list": true
      },
      "gcode": true,
      "printOptions": [
        {
          "kind": "boolean",
          "default": "string",
          "choices": [
            {
              "value": "string",
              "label": "string"
            }
          ],
          "description": "string",
          "ref": "string",
          "label": "string"
        }
      ]
    },
    "printerAdapterBindingsPatch": {
      "bambu": {
        "schemaVersion": 1,
        "commands": {
          "setNozzleTemperature": {},
          "setBedTemperature": {},
          "setFan": {},
          "setLight": {},
          "selectTool": {}
        },
        "components": {},
        "printOptions": {}
      },
      "klipper": {
        "schemaVersion": 1,
        "modules": [
          "string"
        ],
        "commands": {
          "setNozzleTemperature": {},
          "setBedTemperature": {},
          "setFan": {},
          "setLight": {},
          "selectTool": {},
          "setChamberTemperature": {}
        },
        "components": {},
        "printOptions": {}
      },
      "prusa": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      },
      "sdcp": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      },
      "elegoo-mqtt": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      },
      "anycubic": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      },
      "octoprint": {
        "schemaVersion": 1,
        "components": {},
        "printOptions": {}
      }
    },
    "lifetimePrintHours": 1,
    "lifetimeJobCount": 1,
    "isInMaintenance": true,
    "lastMaintenanceOfflineAt": "2025-01-15T12:00:00.000Z",
    "lastMaintenanceOnlineAt": "2025-01-15T12:00:00.000Z",
    "customMetadata": {},
    "id": "string",
    "storeId": "string",
    "createdAt": "2025-01-15T12:00:00.000Z",
    "updatedAt": "2025-01-15T12:00:00.000Z"
  }
]