alphatheta-connect 0.15.0

package/lib/passive/alphatheta.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Cross-platform utilities for detecting AlphaTheta (Pioneer DJ) network interfaces.
+ * Supports both USB-connected devices (XDJ-XZ, XDJ-AZ) and Ethernet-connected devices.
+ */
+import { type NetworkInterfaceInfo } from 'os';
+export interface AlphaThetaInterface {
+    /** The interface name (e.g., "en15" on macOS, "Ethernet 3" on Windows) */
+    name: string;
+    /** The MAC address of the interface */
+    mac: string;
+    /** The IPv4 address of the host on this interface */
+    ipv4?: string;
+    /** The full NetworkInterfaceInfo from Node.js */
+    info: NetworkInterfaceInfo;
+    /** How the device is connected */
+    connectionType: 'usb' | 'ethernet';
+    /** IP addresses of AlphaTheta devices found on this interface */
+    deviceIps?: string[];
+}
+/**
+ * Find the network interface for an AlphaTheta device connected via USB or Ethernet.
+ * Works on macOS, Windows, and Linux.
+ *
+ * Detection methods (tried in order):
+ * 1. USB: Looks for USB-connected devices (XDJ-XZ, XDJ-AZ) via system APIs
+ * 2. Ethernet: Checks ARP cache for known AlphaTheta/Pioneer MAC address prefixes
+ *
+ * This is useful for passive mode to automatically detect the correct interface
+ * for AlphaTheta devices like XDJ-XZ, XDJ-AZ, CDJ-3000, etc.
+ *
+ * @example
+ * ```typescript
+ * import { findAlphaThetaInterface, bringOnlinePassive } from 'alphatheta-connect';
+ *
+ * const iface = findAlphaThetaInterface();
+ * if (iface) {
+ *   console.log(`Found AlphaTheta device on ${iface.name} (${iface.connectionType})`);
+ *   const network = await bringOnlinePassive({ iface: iface.name });
+ * }
+ * ```
+ *
+ * @returns The AlphaTheta interface info, or null if not found
+ */
+export declare function findAlphaThetaInterface(): AlphaThetaInterface | null;
+/**
+ * Find ALL network interfaces with AlphaTheta/Pioneer DJ devices.
+ * Works on macOS, Windows, and Linux.
+ *
+ * Detection methods:
+ * 1. USB: Looks for USB-connected devices (XDJ-XZ, XDJ-AZ) via system APIs
+ * 2. Ethernet: Checks ARP cache for known AlphaTheta/Pioneer MAC address prefixes
+ *
+ * Returns all detected interfaces, with USB interfaces listed first.
+ * Use this when you want to present users with a choice of interfaces,
+ * or when multiple Pro DJ Link networks are available.
+ *
+ * @example
+ * ```typescript
+ * import { findAllAlphaThetaInterfaces, bringOnlinePassive } from 'alphatheta-connect';
+ *
+ * const interfaces = findAllAlphaThetaInterfaces();
+ * if (interfaces.length > 0) {
+ *   console.log('Available interfaces:');
+ *   for (const iface of interfaces) {
+ *     console.log(`  ${iface.name} (${iface.connectionType}) - ${iface.ipv4 || 'no IP'}`);
+ *   }
+ *
+ *   // Let user choose or use first one
+ *   const network = await bringOnlinePassive({ iface: interfaces[0].name });
+ * }
+ * ```
+ *
+ * @returns Array of AlphaTheta interface info, empty if none found
+ */
+export declare function findAllAlphaThetaInterfaces(): AlphaThetaInterface[];
+/**
+ * Get the device IP address from a link-local interface.
+ *
+ * When connected via USB, the device typically uses a link-local address
+ * in the 169.254.x.x range. The device's IP can often be inferred from
+ * the host's IP (they're usually on the same /16 subnet).
+ *
+ * @param hostIp - The host's IP address on the interface
+ * @returns The likely device IP, or null if not determinable
+ */
+export declare function inferDeviceIpFromHost(hostIp: string): string | null;
+/**
+ * Try to find the device IP by checking the ARP cache.
+ * Works on macOS and Linux.
+ *
+ * @param interfaceName - The interface name to check
+ * @returns Array of IP addresses found in ARP cache for this interface
+ */
+export declare function getArpCacheForInterface(interfaceName: string): string[];

