pipewire 1.3.0 → 2.0.0

package/examples/event-registry-sync.ts

@@ -0,0 +1,60 @@
+import koffi from "koffi";
+import { bindings as pw } from "../src/index.js";
+
+(async () => {
+    pw.pipewire.pw_init(0, null);
+
+    const mainLoop = pw.main_loop.pw_main_loop_new(null);
+    const loop = pw.main_loop.pw_main_loop_get_loop(mainLoop);
+    const context = pw.context.pw_context_new(loop, null, 0);
+    const core = pw.core.pw_context_connect(context, null, 0);
+    const registry = pw.core.pw_core_get_registry(core, 3, 0);
+
+    const registry_event_global = (
+        data: unknown,
+        id: number,
+        permissions: number,
+        type: string,
+        version: number,
+        props: unknown
+    ) => {
+        console.log(`New object: id: ${id} type: ${type} version: ${version}`);
+    };
+
+    const registry_event_global_remove = (data: unknown, id: number) => {
+        console.log(`Removed object: id: ${id}`);
+    };
+
+    const registry_listener = Buffer.alloc(koffi.sizeof(pw.hook.spa_hook));
+    const registry_events = Buffer.alloc(koffi.sizeof(pw.core.pw_registry_events));
+    const registry_event_global_register = koffi.register(
+        registry_event_global,
+        koffi.pointer(pw.core.pw_registry_events_global)
+    );
+    const registry_event_global_remove_register = koffi.register(
+        registry_event_global_remove,
+        koffi.pointer(pw.core.pw_registry_events_global_remove)
+    );
+    koffi.encode(registry_events, pw.core.pw_registry_events, {
+        version: 0,
+        global: registry_event_global_register,
+        global_remove: registry_event_global_remove_register
+    });
+    pw.registry.pw_registry_add_listener(registry, registry_listener, registry_events, null);
+
+    console.log("Starting PipeWire main loop...");
+    pw.loop.pw_loop_enter(loop);
+    const interval = setInterval(() => pw.loop.pw_loop_iterate(loop, 1), 10);
+    await new Promise((resolve) => process.on("SIGINT", resolve));
+    clearInterval(interval);
+    pw.loop.pw_loop_leave(loop);
+
+    pw.proxy.pw_proxy_destroy(registry);
+    koffi.unregister(registry_event_global_register);
+    koffi.unregister(registry_event_global_remove_register);
+    pw.core.pw_core_disconnect(core);
+    pw.context.pw_context_destroy(context);
+    pw.main_loop.pw_main_loop_destroy(mainLoop);
+
+    console.log("PipeWire main loop exited, cleanup done.");
+})();

package/examples/node-events.ts

