@arcanewizards/tcnet 0.1.1

package/dist/monitor.js

@@ -0,0 +1,307 @@
+import {
+  TCNET_LAYER_COUNT
+} from "./chunk-FAJ3XTSE.js";
+import {
+  calculateUniqueNodeId,
+  differsByMoreThan
+} from "./chunk-2L35L5P5.js";
+import {
+  TCNetProtocolError
+} from "./chunk-VXAKTGOW.js";
+
+// src/monitor.ts
+import EventEmitter from "node:events";
+var MAX_DELTA_MS = 10;
+var layerDataIdToIndex = (dataLayerId) => {
+  return dataLayerId - 1;
+};
+var layerIndexToDataId = (index) => {
+  return index + 1;
+};
+var asLayerIndex = (rawNumber) => {
+  return rawNumber;
+};
+var getLayerId = (node, layer) => {
+  return `${calculateUniqueNodeId(node)}:${layer}`;
+};
+var TCNET_LAYER_INDEXES = Array.from(
+  { length: TCNET_LAYER_COUNT },
+  (_, i) => asLayerIndex(i)
+);
+var createTCNetTimecodeMonitor = (tcNetNode, logger) => {
+  const events = new EventEmitter();
+  const on = events.on.bind(events);
+  const addListener = events.addListener.bind(events);
+  const removeListener = events.removeListener.bind(events);
+  const nodeStates = /* @__PURE__ */ new Map();
+  const getNodeState = (node) => {
+    const nodeKey = calculateUniqueNodeId(node);
+    let nodeState = nodeStates.get(nodeKey);
+    if (nodeState) {
+      return nodeState;
+    }
+    const layerInfoArray = new Array(TCNET_LAYER_COUNT);
+    nodeState = {
+      node,
+      trackInfo: /* @__PURE__ */ new Map(),
+      getLayerInfo: (i) => layerInfoArray[i]
+    };
+    nodeStates.set(nodeKey, nodeState);
+    for (const i of TCNET_LAYER_INDEXES) {
+      layerInfoArray[i] = {
+        name: null,
+        status: "IDLE",
+        trackId: null,
+        pitchBend: 0,
+        speed: 0,
+        layerState: {
+          layerId: `${i}`,
+          layerName: `Layer ${i + 1}`,
+          totalTime: null,
+          info: null,
+          playState: {
+            state: "stopped",
+            currentTimeMillis: 0,
+            speed: 1,
+            onAir: false
+          }
+        }
+      };
+    }
+    return nodeState;
+  };
+  const updateMetadataForLayer = (node, layer) => {
+    const trackID = getNodeState(node).getLayerInfo(layer)?.trackId;
+    if (typeof trackID !== "number") {
+      return;
+    }
+    tcNetNode.requestData(node, "METADATA", layerIndexToDataId(layer));
+  };
+  const updateMetricsForLayer = (node, layer) => {
+    const trackID = getNodeState(node).getLayerInfo(layer)?.trackId;
+    if (typeof trackID !== "number") {
+      return;
+    }
+    tcNetNode.requestData(node, "METRICS_DATA", layerIndexToDataId(layer));
+  };
+  const getProbableTrackInfo = (node, trackID) => {
+    if (trackID === null) {
+      return null;
+    }
+    const trackInfoForTrack = getNodeState(node).trackInfo.get(trackID);
+    if (!trackInfoForTrack) {
+      return null;
+    }
+    let bestMatch = null;
+    for (const info of trackInfoForTrack.values()) {
+      const bestMatchCount = bestMatch?.matchCount ?? 0;
+      if (
+        // Best match if we've seen this track the most times
+        info.matchCount > bestMatchCount || // Or if we've seen it aa similar same amount of times,
+        // but more recently
+        info.matchCount > bestMatchCount - 4 && info.lastMatchTime > (bestMatch?.lastMatchTime ?? 0)
+      ) {
+        bestMatch = info;
+      }
+    }
+    return bestMatch?.info ?? null;
+  };
+  const updatePlayingTimecode = (node, i, info, layer) => {
+    if (!layer) {
+      return;
+    }
+    const now = Date.now();
+    const effectiveStartTime = now - layer.currentTimeMillis / info.speed;
+    const trackInfo = getProbableTrackInfo(node, info.trackId);
+    if (!info.layerState || info.layerState.playState.state !== "playing" || info.layerState.playState.state === "playing" && (differsByMoreThan(
+      info.layerState.playState.effectiveStartTime,
+      effectiveStartTime,
+      MAX_DELTA_MS
+    ) || differsByMoreThan(
+      info.layerState.totalTime?.timeMillis ?? 0,
+      layer.totalTimeMillis,
+      MAX_DELTA_MS
+    )) || info.layerState.info !== trackInfo || info.layerState.playState.speed !== info.speed || info.layerState.playState.onAir !== info.layerState.playState.onAir) {
+      info.layerState = {
+        layerId: getLayerId(node, i),
+        layerName: info.name ?? `Layer ${layerIndexToDataId(i)}`,
+        totalTime: layer.totalTimeMillis > 0 ? {
+          timeMillis: layer.totalTimeMillis,
+          precisionMillis: 1e3
+        } : null,
+        info: trackInfo,
+        playState: {
+          state: "playing",
+          effectiveStartTime,
+          speed: info.speed,
+          onAir: info.layerState?.playState.onAir
+        }
+      };
+      events.emit("timecode-changed", info.layerState);
+    }
+  };
+  const updatePausedTimecode = (node, i, info, layer) => {
+    if (!layer) {
+      return;
+    }
+    const trackInfo = getProbableTrackInfo(node, info.trackId);
+    if (!info.layerState || info.layerState.playState.state !== "stopped" || info.layerState.playState.state === "stopped" && (differsByMoreThan(
+      info.layerState.playState.currentTimeMillis,
+      layer.currentTimeMillis,
+      MAX_DELTA_MS
+    ) || differsByMoreThan(
+      info.layerState.totalTime?.timeMillis ?? 0,
+      layer.totalTimeMillis,
+      MAX_DELTA_MS
+    )) || info.layerState.info !== trackInfo || info.layerState.playState.speed !== info.speed || info.layerState.playState.onAir !== info.layerState.playState.onAir) {
+      info.layerState = {
+        layerId: getLayerId(node, i),
+        layerName: info.name ?? `Layer ${layerIndexToDataId(i)}`,
+        totalTime: layer.totalTimeMillis > 0 ? {
+          timeMillis: layer.totalTimeMillis,
+          precisionMillis: 1e3
+        } : null,
+        info: trackInfo,
+        playState: {
+          state: "stopped",
+          currentTimeMillis: layer.currentTimeMillis,
+          speed: info.speed,
+          onAir: info.layerState?.playState.onAir
+        }
+      };
+      events.emit("timecode-changed", info.layerState);
+    }
+  };
+  tcNetNode.on("data", ({ packet, node }) => {
+    const nodeState = getNodeState(node);
+    if (packet.dataType === "METADATA") {
+      if (packet.trackId) {
+        logger.warn(
+          new TCNetProtocolError(
+            `Received unexpected trackId in METADATA packet, implementation needs to be updated to handle this!`
+          )
+        );
+      }
+      const info = {
+        title: packet.trackTitle || null,
+        artist: packet.trackArtist || null
+      };
+      if (!info.title && !info.artist) {
+        return;
+      }
+      const trackID = nodeState.getLayerInfo(
+        layerDataIdToIndex(packet.layer)
+      )?.trackId;
+      if (typeof trackID !== "number") {
+        return;
+      }
+      let trackInfoForTrack = nodeState.trackInfo.get(trackID);
+      if (!trackInfoForTrack) {
+        trackInfoForTrack = /* @__PURE__ */ new Map();
+        nodeState.trackInfo.set(trackID, trackInfoForTrack);
+      }
+      const key = `${info.artist} - ${info.title}`;
+      const weightedInfo = trackInfoForTrack.get(key) || {
+        matchCount: 0,
+        lastMatchTime: Date.now(),
+        info
+      };
+      weightedInfo.matchCount++;
+      weightedInfo.lastMatchTime = Date.now();
+      trackInfoForTrack.set(key, weightedInfo);
+    } else if (packet.dataType === "METRICS_DATA") {
+      const info = nodeState.getLayerInfo(layerDataIdToIndex(packet.layer));
+      if (info) {
+        info.pitchBend = packet.pitchBend ?? 0;
+        info.speed = 1 + info.pitchBend / 1e4;
+      }
+    }
+  });
+  tcNetNode.on("time", ({ packet, node }) => {
+    const nodeState = getNodeState(node);
+    for (const i of TCNET_LAYER_INDEXES) {
+      const info = nodeState.getLayerInfo(i);
+      switch (info?.status) {
+        case "PLAYING":
+        case "LOOPING":
+        case "CUEDOWN":
+          updatePlayingTimecode(node, i, info, packet.layers[i]);
+          break;
+        case "PAUSED":
+        case "STOPPED":
+        case "LOADING":
+        case "PLATTERDOWN":
+        case "HOLD":
+        case "FFWD":
+        case "FFRV":
+          updatePausedTimecode(node, i, info, packet.layers[i]);
+          break;
+        case "UNKNOWN":
+        case "IDLE":
+      }
+    }
+  });
+  tcNetNode.on("node-status", ({ packet, node }) => {
+    for (const i of TCNET_LAYER_INDEXES) {
+      const layer = packet.layers[i];
+      const info = getNodeState(node).getLayerInfo(i);
+      if (!info || !layer) {
+        throw new Error("Inconsistent layer indexes");
+      }
+      info.status = layer.status;
+      info.name = layer.name;
+      if (info.trackId !== layer.trackId && layer.trackId > 0) {
+        logger.info(
+          `Updated trackID for layer ${i}: ${info.trackId} -> ${layer.trackId}`
+        );
+        info.trackId = layer.trackId;
+        updateMetadataForLayer(node, i);
+      }
+    }
+  });
+  tcNetNode.on("nodes-changed", (nodes) => {
+    const knownNodeIds = new Set(
+      Object.values(nodes).map((node) => calculateUniqueNodeId(node))
+    );
+    for (const [nodeId, nodeState] of nodeStates.entries()) {
+      if (!knownNodeIds.has(nodeId)) {
+        for (const i of TCNET_LAYER_INDEXES) {
+          const layerState = nodeState.getLayerInfo(i)?.layerState;
+          if (layerState) {
+            events.emit("layer-removed", { layerId: layerState.layerId });
+          }
+        }
+        nodeStates.delete(nodeId);
+      }
+    }
+  });
+  const updateLoadedTracks = () => {
+    for (const nodeState of nodeStates.values()) {
+      for (const i of TCNET_LAYER_INDEXES) {
+        const info = nodeState.getLayerInfo(i);
+        if (info?.trackId) {
+          updateMetadataForLayer(nodeState.node, i);
+          updateMetricsForLayer(nodeState.node, i);
+        }
+      }
+    }
+  };
+  let autoUpdater = null;
+  tcNetNode.on("ready", () => {
+    autoUpdater = setInterval(updateLoadedTracks, 1e3);
+    updateLoadedTracks();
+  });
+  tcNetNode.on("destroy", () => {
+    if (autoUpdater) {
+      clearInterval(autoUpdater);
+    }
+  });
+  return {
+    on,
+    addListener,
+    removeListener
+  };
+};
+export {
+  createTCNetTimecodeMonitor
+};