package/lib/passive/devices.d.ts

@@ -0,0 +1,64 @@
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Device, DeviceID } from "../types";
+import { PcapAdapter } from './pcap-adapter';
+interface Config {
+    /**
+     * Time in milliseconds after which a device is considered to have
+     * disconnected if it has not broadcast an announcement.
+     *
+     * @default 10000 ms
+     */
+    deviceTimeout?: number;
+}
+/**
+ * The interface the passive device manager event emitter should follow
+ */
+interface DeviceEvents {
+    /**
+     * Fired when a new device becomes available on the network
+     */
+    connected: (device: Device) => void;
+    /**
+     * Fired when a device has not announced itself on the network for the
+     * specified timeout.
+     */
+    disconnected: (device: Device) => void;
+    /**
+     * Fired every time the device announces itself on the network
+     */
+    announced: (device: Device) => void;
+}
+type Emitter = StrictEventEmitter<EventEmitter, DeviceEvents>;
+/**
+ * PassiveDeviceManager tracks devices on the Pro DJ Link network using
+ * passive packet capture instead of UDP sockets.
+ *
+ * It provides the same API as the active DeviceManager, making it easy
+ * to swap between active and passive modes.
+ */
+export declare class PassiveDeviceManager {
+    #private;
+    constructor(adapter: PcapAdapter, config?: Config);
+    on: Emitter['on'];
+    off: Emitter['off'];
+    once: Emitter['once'];
+    /**
+     * Get active devices on the network.
+     */
+    get devices(): Map<number, Device>;
+    /**
+     * Waits for a specific device ID to appear on the network, with a
+     * configurable timeout, in which case it will resolve with null.
+     */
+    getDeviceEnsured(id: DeviceID, timeout?: number): Promise<Device | null>;
+    /**
+     * Reconfigure the device manager.
+     */
+    reconfigure(config: Config): void;
+    /**
+     * Stop listening to the pcap adapter and clean up timeouts.
+     */
+    stop(): void;
+}
+export default PassiveDeviceManager;

package/lib/passive/index.d.ts