@@ -0,0 +1,34 @@
+import { Pipewire, PipewireNode } from "../src/index.js";
+
+const pipewire = new Pipewire();
+
+pipewire.on("objectAdded", (obj) => {
+    if (!(obj instanceof PipewireNode)) return;
+    console.log(`Node added: id: ${obj.id} name: ${obj.nodeName}`);
+
+    obj.on("nodeInfo", (info) => {
+        console.log(`Node info for id ${obj.id}: ${info.changes.join(", ")}`);
+    });
+    obj.on("rawNodeParam", () => {
+        console.log(`Node param for id ${obj.id}`);
+    });
+
+    setImmediate(() => {
+        obj.attachListener();
+        obj.subscribeParams(Object.values(PipewireNode.spa_param_type).filter((v) => typeof v === "number"));
+    });
+});
+
+pipewire.on("objectRemoved", (obj) => {
+    if (!(obj instanceof PipewireNode)) return;
+    console.log(`Node removed: id: ${obj.id} name: ${obj.nodeName}`);
+});
+
+console.log("Starting PipeWire main loop...");
+pipewire.startLoop();
+
+process.on("SIGINT", () => {
+    pipewire.stopLoop();
+    pipewire.deinit();
+    console.log("PipeWire main loop exited, cleanup done.");
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pipewire",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/{core.ts → bindings/core.ts}

@@ -4,19 +4,21 @@ import { pw_properties } from "./properties.js";
 
 const pipewire = koffi.load("libpipewire-0.3.so.0");
 
+export const PW_VERSION_REGISTRY = 3;
+
 export const pw_core = koffi.opaque("pw_core");
 export const pw_registry = koffi.opaque("pw_registry");
 
 export const pw_context_connect = pipewire.func("pw_context_connect", koffi.pointer(pw_core), [
-    koffi.pointer(pw_context),
-    koffi.pointer(pw_properties),
-    "size_t"
+    koffi.pointer(pw_context), // context
+    koffi.pointer(pw_properties), // properties
+    "size_t" // user_data_size
 ]);
 
 export const pw_core_get_registry = pipewire.func("pw_core_get_registry", koffi.pointer(pw_registry), [
-    koffi.pointer(pw_core),
-    "uint32_t",
-    "size_t"
+    koffi.pointer(pw_core), // core
+    "uint32_t", // version
+    "size_t" // user_data_size
 ]);
 
 export const pw_registry_events_global = koffi.proto("void", [

package/src/bindings/index.ts

@@ -0,0 +1,16 @@
+import * as context from "./context.js";
+import * as core from "./core.js";
+import * as dict from "./dict.js";
+import * as hook from "./hook.js";
+import * as loop from "./loop.js";
+import * as main_loop from "./main-loop.js";
+import * as node from "./node.js";
+import * as param from "./param.js";
+import * as pipewire from "./pipewire.js";
+import * as pod from "./pod.js";
+import * as props from "./props.js";
+import * as proxy from "./proxy.js";
+import * as registry from "./registry.js";
+import * as thread_loop from "./thread-loop.js";
+
+export default { context, core, dict, hook, loop, main_loop, node, param, pod, props, pipewire, proxy, registry, thread_loop };

package/src/{loop.ts → bindings/loop.ts}

@@ -1,5 +1,7 @@
 import koffi from "koffi";
 
+const pipewire = koffi.load("libpipewire-0.3.so.0");
+
 export const spa_system = koffi.opaque("spa_system");
 export const spa_loop = koffi.opaque("spa_loop");
 export const spa_loop_control = koffi.opaque("spa_loop_control");
@@ -13,3 +15,7 @@ export const pw_loop = koffi.struct("pw_loop", {
     utils: koffi.pointer(spa_loop_utils),
     name: "const char*"
 });
+
+export const pw_loop_enter = pipewire.func("pw_loop_enter", "void", [koffi.pointer(pw_loop)]);
+export const pw_loop_iterate = pipewire.func("pw_loop_iterate", "int", [koffi.pointer(pw_loop), "int"]);
+export const pw_loop_leave = pipewire.func("pw_loop_leave", "void", [koffi.pointer(pw_loop)]);

package/src/bindings/node.ts

@@ -0,0 +1,92 @@
+import koffi from "koffi";
+import { spa_hook } from "./hook.js";
+import { spa_pod } from "./pod.js";
+import { spa_dict } from "./dict.js";
+import { spa_param_info } from "./param.js";
+
+const pipewire = koffi.load("libpipewire-0.3.so.0");
+
+export const PW_VERSION_NODE = 3;
+export const PW_VERSION_NODE_EVENTS = 0;
+
+export const PW_NODE_CHANGE_MASK = {
+    INPUT_PORTS: 1 << 0,
+    OUTPUT_PORTS: 1 << 1,
+    STATE: 1 << 2,
+    PROPS: 1 << 3,
+    PARAMS: 1 << 4
+};
+
+export enum pw_node_state {
+    PW_NODE_STATE_ERROR = -1,
+    PW_NODE_STATE_CREATING = 0,
+    PW_NODE_STATE_SUSPENDED = 1,
+    PW_NODE_STATE_IDLE = 2,
+    PW_NODE_STATE_RUNNING = 3
+}
+
+export const pw_node = koffi.opaque("pw_node");
+
+export const pw_node_state_enum = koffi.enumeration("pw_node_state", {
+    PW_NODE_STATE_ERROR: -1,
+    PW_NODE_STATE_CREATING: 0,
+    PW_NODE_STATE_SUSPENDED: 1,
+    PW_NODE_STATE_IDLE: 2,
+    PW_NODE_STATE_RUNNING: 3
+});
+
+export const pw_node_info = koffi.struct("pw_node_info", {
+    id: "uint32_t",
+    max_input_ports: "uint32_t",
+    max_output_ports: "uint32_t",
+    change_mask: "uint64_t",
+    n_input_ports: "uint32_t",
+    n_output_ports: "uint32_t",
+    state: pw_node_state_enum,
+    error: "const char*",
+    props: koffi.pointer(spa_dict),
+    params: koffi.pointer(spa_param_info),
+    n_params: "uint32_t"
+});
+
+export const pw_node_events_info = koffi.proto("void", [
+    "void*", // data
+    koffi.pointer(pw_node_info) // info
+]);
+
+export const pw_node_events_param = koffi.proto("void", [
+    "void*", // data
+    "int", // seq
+    "uint32_t", // id
+    "uint32_t", // index
+    "uint32_t", // next
+    koffi.pointer(spa_pod) // param
+]);
+
+export const pw_node_events = koffi.struct("pw_node_events", {
+    version: "uint32_t",
+    info: koffi.pointer(pw_node_events_info),
+    param: koffi.pointer(pw_node_events_param)
+});
+
+export const pw_node_add_listener = pipewire.func("pw_node_add_listener", "int", [
+    koffi.pointer(pw_node), // object
+    koffi.pointer(spa_hook), // listener
+    koffi.pointer(pw_node_events), // events
+    "void*" // data
+]);
+
+export const pw_node_enum_params = pipewire.func("pw_node_enum_params", "int", [
+    koffi.pointer(pw_node), // object
+    "int", // seq
+    "uint32_t", // id
+    "uint32_t", // start
+    "uint32_t", // num
+    koffi.pointer(spa_pod) // filter
+]);
+
+export const pw_node_subscribe_params = pipewire.func("pw_node_subscribe_params", "int", [
+    koffi.pointer(pw_node), // object
+    "uint32_t*", // ids
+    "uint32_t" // n_ids
+]);

package/src/bindings/param.ts

@@ -0,0 +1,33 @@
+import koffi from "koffi";
+
+export const spa_param_info = koffi.struct("spa_param_info", {
+    id: "uint32_t",
+    flags: "uint32_t",
+    user: "uint32_t",
+    seq: "int32_t",
+    padding: koffi.array("uint32_t", 4)
+});
+
+export enum spa_param_type {
+    SPA_PARAM_Invalid,
+    SPA_PARAM_PropInfo,
+    SPA_PARAM_Props,
+    SPA_PARAM_EnumFormat,
+    SPA_PARAM_Format,
+    SPA_PARAM_Buffers,
+    SPA_PARAM_Meta,
+    SPA_PARAM_IO,
+    SPA_PARAM_EnumProfile,
+    SPA_PARAM_Profile,
+    SPA_PARAM_EnumPortConfig,
+    SPA_PARAM_PortConfig,
+    SPA_PARAM_EnumRoute,
+    SPA_PARAM_Route,
+    SPA_PARAM_Control,
+    SPA_PARAM_Latency,
+    SPA_PARAM_ProcessLatency,
+    SPA_PARAM_Tag,
+    SPA_PARAM_PeerEnumFormat,
+    SPA_PARAM_Capability,
+    SPA_PARAM_PeerCapability
+}

package/src/bindings/pipewire.ts

@@ -0,0 +1,6 @@
+import koffi from "koffi";
+
+const pipewire = koffi.load("libpipewire-0.3.so.0");
+
+export const pw_init = pipewire.func("pw_init", "void", ["int**", "char***"]);
+export const pw_deinit = pipewire.func("pw_deinit", "void", []);

package/src/{registry.ts → bindings/registry.ts}

@@ -4,6 +4,8 @@ import { spa_hook } from "./hook.js";
 
 const pipewire = koffi.load("libpipewire-0.3.so.0");
 
+export const PW_VERSION_REGISTRY_EVENTS = 0;
+
 export const pw_registry_add_listener = pipewire.func("pw_registry_add_listener", "int", [
     koffi.pointer(pw_registry), // registry
     koffi.pointer(spa_hook), // listener

package/src/bindings/thread-loop.ts

@@ -0,0 +1,23 @@
+import koffi from "koffi";
+import { spa_dict } from "./dict.js";
+import { pw_loop } from "./loop.js";
+
+const pipewire = koffi.load("libpipewire-0.3.so.0");
+
+export const pw_thread_loop = koffi.opaque("pw_thread_loop");
+
+export const pw_thread_loop_new = pipewire.func("pw_thread_loop_new", koffi.pointer(pw_thread_loop), [
+    "const char*", // name
+    koffi.pointer(spa_dict) // props
+]);
+export const pw_thread_loop_destroy = pipewire.func("pw_thread_loop_destroy", "void", [koffi.pointer(pw_thread_loop)]);
+
+export const pw_thread_loop_get_loop = pipewire.func("pw_thread_loop_get_loop", koffi.pointer(pw_loop), [
+    koffi.pointer(pw_thread_loop)
+]);
+
+export const pw_thread_loop_lock = pipewire.func("pw_thread_loop_lock", "void", [koffi.pointer(pw_thread_loop)]);
+export const pw_thread_loop_unlock = pipewire.func("pw_thread_loop_unlock", "void", [koffi.pointer(pw_thread_loop)]);
+
+export const pw_thread_loop_start = pipewire.func("pw_thread_loop_start", "int", [koffi.pointer(pw_thread_loop)]);
+export const pw_thread_loop_stop = pipewire.func("pw_thread_loop_stop", "void", [koffi.pointer(pw_thread_loop)]);

package/src/index.ts

@@ -1,14 +1,6 @@
-import * as context from "./context.js";
-import * as core from "./core.js";
-import * as dict from "./dict.js";
-import * as hook from "./hook.js";
-import * as main_loop from "./main-loop.js";
-import * as node from "./node.js";
-import * as param from "./param.js";
-import * as pipewire from "./pipewire.js";
-import * as pod from "./pod.js";
-import * as props from "./props.js";
-import * as proxy from "./proxy.js";
-import * as registry from "./registry.js";
+import Pipewire from "./pipewire.js";
+import PipewireObject from "./object.js";
+import PipewireNode from "./node.js";
+import bindings from "./bindings/index.js";
 
-export { context, core, dict, hook, main_loop, node, param, pod, props, pipewire, proxy, registry };
+export { Pipewire, PipewireObject, PipewireNode, bindings };

package/src/node.ts

@@ -1,81 +1,169 @@
 import koffi from "koffi";
-import { spa_hook } from "./hook.js";
-import { spa_pod } from "./pod.js";
-import { spa_dict } from "./dict.js";
-import { spa_param_info } from "./param.js";
-
-const pipewire = koffi.load("libpipewire-0.3.so.0");
-
-export const pw_node = koffi.opaque("pw_node");
-
-export const pw_node_state = koffi.enumeration("pw_node_state", {
-    PW_NODE_STATE_ERROR: -1,
-    PW_NODE_STATE_CREATING: 0,
-    PW_NODE_STATE_SUSPENDED: 1,
-    PW_NODE_STATE_IDLE: 2,
-    PW_NODE_STATE_RUNNING: 3
-});
-
-export const PW_NODE_CHANGE_MASK = {
-    INPUT_PORTS: 1 << 0,
-    OUTPUT_PORTS: 1 << 1,
-    STATE: 1 << 2,
-    PROPS: 1 << 3,
-    PARAMS: 1 << 4
-};
+import type Pipewire from "./pipewire.js";
+import type { pw_node_state } from "./bindings/node.js";
+import type { spa_param_type } from "./bindings/param.js";
+import PipewireObject from "./object.js";
+import pw from "./bindings/index.js";
+
+export default class PipewireNode extends PipewireObject {
+    static readonly pw_node_state = pw.node.pw_node_state_enum;
+    static readonly spa_param_type = pw.param.spa_param_type;
+
+    nodeName: string;
+    factoryId: number;
+
+    nodeProxy: unknown | null = null;
+    nodeListener: Buffer | null = null;
+    nodeEvents: Buffer | null = null;
+    nodeEventInfoRegister: bigint | null = null;
+    nodeEventParamRegister: bigint | null = null;
+
+    constructor(
+        pipewire: Pipewire,
+        id: number,
+        permissions: number,
+        type: string,
+        version: number,
+        props: { [key: string]: string }
+    ) {
+        super(pipewire, id, permissions, type, version, props);
+        this.nodeName = props["node.name"]!;
+        this.factoryId = Number(props["factory.id"]);
+    }
+
+    attachListener(): void {
+        if (this.removed) return;
+        if (this.nodeProxy) throw new Error(`Listener already attached to node ${this.id}`);
+
+        this.nodeProxy = pw.registry.pw_registry_bind(
+            this.pipewire.registry,
+            this.id,
+            this.type,
+            pw.node.PW_VERSION_NODE,
+            0
+        );
+        this.nodeListener = Buffer.alloc(koffi.sizeof(pw.hook.spa_hook));
+        this.nodeEvents = Buffer.alloc(koffi.sizeof(pw.node.pw_node_events));
+        this.nodeEventInfoRegister = koffi.register(
+            this.nodeEventInfo.bind(this),
+            koffi.pointer(pw.node.pw_node_events_info)
+        );
+        this.nodeEventParamRegister = koffi.register(
+            this.nodeEventParam.bind(this),
+            koffi.pointer(pw.node.pw_node_events_param)
+        );
+        koffi.encode(this.nodeEvents, pw.node.pw_node_events, {
+            version: pw.node.PW_VERSION_NODE_EVENTS,
+            info: this.nodeEventInfoRegister,
+            param: this.nodeEventParamRegister
+        });
+        pw.node.pw_node_add_listener(this.nodeProxy, this.nodeListener, this.nodeEvents, null);
+    }
+
+    detachListener(): void {
+        if (!this.nodeProxy) throw new Error(`Listener not attached to node ${this.id}`);
+
+        if (!this.removed) pw.proxy.pw_proxy_destroy(this.nodeProxy);
+        koffi.unregister(this.nodeEventParamRegister!);
+        koffi.unregister(this.nodeEventInfoRegister!);
+        this.nodeEventInfoRegister = null;
+        this.nodeEventParamRegister = null;
+        this.nodeEvents = null;
+        this.nodeListener = null;
+        this.nodeProxy = null;
+    }
+
+    subscribeParams(params: spa_param_type[]) {
+        if (this.removed) return;
+        if (!this.nodeProxy) throw new Error(`Listener not attached to node ${this.id}`);
+        pw.node.pw_node_subscribe_params(this.nodeProxy, params, params.length);
+    }
+
+    nodeEventInfo(_data: unknown, info: unknown): void {
+        this.emit("rawNodeInfo", info);
+
+        const nodeInfo = koffi.decode(info, pw.node.pw_node_info);
 
-export const pw_node_info = koffi.struct("pw_node_info", {
-    id: "uint32_t",
-    max_input_ports: "uint32_t",
-    max_output_ports: "uint32_t",
-    change_mask: "uint64_t",
-    n_input_ports: "uint32_t",
-    n_output_ports: "uint32_t",
-    state: pw_node_state,
-    error: "const char*",
-    props: koffi.pointer(spa_dict),
-    params: koffi.pointer(spa_param_info),
-    n_params: "uint32_t"
-});
-
-export const pw_node_events_info = koffi.proto("void", [
-    "void*", // data
-    koffi.pointer(pw_node_info) // info
-]);
-
-export const pw_node_events_param = koffi.proto("void", [
-    "void*", // data
-    "int", // seq
-    "uint32_t", // id
-    "uint32_t", // index
-    "uint32_t", // next
-    koffi.pointer(spa_pod) // param
-]);
-
-export const pw_node_events = koffi.struct("pw_node_events", {
-    version: "uint32_t",
-    info: koffi.pointer(pw_node_events_info),
-    param: koffi.pointer(pw_node_events_param)
-});
-
-export const pw_node_add_listener = pipewire.func("pw_node_add_listener", "int", [
-    koffi.pointer(pw_node), // object
-    koffi.pointer(spa_hook), // listener
-    koffi.pointer(pw_node_events), // events
-    "void*" // data
-]);
-
-export const pw_node_enum_params = pipewire.func("pw_node_enum_params", "int", [
-    koffi.pointer(pw_node), // object
-    "int", // seq
-    "uint32_t", // id
-    "uint32_t", // start
-    "uint32_t", // num
-    koffi.pointer(spa_pod) // filter
-]);
-
-export const pw_node_subscribe_params = pipewire.func("pw_node_subscribe_params", "int", [
-    koffi.pointer(pw_node), // object
-    "uint32_t*", // ids
-    "uint32_t" // n_ids
-]);
+        const changesMasks = Object.keys(pw.node.PW_NODE_CHANGE_MASK) as (keyof typeof pw.node.PW_NODE_CHANGE_MASK)[];
+        const changes = changesMasks.filter((key) => nodeInfo.change_mask & pw.node.PW_NODE_CHANGE_MASK[key]);
+
+        const props = koffi.decode(nodeInfo.props, pw.dict.spa_dict);
+        if (changes.includes("PROPS") !== !!props.items) throw new Error(`Node ${this.id} props change mismatch`);
+
+        const propsObj: { [key: string]: string } | null = changes.includes("PROPS") ? {} : null;
+        if (propsObj) {
+            const propsArray = koffi.decode(props.items, pw.dict.spa_dict_item, props.n_items);
+            for (const item of propsArray) propsObj[item.key] = item.value;
+        }
+
+        const paramsObj: spa_param_type[] = [];
+        if (nodeInfo.params) {
+            const params = koffi.decode(nodeInfo.params, pw.param.spa_param_info, nodeInfo.n_params);
+            for (const param of params) paramsObj.push(param.id as spa_param_type);
+        }
+
+        const nodeInfoObj: NodeInfo = {
+            id: nodeInfo.id,
+            maxInputPorts: nodeInfo.max_input_ports,
+            maxOutputPorts: nodeInfo.max_output_ports,
+            changes: changes,
+            inputPortsCount: nodeInfo.n_input_ports,
+            outputPortsCount: nodeInfo.n_output_ports,
+            state: nodeInfo.state as pw_node_state,
+            error: nodeInfo.error ? koffi.decode(nodeInfo.error, "string") : null,
+            props: propsObj,
+            params: paramsObj
+        };
+
+        this.emit("nodeInfo", nodeInfoObj);
+    }
+
+    nodeEventParam(_data: unknown, info: unknown): void {
+        this.emit("rawNodeParam", info);
+    }
+
+    on(event: "nodeInfo", listener: (info: NodeInfo) => void): this;
+    on(event: "rawNodeInfo", listener: (info: unknown) => void): this;
+    on(event: "rawNodeParam", listener: (info: unknown) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this {
+        return super.on(event, listener);
+    }
+
+    once(event: "nodeInfo", listener: (info: NodeInfo) => void): this;
+    once(event: "rawNodeInfo", listener: (info: unknown) => void): this;
+    once(event: "rawNodeParam", listener: (info: unknown) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this {
+        return super.once(event, listener);
+    }
+
+    off(event: "nodeInfo", listener: (info: NodeInfo) => void): this;
+    off(event: "rawNodeInfo", listener: (info: unknown) => void): this;
+    off(event: "rawNodeParam", listener: (info: unknown) => void): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this {
+        return super.off(event, listener);
+    }
+
+    emit(event: "nodeInfo", info: NodeInfo): boolean;
+    emit(event: "rawNodeInfo", info: unknown): boolean;
+    emit(event: "rawNodeParam", info: unknown): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean {
+        return super.emit(event, ...args);
+    }
+}
+
+export type NodeInfo = {
+    id: number;
+    maxInputPorts: number;
+    maxOutputPorts: number;
+    changes: (keyof typeof pw.node.PW_NODE_CHANGE_MASK)[];
+    inputPortsCount: number;
+    outputPortsCount: number;
+    state: pw_node_state;
+    error: string | null;
+    props: { [key: string]: string } | null;
+    params: spa_param_type[];
+};

package/src/object.ts

@@ -0,0 +1,36 @@
+import EventEmitter from "node:events";
+import type Pipewire from "./pipewire.js";
+
+export default class PipewireObject extends EventEmitter {
+    pipewire: Pipewire;
+    removed: boolean = false;
+
+    id: number;
+    permissions: number;
+    type: string;
+    version: number;
+    props: { [key: string]: string };
+
+    objectSerial: number;
+
+    constructor(
+        pipewire: Pipewire,
+        id: number,
+        permissions: number,
+        type: string,
+        version: number,
+        props: { [key: string]: string }
+    ) {
+        super();
+
+        this.pipewire = pipewire;
+
+        this.id = id;
+        this.permissions = permissions;
+        this.type = type;
+        this.version = version;
+        this.props = props;
+
+        this.objectSerial = Number(props["object.serial"]);
+    }
+}