package/dist/protocol.cjs

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk7IUB6OJ3cjs = require('./chunk-7IUB6OJ3.cjs');
+require('./chunk-VYNI4G3K.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.MAX_NODE_ID = _chunk7IUB6OJ3cjs.MAX_NODE_ID; exports.MGMT_HEADER_MINOR_VERSION = _chunk7IUB6OJ3cjs.MGMT_HEADER_MINOR_VERSION; exports.MGMT_HEADER_VERSION = _chunk7IUB6OJ3cjs.MGMT_HEADER_VERSION; exports.TCNET_LAYER_COUNT = _chunk7IUB6OJ3cjs.TCNET_LAYER_COUNT; exports.generateTcNetPortNodeOptionsFlags = _chunk7IUB6OJ3cjs.generateTcNetPortNodeOptionsFlags; exports.getTcNetDataPacketType = _chunk7IUB6OJ3cjs.getTcNetDataPacketType; exports.getTcNetLayerState = _chunk7IUB6OJ3cjs.getTcNetLayerState; exports.getTcNetLayerTCState = _chunk7IUB6OJ3cjs.getTcNetLayerTCState; exports.getTcNetMessageType = _chunk7IUB6OJ3cjs.getTcNetMessageType; exports.getTcNetMixerType = _chunk7IUB6OJ3cjs.getTcNetMixerType; exports.getTcNetNodeType = _chunk7IUB6OJ3cjs.getTcNetNodeType; exports.parseManagementHeader = _chunk7IUB6OJ3cjs.parseManagementHeader; exports.parsePacket = _chunk7IUB6OJ3cjs.parsePacket; exports.parseTcNetPortNodeOptions = _chunk7IUB6OJ3cjs.parseTcNetPortNodeOptions; exports.writeManagementHeader = _chunk7IUB6OJ3cjs.writeManagementHeader; exports.writeOptInPacket = _chunk7IUB6OJ3cjs.writeOptInPacket; exports.writeOptOutPacket = _chunk7IUB6OJ3cjs.writeOptOutPacket; exports.writeRequestPacket = _chunk7IUB6OJ3cjs.writeRequestPacket;

package/dist/protocol.d.cts

@@ -0,0 +1,308 @@
+/**
+ * Branded Layer ID as provided / required in TCNet Data Packets.
+ *
+ * Allows for type-checking to avoid confusion between
+ * layer indices used in status packets and layer IDs used in data packets,
+ * which are not necessarily the same.
+ *
+ * Example: 1=LAYER1, 2=LAYER2, 3=LAYER3, 4=LAYER4, 5=LAYER A, 6=LAYER B, 7=MASTER OUT, 8=RESERVED
+ */
+type LayerDataId = number & {
+    __brand: 'LayerDataId';
+};
+declare const TCNET_LAYER_COUNT = 8;
+declare const TCNET_LAYER_STATE_IDS: Readonly<{
+    IDLE: 0;
+    /**
+     * Not in spec, but seems to be what's observed.
+     */
+    LOADING: 2;
+    PLAYING: 3;
+    LOOPING: 4;
+    PAUSED: 5;
+    STOPPED: 6;
+    CUEDOWN: 7;
+    PLATTERDOWN: 8;
+    FFWD: 9;
+    FFRV: 10;
+    HOLD: 11;
+    /**
+     * Not in spec, but seems to be what's observed.
+     */
+    END: 17;
+    /**
+     * TODO: determine what this means, seems to be disconnected state?
+     */
+    UNKNOWN: 255;
+}>;
+type TCNetLayerState = keyof typeof TCNET_LAYER_STATE_IDS;
+declare const getTcNetLayerState: (id: number) => TCNetLayerState;
+declare const TCNET_MIXER_TYPE_IDS: Readonly<{
+    STANDARD: 0;
+    EXTENDED: 2;
+}>;
+type TCNetMixerType = keyof typeof TCNET_MIXER_TYPE_IDS;
+declare const getTcNetMixerType: (id: number) => TCNetMixerType;
+declare const TCNET_MESSAGE_TYPE_IDS: Readonly<{
+    OPT_IN: 2;
+    OPT_OUT: 3;
+    STATUS: 5;
+    TIME_SYNC: 10;
+    ERROR: 13;
+    REQUEST: 20;
+    APPLICATION_SPECIFIC_DATA_1: 30;
+    CONTROL: 101;
+    TEXT_DATA: 128;
+    KEYBOARD_DATA: 132;
+    DATA: 200;
+    FILE: 204;
+    APPLICATION_SPECIFIC_DATA_2: 213;
+    TIME: 254;
+}>;
+type TCNetMessageType = keyof typeof TCNET_MESSAGE_TYPE_IDS;
+declare const getTcNetMessageType: (id: number) => TCNetMessageType;
+declare const TCNET_DATA_PACKET_TYPE_IDS: Readonly<{
+    METRICS_DATA: 2;
+    METADATA: 4;
+    BEAT_GRID_DATA: 8;
+    CUE_DATA: 12;
+    SMALL_WAVEFORM: 16;
+    BIG_WAVEFORM: 32;
+    MIXER_DATA: 150;
+}>;
+type TCNetDataPacketType = keyof typeof TCNET_DATA_PACKET_TYPE_IDS;
+declare const getTcNetDataPacketType: (id: number) => TCNetDataPacketType;
+declare const TCNET_NODE_TYPE_IDS: Readonly<{
+    AUTO: 1;
+    MASTER: 2;
+    SLAVE: 4;
+    REPEATER: 8;
+}>;
+type TCNetNodeType = keyof typeof TCNET_NODE_TYPE_IDS;
+declare const getTcNetNodeType: (id: number) => TCNetNodeType;
+declare const TCNET_PORT_NODE_OPTION_FLAGS: Readonly<{
+    NEED_AUTHENTICATION: 1;
+    /**
+     * Listens to TCNet Control Messages
+     */
+    SUPPORTS_TCNCM: 2;
+    /**
+     * Listens to TCNet Application Specific Data Packets
+     */
+    SUPPORTS_TCNASDP: 4;
+    /**
+     * Do not disturb/Sleeping. Node will request data itself if needed to avoid traffic
+     */
+    DO_NOT_DISTURB: 8;
+}>;
+type TCNetPortNodeOption = keyof typeof TCNET_PORT_NODE_OPTION_FLAGS;
+type TCNetPortNodeOptions = Partial<Record<TCNetPortNodeOption, true | undefined>>;
+declare const parseTcNetPortNodeOptions: (flags: number) => TCNetPortNodeOptions;
+declare const generateTcNetPortNodeOptionsFlags: (options: TCNetPortNodeOptions) => number;
+declare const TCNET_LAYER_TC_STATE_IDS: Readonly<{
+    STOPPED: 0;
+    RUNNING: 1;
+    FORCE_RESYNC: 2;
+}>;
+type TCNetLayerTCState = keyof typeof TCNET_LAYER_TC_STATE_IDS;
+declare const getTcNetLayerTCState: (id: number) => TCNetLayerTCState;
+declare const MAX_NODE_ID: number;
+declare const MGMT_HEADER_VERSION = 3;
+declare const MGMT_HEADER_MINOR_VERSION = 5;
+type TCNetManagementHeader = {
+    /**
+     * Unique Node ID. When multiple applications/services are running on same IP, this number must be unique
+     */
+    nodeId: number;
+    protocolVersionMajor: number;
+    protocolVersionMinor: number;
+    messageType: TCNetMessageType;
+    /**
+     * GW Code of software/machine/source that sends packet.
+     */
+    nodeName: Buffer;
+    /**
+     * Sequence number of packet
+     */
+    seq: number;
+    nodeType: TCNetNodeType;
+    nodeOptions: TCNetPortNodeOptions;
+    timestamp: number;
+};
+type TCNetManagementHeaderWithoutMessageType = Omit<TCNetManagementHeader, 'messageType'>;
+declare const writeManagementHeader: (buffer: Buffer, header: TCNetManagementHeaderWithoutMessageType, messageType: TCNetMessageType) => void;
+declare const parseManagementHeader: (buffer: Buffer) => TCNetManagementHeader;
+type TCNetBasePacket<T extends TCNetMessageType> = {
+    header: TCNetManagementHeaderWithoutMessageType;
+    type: T;
+};
+type TCNetOptInPacket = TCNetBasePacket<'OPT_IN'> & {
+    /**
+     * Number of nodes registered by system
+     */
+    nodeCount: number;
+    /**
+     * Listener port of node (Used to receive unicast messages)
+     */
+    nodeListenerPort: number;
+    uptime: number;
+    vendorName: Buffer;
+    applicationName: Buffer;
+    applicationVersion: Buffer;
+};
+declare const writeOptInPacket: (data: Omit<TCNetOptInPacket, "type">) => Buffer;
+type TCNetOptOutPacket = TCNetBasePacket<'OPT_OUT'> & Pick<TCNetOptInPacket, 'nodeCount' | 'nodeListenerPort'>;
+declare const writeOptOutPacket: (data: Omit<TCNetOptOutPacket, "type">) => Buffer;
+type TCNetStatusPacketLayer = {
+    source: number;
+    status: TCNetLayerState;
+    trackId: number;
+    name: string;
+};
+type TCNetStatusPacket = TCNetBasePacket<'STATUS'> & {
+    nodeCount: number;
+    nodeListenerPort: number;
+    smpteMode: number;
+    /**
+     * Auto Master mode on node (0=Disabled, 1=HTP Master, 2=Link Master)
+     */
+    autoMasterMode: number;
+    layers: TCNetStatusPacketLayer[];
+};
+type TCNetRequestPacket = TCNetBasePacket<'REQUEST'> & {
+    dataType: TCNetDataPacketType;
+    layer: LayerDataId;
+};
+declare const writeRequestPacket: (data: Omit<TCNetRequestPacket, "type">) => Buffer;
+type TCNetApplicationSpecificData1Packet = TCNetBasePacket<'APPLICATION_SPECIFIC_DATA_1'>;
+type TCNetDataPacket<D extends TCNetDataPacketType> = TCNetBasePacket<'DATA'> & {
+    dataType: D;
+};
+type TCNetMetricsDataPacket = TCNetDataPacket<'METRICS_DATA'> & {
+    /**
+     * Layer number of layer sending data.
+     *
+     * see {@link LayerDataId}
+     */
+    layer: LayerDataId;
+    /** Play head status of layer */
+    state: TCNetLayerState;
+    /** Sync master status of layer. Example use of this status is to follow the current active layer and allows auto cue to this layer.  */
+    syncMaster: number;
+    /**
+     * Range 1-4
+     */
+    beatMarker: number;
+    trackLengthMillis: number;
+    /**
+     * Play head position of layer
+     */
+    currentPositionMillis: number;
+    /**
+     * Play head speed on layer
+     *
+     * 0~65536 (Where 32768 = 100% speed, 0 = 0% Speed, 65536=200% speed)
+     */
+    speed: number;
+    beatNumber: number;
+    /** Play head BPM speed of layer. Example: 0.01~999.99  */
+    bpm: number;
+    /**
+     * Play head speed bend value of layer. (Used for live adjust.)
+     * Example: 0~65536 (Where 32768 = 100% speed, 0 = 0% Speed, 65536=200% speed)
+     */
+    pitchBend: number;
+    /**
+     * Track ID number of the track that is loaded on layer. This is usually the database ID number. (Used to reflect track selection changes)
+     */
+    trackId: number;
+};
+type TCNetMetadataDataPacket = TCNetDataPacket<'METADATA'> & {
+    /**
+     * Layer number of layer sending data.
+     *
+     * see {@link LayerDataId}
+     */
+    layer: LayerDataId;
+    trackArtist: string;
+    trackTitle: string;
+    trackKey: number;
+    /**
+     * @deprecated Note that ShowKontrol seems to not consistently send the correct
+     * trackID here, and you need to rely on the trackID from the status packet instead.
+     */
+    trackId: number;
+};
+type TCNetMixerDataPacket = TCNetDataPacket<'MIXER_DATA'> & {
+    mixerId: number;
+    mixerType: TCNetMixerType;
+    mixerName: string;
+    micEqHi: number;
+    micEqLow: number;
+    masterAudioLevel: number;
+    masterFaderLevel: number;
+};
+type AnyTCNetDataPacket = TCNetMetricsDataPacket | TCNetMetadataDataPacket | TCNetMixerDataPacket;
+/**
+ * 24=24FPS (FILM)
+ * 25=25FPS (EBU)
+ * 29=29.7FPS (DF)
+ * 30=30FPS (NTSC)
+ */
+type SMPTEFramerate = 24 | 25 | 29 | 30;
+type TCNetTimePacketLayer = {
+    currentTimeMillis: number;
+    totalTimeMillis: number;
+    /**
+     * 0 = unknown, 1-4 = beat position in current bar
+     */
+    beatMarker: number;
+    state: TCNetLayerState;
+    smpte: {
+        /**
+         * See {@link SMPTEFramerate}
+         */
+        mode: null | SMPTEFramerate;
+        state: TCNetLayerTCState;
+        hours: number;
+        minutes: number;
+        seconds: number;
+        frames: number;
+    };
+    /**
+     * OnAir State & Fader Position (0-255) (Example: 0=Not on Air, >=1 =On Air)
+     *
+     * Note: ShowKontrol does not seem to include the actual mixer value here,
+     * and only sends 0 or 1.
+     */
+    onAir: number;
+};
+type TCNetTimePacketLayers = [
+    TCNetTimePacketLayer,
+    TCNetTimePacketLayer,
+    TCNetTimePacketLayer,
+    TCNetTimePacketLayer,
+    TCNetTimePacketLayer,
+    TCNetTimePacketLayer,
+    TCNetTimePacketLayer,
+    TCNetTimePacketLayer
+];
+type TCNetTimePacket = TCNetBasePacket<'TIME'> & {
+    /**
+     * All layers:
+     * - 0 - L1
+     * - 1 - L2
+     * - 2 - L3
+     * - 3 - L4
+     * - 4 - LA
+     * - 5 - LB
+     * - 6 - MASTER
+     * - 7 - LC
+     */
+    layers: TCNetTimePacketLayers;
+    generalSmpteFramerate: SMPTEFramerate;
+};
+type TCNetPacket = TCNetOptInPacket | TCNetOptOutPacket | TCNetStatusPacket | TCNetApplicationSpecificData1Packet | TCNetTimePacket | AnyTCNetDataPacket;
+declare const parsePacket: (buffer: Buffer) => TCNetPacket;
+
+export { type AnyTCNetDataPacket, type LayerDataId, MAX_NODE_ID, MGMT_HEADER_MINOR_VERSION, MGMT_HEADER_VERSION, type SMPTEFramerate, TCNET_LAYER_COUNT, type TCNetApplicationSpecificData1Packet, type TCNetDataPacket, type TCNetDataPacketType, type TCNetLayerState, type TCNetLayerTCState, type TCNetManagementHeader, type TCNetManagementHeaderWithoutMessageType, type TCNetMessageType, type TCNetMetadataDataPacket, type TCNetMetricsDataPacket, type TCNetMixerDataPacket, type TCNetMixerType, type TCNetNodeType, type TCNetOptInPacket, type TCNetOptOutPacket, type TCNetPacket, type TCNetPortNodeOption, type TCNetPortNodeOptions, type TCNetRequestPacket, type TCNetStatusPacket, type TCNetStatusPacketLayer, type TCNetTimePacket, type TCNetTimePacketLayer, generateTcNetPortNodeOptionsFlags, getTcNetDataPacketType, getTcNetLayerState, getTcNetLayerTCState, getTcNetMessageType, getTcNetMixerType, getTcNetNodeType, parseManagementHeader, parsePacket, parseTcNetPortNodeOptions, writeManagementHeader, writeOptInPacket, writeOptOutPacket, writeRequestPacket };