@@ -0,0 +1,169 @@
+import { DatabasePreference } from "../localdb/database-adapter";
+import { MixstatusProcessor } from "../mixstatus";
+import { PassiveDeviceManager } from './devices';
+import { PassiveLocalDatabase } from './localdb';
+import { PcapAdapter } from './pcap-adapter';
+import { PassivePositionEmitter } from './position';
+import { PassiveRemoteDatabase } from './remotedb';
+import { PassiveStatusEmitter } from './status';
+export { AlphaThetaInterface, findAlphaThetaInterface, findAllAlphaThetaInterfaces, getArpCacheForInterface, } from './alphatheta';
+export { PassiveDeviceManager } from './devices';
+export { PassiveLocalDatabase } from './localdb';
+export { PacketInfo, PcapAdapter, PcapAdapterConfig } from './pcap-adapter';
+export { PassivePositionEmitter } from './position';
+export { PassiveRemoteDatabase } from './remotedb';
+export { PassiveStatusEmitter } from './status';
+export interface PassiveNetworkConfig {
+    /**
+     * Network interface name (e.g., 'en0', 'eth0', 'en15' for USB-connected devices)
+     */
+    iface: string;
+    /**
+     * Buffer size for packet capture in bytes
+     * @default 10485760 (10MB)
+     */
+    bufferSize?: number;
+    /**
+     * Time in milliseconds after which a device is considered disconnected
+     * @default 10000
+     */
+    deviceTimeout?: number;
+    /**
+     * Database format preference for loading rekordbox databases.
+     *
+     * - 'auto': Try OneLibrary first (rekordbox 7.x+), fall back to PDB (rekordbox 6.x)
+     * - 'oneLibrary': Only use OneLibrary format (exportLibrary.db)
+     * - 'pdb': Only use PDB format (export.pdb)
+     *
+     * @default 'auto'
+     */
+    databasePreference?: DatabasePreference;
+}
+/**
+ * PassiveProlinkNetwork provides a passive monitoring interface to the
+ * Pro DJ Link network using pcap packet capture.
+ *
+ * Unlike the active ProlinkNetwork, passive mode:
+ * - Does not bind to UDP ports (no conflicts with Rekordbox)
+ * - Does not announce a virtual CDJ (devices don't know we exist)
+ * - Cannot send packets (no CDJ control, no queryMediaSlot)
+ * - Works with USB-connected devices (XDJ-AZ, XDJ-XZ)
+ *
+ * Requirements:
+ * - Root/sudo privileges for packet capture
+ * - libpcap (Linux) or Npcap/WinPcap (Windows)
+ * - The 'cap' npm module
+ */
+export declare class PassiveProlinkNetwork {
+    #private;
+    constructor(config: PassiveNetworkConfig);
+    /**
+     * Start passive packet capture.
+     * Requires root/sudo privileges.
+     */
+    start(): void;
+    /**
+     * Stop packet capture and clean up all resources.
+     */
+    stop(): void;
+    /**
+     * Check if packet capture is active.
+     */
+    get isCapturing(): boolean;
+    /**
+     * Get the network interface being monitored.
+     */
+    get interfaceName(): string;
+    /**
+     * Get the pcap adapter for advanced usage.
+     */
+    get adapter(): PcapAdapter;
+    /**
+     * Get the PassiveDeviceManager service. Tracks devices on the network
+     * by listening to announcement packets.
+     */
+    get deviceManager(): PassiveDeviceManager;
+    /**
+     * Get the PassiveStatusEmitter service. Reports CDJ status updates
+     * received via packet capture.
+     */
+    get statusEmitter(): PassiveStatusEmitter;
+    /**
+     * Get the PassivePositionEmitter service. Reports absolute playhead
+     * position updates from CDJ-3000+ devices.
+     */
+    get positionEmitter(): PassivePositionEmitter;
+    /**
+     * Get the PassiveLocalDatabase service. Provides access to rekordbox
+     * databases on devices using NFS (works without announcing a VCDJ).
+     */
+    get localdb(): PassiveLocalDatabase;
+    /**
+     * Get (and initialize) the PassiveRemoteDatabase service. Provides access
+     * to track metadata via RemoteDB queries.
+     *
+     * Note: This sends TCP packets to devices, so it's not fully "passive",
+     * but it avoids UDP announcements that would conflict with Rekordbox.
+     *
+     * Useful for getting metadata for Rekordbox Link tracks where NFS
+     * access is not available.
+     */
+    get remotedb(): PassiveRemoteDatabase;
+    /**
+     * Get (and initialize) the MixstatusProcessor service. Can be used to
+     * monitor the 'status' of devices on the network as a whole.
+     */
+    get mixstatus(): MixstatusProcessor;
+}
+/**
+ * Create and start a passive Pro DJ Link network monitor.
+ *
+ * This is the primary entrypoint for passive mode. It captures Pro DJ Link
+ * packets via pcap without binding to UDP ports or announcing a virtual CDJ.
+ *
+ * @example
+ * ```typescript
+ * import { bringOnlinePassive } from 'alphatheta-connect';
+ *
+ * // Start passive monitoring on en15 (XDJ-XZ USB interface)
+ * const network = await bringOnlinePassive({ iface: 'en15' });
+ *
+ * // Listen for devices
+ * network.deviceManager.on('connected', device => {
+ *   console.log('Device connected:', device.name);
+ * });
+ *
+ * // Listen for track changes
+ * network.statusEmitter.on('status', status => {
+ *   console.log('Track:', status.trackId);
+ * });
+ *
+ * // Get track metadata via NFS
+ * const track = await network.localdb.get(device.id, MediaSlot.USB);
+ *
+ * // Cleanup
+ * network.stop();
+ * ```
+ *
+ * @param config - Configuration including network interface name
+ * @returns PassiveProlinkNetwork instance
+ */
+export declare function bringOnlinePassive(config: PassiveNetworkConfig): PassiveProlinkNetwork;
+/**
+ * List available network interfaces that can be used for packet capture.
+ * Useful for finding USB-connected DJ hardware interfaces.
+ *
+ * @example
+ * ```typescript
+ * import { listInterfaces } from 'alphatheta-connect/passive';
+ *
+ * const interfaces = listInterfaces();
+ * console.log(interfaces);
+ * // [{ name: 'en0', address: '192.168.1.100' }, { name: 'en15', address: '169.254.x.x' }]
+ * ```
+ */
+export declare function listInterfaces(): Array<{
+    name: string;
+    address: string;
+    description?: string;
+}>;

package/lib/passive/localdb.d.ts

@@ -0,0 +1,122 @@
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { DatabaseAdapter, DatabasePreference } from "../localdb/database-adapter";
+import { HydrationProgress } from "../localdb/rekordbox";
+import { FetchProgress } from "../nfs";
+import { Device, DeviceID, MediaSlot, MediaSlotInfo } from "../types";
+import { PassiveDeviceManager } from './devices';
+import { PassiveStatusEmitter } from './status';
+/**
+ * Rekordbox databases will only exist within these two slots
+ */
+type DatabaseSlot = MediaSlot.USB | MediaSlot.SD;
+interface CommonProgressOpts {
+    device: Device;
+    slot: MediaSlot;
+}
+type DownloadProgressOpts = CommonProgressOpts & {
+    progress: FetchProgress;
+};
+type HydrationProgressOpts = CommonProgressOpts & {
+    progress: HydrationProgress;
+};
+type HydrationDoneOpts = CommonProgressOpts;
+/**
+ * Events that may be triggered by the PassiveLocalDatabase emitter
+ */
+interface DatabaseEvents {
+    /**
+     * Triggered when we are fetching a database from a CDJ
+     */
+    fetchProgress: (opts: DownloadProgressOpts) => void;
+    /**
+     * Triggered when we are hydrating a rekordbox database into the in-memory
+     * sqlite database.
+     */
+    hydrationProgress: (opts: HydrationProgressOpts) => void;
+    /**
+     * Triggered when the database has been fully hydrated.
+     */
+    hydrationDone: (opts: HydrationDoneOpts) => void;
+}
+type Emitter = StrictEventEmitter<EventEmitter, DatabaseEvents>;
+/**
+ * PassiveLocalDatabase provides access to rekordbox databases on devices
+ * using passive packet capture.
+ *
+ * Unlike the active LocalDatabase, this version:
+ * - Cannot query for media slot info (no queryMediaSlot)
+ * - Listens for mediaSlot broadcasts to cache media info
+ * - Provides getWithMedia() method when media info is known
+ *
+ * NFS access to fetch rekordbox databases works without announcing a VCDJ.
+ */
+export declare class PassiveLocalDatabase {
+    #private;
+    constructor(deviceManager: PassiveDeviceManager, statusEmitter: PassiveStatusEmitter, preference?: DatabasePreference);
+    /**
+     * Get the current database preference
+     */
+    get preference(): DatabasePreference;
+    /**
+     * Set the database preference. Only affects newly loaded databases.
+     */
+    set preference(value: DatabasePreference);
+    on: Emitter['on'];
+    off: Emitter['off'];
+    once: Emitter['once'];
+    /**
+     * Get cached media slot info for a device and slot.
+     * Returns undefined if no media slot info has been received.
+     */
+    getCachedMedia(deviceId: DeviceID, slot: DatabaseSlot): MediaSlotInfo | undefined;
+    /**
+     * Get all cached media slot info.
+     */
+    getAllCachedMedia(): MediaSlotInfo[];
+    /**
+     * Disconnects the local database connection for the specified device
+     */
+    disconnectForDevice(device: Device): void;
+    /**
+     * Stop listening to events and clean up.
+     */
+    stop(): void;
+    /**
+     * Gets the database adapter for the media metadata in the provided device slot,
+     * using cached media info.
+     *
+     * This method uses cached media slot info that was received from
+     * broadcast packets. If no media info is cached for this slot,
+     * it will attempt to fetch the database without media info (useful
+     * for all-in-one units like XDJ-XZ that don't broadcast mediaSlot).
+     *
+     * @returns null if no rekordbox media present or fetch fails
+     */
+    get(deviceId: DeviceID, slot: DatabaseSlot): Promise<DatabaseAdapter | null>;
+    /**
+     * Gets the database adapter for the media metadata using provided media slot info.
+     *
+     * Use this method when you have media slot info from another source
+     * (e.g., parsed from status packets or provided manually).
+     *
+     * @returns null if no rekordbox media present
+     */
+    getWithMedia(device: Device, slot: DatabaseSlot, media: MediaSlotInfo): Promise<DatabaseAdapter | null>;
+    /**
+     * Attempts to get/hydrate a database without cached media slot info.
+     * This is used for all-in-one units (XDJ-XZ, XDJ-RX, etc.) that don't
+     * broadcast mediaSlot info packets.
+     *
+     * The method will try to fetch the rekordbox export.pdb file directly
+     * via NFS. If successful, the database is hydrated and cached.
+     *
+     * @returns null if no rekordbox database found or fetch fails
+     */
+    getWithoutMedia(device: Device, slot: DatabaseSlot): Promise<DatabaseAdapter | null>;
+    /**
+     * Preload the databases for all connected devices using cached media info.
+     */
+    preload(): Promise<void>;
+}
+export default PassiveLocalDatabase;

package/lib/passive/pcap-adapter.d.ts

@@ -0,0 +1,77 @@
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+/**
+ * Packet info including source IP (useful for short-format packets
+ * where the IP may not be fully present in the payload).
+ */
+export interface PacketInfo {
+    /** The UDP payload */
+    payload: Buffer;
+    /** Source IP address (e.g., '169.254.88.83') */
+    srcAddr: string;
+}
+interface PcapAdapterEvents {
+    /**
+     * Fired when a device announcement packet is received (port 50000)
+     */
+    announce: (packet: Buffer, info: PacketInfo) => void;
+    /**
+     * Fired when a status packet is received (port 50002)
+     */
+    status: (packet: Buffer, info: PacketInfo) => void;
+    /**
+     * Fired when a beat/position packet is received (port 50001)
+     */
+    beat: (packet: Buffer, info: PacketInfo) => void;
+    /**
+     * Fired when an error occurs
+     */
+    error: (error: Error) => void;
+}
+type Emitter = StrictEventEmitter<EventEmitter, PcapAdapterEvents>;
+export interface PcapAdapterConfig {
+    /**
+     * Network interface name (e.g., 'en0', 'eth0', 'en15')
+     */
+    iface: string;
+    /**
+     * Buffer size for packet capture in bytes
+     * @default 10485760 (10MB)
+     */
+    bufferSize?: number;
+}
+/**
+ * PcapAdapter captures Pro DJ Link packets via pcap (libpcap).
+ * It extracts UDP payloads and emits them to event listeners based on
+ * destination port.
+ *
+ * This allows passive monitoring of the Pro DJ Link network without
+ * binding to UDP ports or announcing a virtual CDJ.
+ *
+ * NOTE: Requires root/sudo privileges for packet capture.
+ */
+export declare class PcapAdapter {
+    #private;
+    constructor(config: PcapAdapterConfig);
+    on: Emitter['on'];
+    off: Emitter['off'];
+    once: Emitter['once'];
+    /**
+     * Start capturing packets on the configured interface.
+     * Requires root/sudo privileges.
+     */
+    start(): void;
+    /**
+     * Stop capturing packets and release resources.
+     */
+    stop(): void;
+    /**
+     * Check if the adapter is currently capturing.
+     */
+    get isCapturing(): boolean;
+    /**
+     * Get the interface name being captured.
+     */
+    get interfaceName(): string;
+}
+export default PcapAdapter;

package/lib/passive/position.d.ts

@@ -0,0 +1,32 @@
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { CDJStatus } from "../types";
+import { PcapAdapter } from './pcap-adapter';
+interface PositionEvents {
+    /**
+     * Fired when an absolute position packet is received from a CDJ-3000+.
+     * These packets are sent approximately every 30ms while a track is loaded.
+     */
+    position: (position: CDJStatus.PositionState) => void;
+}
+type Emitter = StrictEventEmitter<EventEmitter, PositionEvents>;
+/**
+ * PassivePositionEmitter reports absolute playhead position updates from
+ * CDJ-3000+ devices using passive packet capture.
+ *
+ * Position packets provide precise track position independent of beat grids,
+ * enabling accurate timecode, lighting cue, and video synchronization even
+ * during scratching, reverse play, loops, and needle jumps.
+ */
+export declare class PassivePositionEmitter {
+    #private;
+    constructor(adapter: PcapAdapter);
+    on: Emitter['on'];
+    off: Emitter['off'];
+    once: Emitter['once'];
+    /**
+     * Stop listening to the pcap adapter.
+     */
+    stop(): void;
+}
+export default PassivePositionEmitter;

package/lib/passive/remotedb.d.ts

@@ -0,0 +1,49 @@
+import { QueryInterface } from "../remotedb";
+import { Device, DeviceID, MediaSlot, TrackType } from "../types";
+import { PassiveDeviceManager } from './devices';
+/**
+ * PassiveRemoteDatabase provides RemoteDB query support for passive mode.
+ *
+ * This allows querying track metadata from Rekordbox Link without fully
+ * announcing a virtual CDJ on the network. It uses a "virtual" device ID
+ * (default: 5) for the introduction handshake.
+ *
+ * Note: This makes the mode not fully "passive" since we're sending TCP
+ * packets, but we still avoid UDP announcements that would conflict with
+ * Rekordbox.
+ */
+export declare class PassiveRemoteDatabase {
+    #private;
+    constructor(deviceManager: PassiveDeviceManager, virtualDeviceId?: number);
+    /**
+     * Open a connection to the specified device for querying
+     */
+    connectToDevice(device: Device): Promise<void>;
+    /**
+     * Disconnect from the specified device
+     */
+    disconnectFromDevice(device: Device): Promise<void>;
+    /**
+     * Gets the remote database query interface for the given device.
+     *
+     * If we have not already established a connection with the specified device,
+     * we will attempt to first connect.
+     *
+     * @returns null if the device is not found
+     */
+    get(deviceId: DeviceID): Promise<QueryInterface | null>;
+    /**
+     * Query track metadata from a device.
+     *
+     * @param deviceId - The device to query (e.g., 17 for Rekordbox)
+     * @param trackSlot - The media slot (e.g., MediaSlot.RB for Rekordbox Link)
+     * @param trackType - The track type (e.g., TrackType.RB)
+     * @param trackId - The track ID to look up
+     */
+    getTrackMetadata(deviceId: DeviceID, trackSlot: MediaSlot, trackType: TrackType, trackId: number): Promise<import("../types").Track<import("..").EntityFK.WithRelations> | null>;
+    /**
+     * Stop all connections
+     */
+    stop(): void;
+}
+export default PassiveRemoteDatabase;

package/lib/passive/status.d.ts

@@ -0,0 +1,41 @@
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { CDJStatus, MediaSlotInfo } from "../types";
+import { PcapAdapter } from './pcap-adapter';
+interface StatusEvents {
+    /**
+     * Fired each time the CDJ reports its status
+     */
+    status: (status: CDJStatus.State) => void;
+    /**
+     * Fired when the CDJ reports its media slot status
+     */
+    mediaSlot: (info: MediaSlotInfo) => void;
+    /**
+     * Fired when the mixer broadcasts on-air channel status
+     */
+    onAir: (status: CDJStatus.OnAirStatus) => void;
+}
+type Emitter = StrictEventEmitter<EventEmitter, StatusEvents>;
+/**
+ * PassiveStatusEmitter reports CDJ status updates received via passive
+ * packet capture instead of UDP sockets.
+ *
+ * It provides the same event API as the active StatusEmitter, but does
+ * NOT support the queryMediaSlot method since that requires sending packets.
+ *
+ * In passive mode, media slot information is received when CDJs broadcast
+ * it naturally (e.g., when media is inserted or at startup).
+ */
+export declare class PassiveStatusEmitter {
+    #private;
+    constructor(adapter: PcapAdapter);
+    on: Emitter['on'];
+    off: Emitter['off'];
+    once: Emitter['once'];
+    /**
+     * Stop listening to the pcap adapter.
+     */
+    stop(): void;
+}
+export default PassiveStatusEmitter;

package/lib/remotedb/constants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * All remote database messages include this 4 byte magic value.
+ */
+export declare const REMOTEDB_MAGIC = 2267236782;
+/**
+ * The consistent port on which we can query the remote db server for the port
+ */
+export declare const REMOTEDB_SERVER_QUERY_PORT = 12523;