icom-wlan-node 0.6.0 → 0.6.2

package/README.md

@@ -122,10 +122,42 @@ await rig.setTunerEnabled(true);
 const swr = await rig.readSWR();
 const power = await rig.readPowerLevel();
 console.log({ tuner, swr, watts: power?.watts, powerPercent: power?.percent });
+
+// Hamlib A/B-level controls are profile-gated.
+await rig.setFunction('NR', true);
+await rig.setNoiseReductionEnabled(true);
+await rig.setLevel('RF', 0.5);
+await rig.setRitOffset(-120);
+await rig.setSplitEnabled(true);
+await rig.setSplitFrequency(7074000);
+await rig.setTuningStep(100);
+await rig.setToneFrequency(88.5);
+await rig.setSpectrumSpeed('slow');
 ```
 
 Profile-specific behavior includes IC-905 6-byte frequency BCD above 5.85 GHz, model-specific scope fixed-edge ranges, and calibrated SWR/ALC/RF power/COMP/voltage/current meters. Private connector commands such as WLAN level or connector data mode are only enabled when the active profile declares the vendor extension; unsupported writes throw `UnsupportedCommandError`.
 
+### CI-V Query Concurrency
+
+Standard CI-V frames do not include a transaction/request ID, so the library does not add custom bytes to the CI-V payload. Instead, read/query helpers are internally deduplicated by response signature:
+
+```ts
+// Same response key: one real CI-V request, shared result
+const [a, b] = await Promise.all([
+  rig.readOperatingFrequency(),
+  rig.readOperatingFrequency()
+]);
+
+// Different response keys: concurrent requests are allowed
+const [freq, mode, ptt] = await Promise.all([
+  rig.readOperatingFrequency(),
+  rig.readOperatingMode(),
+  rig.readPtt()
+]);
+```
+
+Raw `sendCiv()` is not managed by this query layer. Write methods such as `setFrequency()`, `setMode()`, and `setPtt()` remain fire-and-forget; if your application needs write-after-read consistency, send the write first and then issue the read sequentially.
+
 ### PTT and Audio TX
 
 ```ts
@@ -201,6 +233,10 @@ await rig.disableScope();
   - **Rig Control**: `setFrequency()`, `setMode()`, `setConnectorDataMode()`, `setConnectorWLanLevel()`
   - **Rig Query**: `readOperatingFrequency()`, `readOperatingMode()`, `readTransmitFrequency()`, `readPtt()`, `readTransceiverState()`, `readBandEdges()`
   - **Antenna Tuner**: `readTunerStatus()`, `setTunerEnabled()`, `startManualTune()`
+  - **Functions**: `getFunction()`, `setFunction()`, plus wrappers for NB/NR/COMP/VOX/MON/ANF/MN/LOCK/BK-IN
+  - **Levels**: `getLevel()`, `setLevel()`, plus wrappers for RF gain, IF shift, PBT, CW pitch, key speed, monitor gain, VOX gain
+  - **RIT/XIT + Split/VFO**: `getRitOffset()`, `setRitOffset()`, `getSplitEnabled()`, `setSplitFrequency()`, `getVfo()`, `setVfo()`, `vfoOperation()`
+  - **Tone/Tuning**: `getTuningStep()`, `setTuningStep()`, `getToneFrequency()`, `setToneFrequency()`, `getRepeaterShift()`, `setRepeaterOffset()`
   - **Meters (RX)**: `readSquelchStatus()`, `readAudioSquelch()`, `readOvfStatus()`, `getLevelMeter()`
   - **Meters (TX)**: `readSWR()`, `readALC()`, `readPowerLevel()`, `readCompLevel()`
   - **Power Supply**: `readVoltage()`, `readCurrent()`
@@ -341,6 +377,20 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 - `readTransceiverState(options?: QueryOptions) => Promise<'TX' | 'RX' | 'UNKNOWN' | null>`
 - `readBandEdges(options?: QueryOptions) => Promise<Buffer|null>`
 
+#### Hamlib A/B Functions, Levels, RIT/XIT, Split, and Tone
+
+- `getFunction(name: IcomFunctionName, options?: QueryOptions) => Promise<boolean|null>` / `setFunction(name, enabled)` — Generic Hamlib function layer for supported profile functions such as `NB`, `NR`, `COMP`, `VOX`, `MON`, `ANF`, `MN`, `LOCK`, `RIT`, `XIT`, `TUNER`, `SCOPE`, `SPECTRUM`, `SPECTRUM_HOLD`, and model-specific extensions.
+- Common function wrappers: `getNoiseBlankerEnabled()/setNoiseBlankerEnabled()`, `getNoiseReductionEnabled()/setNoiseReductionEnabled()`, `getCompressorEnabled()/setCompressorEnabled()`, `getVoxEnabled()/setVoxEnabled()`, `getMonitorEnabled()/setMonitorEnabled()`, `getAutoNotchEnabled()/setAutoNotchEnabled()`, `getManualNotchEnabled()/setManualNotchEnabled()`, `getDialLockEnabled()/setDialLockEnabled()`.
+- `getBreakInMode() => Promise<'off'|'semi'|'full'|null>` / `setBreakInMode(mode)` — Hamlib-aligned BK-IN control using `0x16 0x47`, where raw `1` is semi and raw `2` is full.
+- `getLevel(name: IcomLevelName, options?: QueryOptions) => Promise<number|null>` / `setLevel(name, value)` — Generic level layer for `AF`, `RF`, `SQL`, `IF`, `PBT_IN`, `PBT_OUT`, `CWPITCH`, `KEYSPD`, `NOTCHF_RAW`, `COMP`, `MONITOR_GAIN`, `VOXGAIN`, `ANTIVOX`, and profile ext levels.
+- Common level wrappers: `getRFGain()/setRFGain()`, `getIFShift()/setIFShift()`, `getPbtIn()/setPbtIn()`, `getPbtOut()/setPbtOut()`, `getCwPitch()/setCwPitch()`, `getKeySpeed()/setKeySpeed()`, `getNotchRaw()/setNotchRaw()`, `getCompressionLevel()/setCompressionLevel()`, `getMonitorGain()/setMonitorGain()`, `getVoxGain()/setVoxGain()`, `getAntiVox()/setAntiVox()`.
+- `getRitOffset()/setRitOffset()` and `getXitOffset()/setXitOffset()` — RIT/XIT delta register using Hamlib `0x21 0x00`; `getRitEnabled()/setRitEnabled()` and `getXitEnabled()/setXitEnabled()` use `0x21 0x01/0x02`.
+- `getSplitEnabled()/setSplitEnabled()`, `getSplitFrequency()/setSplitFrequency()`, `getSplitMode()/setSplitMode()` — Modern profiles use targetable TX VFO `0x25/0x26` with VFO number `1`.
+- `getVfo()/setVfo()` and `vfoOperation('copy'|'exchange'|'from-vfo'|'to-vfo'|'memory-clear'|'tune')` — Safe Hamlib VFO operation subset.
+- `getTuningStep()/setTuningStep(hz)` — Profile-specific Hamlib tuning step tables.
+- `getToneFrequency()/setToneFrequency(hz)` and `getToneSquelchFrequency()/setToneSquelchFrequency(hz)` — CTCSS values use public Hz, encoded as tenth-Hz BCD BE.
+- `getRepeaterShift()/setRepeaterShift('none'|'minus'|'plus')` and `getRepeaterOffset()/setRepeaterOffset(hz)` — Repeater offset uses public Hz, encoded as 100 Hz units.
+
 #### Scope / Spectrum
 
 - `scope: IcomScopeService` — Standalone scope service object that can be reused with other CI‑V transport paths in the future
@@ -358,6 +408,7 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 - `getSpectrumMode()/setSpectrumMode()` / `getSpectrumSpan()/setSpectrumSpan()` / `getSpectrumEdgeSlot()/setSpectrumEdgeSlot()` / `getSpectrumFixedEdges()/setSpectrumFixedEdges()` — Hamlib-like convenience aliases over the scope-specific methods
 - `getSpectrumDisplayState(options?: QueryOptions & { receiver?: 0 | 1 }) => Promise<IcomSpectrumDisplayState>` — Read a Hamlib-like normalized display state
 - `configureSpectrumDisplay(config?: IcomSpectrumDisplayConfig) => Promise<IcomSpectrumDisplayState>` — Apply a normalized display config covering center/fixed modes
+- `getSpectrumDataOutput()/setSpectrumDataOutput()`, `getSpectrumHold()/setSpectrumHold()`, `getSpectrumSpeed()/setSpectrumSpeed()`, `getSpectrumRef()/setSpectrumRef()`, `getSpectrumAverage()/setSpectrumAverage()`, `getSpectrumVbw()/setSpectrumVbw()`, `getSpectrumRbw()/setSpectrumRbw()`, `getSpectrumDuringTx()/setSpectrumDuringTx()`, `getSpectrumCenterType()/setSpectrumCenterType()` — Advanced Hamlib spectrum controls where the active profile supports them
 - `waitForScopeFrame(options?: QueryOptions) => Promise<IcomScopeFrame | null>` — Wait for the next complete scope frame
 
 `IcomScopeFrame` shape:
@@ -412,6 +463,8 @@ Current implementation notes:
 
 **Audio Configuration**:
 - `getUsbAfLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` / `setUsbAfLevel(level: number)` — Hamlib-aligned USB AF level when the active profile declares it
+- `getAudioIfMode(options?: QueryOptions) => Promise<'default'|'wlan'|'lan'|'acc'|null>` / `setAudioIfMode(source)` — Hamlib AF/IF audio routing for profile-supported WLAN/LAN/ACC parameters
+- `getParameter(name, options?)` / `setParameter(name, value)` — Generic profile ext-param API for `BEEP`, `BACKLIGHT`, `SCREENSAVER`, `TIME`, `KEYERTYPE`, and `AFIF*`
 - `getConnectorWLanLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` / `setConnectorWLanLevel(level: number)` — Private `icom-wlan-node` WLAN level extension; returns `null` or throws `UnsupportedCommandError` when the active profile does not declare it
 
 #### Connector Settings

package/dist/rig/IcomCivRequestManager.d.ts

@@ -0,0 +1,22 @@
+import type { RigEventEmitter } from '../types';
+export interface CivQueryOptions {
+    key: string;
+    predicate: (frame: Buffer) => boolean;
+    timeoutMs: number;
+    send: () => void;
+}
+/**
+ * Deduplicates identical CI-V read queries while allowing different reply
+ * signatures to wait concurrently on the shared civFrame stream.
+ */
+export declare class IcomCivRequestManager {
+    private readonly events;
+    private pending;
+    private readonly onFrameBound;
+    constructor(events: RigEventEmitter);
+    query(options: CivQueryOptions): Promise<Buffer | null>;
+    dispose(): void;
+    getPendingCount(): number;
+    private onFrame;
+    private finish;
+}

package/dist/rig/IcomCivRequestManager.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcomCivRequestManager = void 0;
+/**
+ * Deduplicates identical CI-V read queries while allowing different reply
+ * signatures to wait concurrently on the shared civFrame stream.
+ */
+class IcomCivRequestManager {
+    constructor(events) {
+        this.events = events;
+        this.pending = new Map();
+        this.onFrameBound = (frame) => this.onFrame(frame);
+        this.events.on('civFrame', this.onFrameBound);
+    }
+    query(options) {
+        const existing = this.pending.get(options.key);
+        if (existing) {
+            return existing.promise;
+        }
+        let entry;
+        const promise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.pending.get(options.key) === entry) {
+                    this.pending.delete(options.key);
+                }
+                resolve(null);
+            }, options.timeoutMs);
+            entry = {
+                promise: undefined,
+                predicate: options.predicate,
+                resolve,
+                reject,
+                timer,
+            };
+        });
+        entry.promise = promise;
+        this.pending.set(options.key, entry);
+        try {
+            options.send();
+        }
+        catch (err) {
+            this.finish(options.key, entry, null, err);
+        }
+        return promise;
+    }
+    dispose() {
+        this.events.off('civFrame', this.onFrameBound);
+        for (const [key, entry] of this.pending) {
+            this.finish(key, entry, null);
+        }
+    }
+    getPendingCount() {
+        return this.pending.size;
+    }
+    onFrame(frame) {
+        for (const [key, entry] of Array.from(this.pending.entries())) {
+            if (entry.predicate(frame)) {
+                this.finish(key, entry, frame);
+            }
+        }
+    }
+    finish(key, entry, frame, err) {
+        if (this.pending.get(key) === entry) {
+            this.pending.delete(key);
+        }
+        clearTimeout(entry.timer);
+        if (err !== undefined) {
+            entry.reject(err);
+            return;
+        }
+        entry.resolve(frame);
+    }
+}
+exports.IcomCivRequestManager = IcomCivRequestManager;

package/dist/rig/IcomCivSpec.d.ts

@@ -10,29 +10,101 @@ export declare const CIV: {
     readonly C_RD_MODE: 4;
     readonly C_SET_FREQ: 5;
     readonly C_SET_MODE: 6;
+    readonly C_SET_VFO: 7;
+    readonly C_WR_MEM: 9;
+    readonly C_MEM2VFO: 10;
+    readonly C_CLR_MEM: 11;
+    readonly C_RD_OFFS: 12;
+    readonly C_SET_OFFS: 13;
+    readonly C_CTL_SCAN: 14;
+    readonly C_CTL_SPLT: 15;
+    readonly C_SET_TS: 16;
+    readonly C_CTL_ATT: 17;
+    readonly C_CTL_ANT: 18;
+    readonly C_CTL_ANN: 19;
     readonly C_CTL_LVL: 20;
     readonly C_RD_SQSM: 21;
     readonly C_CTL_FUNC: 22;
+    readonly C_SET_TONE: 27;
     readonly C_CTL_MEM: 26;
     readonly C_CTL_PTT: 28;
+    readonly C_CTL_RIT: 33;
     readonly C_SEND_SEL_FREQ: 37;
     readonly C_SEND_SEL_MODE: 38;
     readonly C_CTL_SCP: 39;
+    readonly S_VFOA: 0;
+    readonly S_VFOB: 1;
+    readonly S_BTOA: 160;
+    readonly S_XCHNG: 176;
+    readonly S_SUBTOMAIN: 177;
+    readonly S_DUAL_OFF: 192;
+    readonly S_DUAL_ON: 193;
+    readonly S_DUAL: 194;
+    readonly S_MAIN: 208;
+    readonly S_SUB: 209;
+    readonly S_BAND_SEL: 210;
+    readonly S_SPLT_OFF: 0;
+    readonly S_SPLT_ON: 1;
+    readonly S_DUP_OFF: 16;
+    readonly S_DUP_M: 17;
+    readonly S_DUP_P: 18;
     readonly S_PTT: 0;
     readonly S_ANT_TUN: 1;
     readonly S_RD_TX_FREQ: 3;
+    readonly S_RIT_FREQ: 0;
+    readonly S_RIT: 1;
+    readonly S_XIT: 2;
     readonly S_MEM_PARM: 5;
     readonly S_MEM_DATA_MODE: 6;
+    readonly S_MEM_DUALMODE: 89;
+    readonly S_MEM_SATMODE: 90;
     readonly S_LVL_AF: 1;
     readonly S_LVL_RF: 2;
     readonly S_LVL_SQL: 3;
+    readonly S_LVL_IF: 4;
+    readonly S_LVL_APF: 5;
     readonly S_LVL_NR: 6;
+    readonly S_LVL_PBTIN: 7;
+    readonly S_LVL_PBTOUT: 8;
+    readonly S_LVL_CWPITCH: 9;
     readonly S_LVL_RFPOWER: 10;
     readonly S_LVL_MICGAIN: 11;
+    readonly S_LVL_KEYSPD: 12;
+    readonly S_LVL_NOTCHF: 13;
     readonly S_LVL_COMP: 14;
     readonly S_LVL_BKINDL: 15;
+    readonly S_LVL_BALANCE: 16;
+    readonly S_LVL_AGC: 17;
     readonly S_LVL_NB: 18;
     readonly S_LVL_DIGI: 19;
+    readonly S_LVL_DRIVE: 20;
+    readonly S_LVL_MON: 21;
+    readonly S_LVL_VOXGAIN: 22;
+    readonly S_LVL_ANTIVOX: 23;
+    readonly S_FUNC_PAMP: 2;
+    readonly S_FUNC_AGC: 18;
+    readonly S_FUNC_NB: 34;
+    readonly S_FUNC_APF: 50;
+    readonly S_FUNC_NR: 64;
+    readonly S_FUNC_ANF: 65;
+    readonly S_FUNC_TONE: 66;
+    readonly S_FUNC_TSQL: 67;
+    readonly S_FUNC_COMP: 68;
+    readonly S_FUNC_MON: 69;
+    readonly S_FUNC_VOX: 70;
+    readonly S_FUNC_BKIN: 71;
+    readonly S_FUNC_MN: 72;
+    readonly S_FUNC_RF: 73;
+    readonly S_FUNC_AFC: 74;
+    readonly S_FUNC_VSC: 76;
+    readonly S_FUNC_DIGISEL: 78;
+    readonly S_FUNC_DIAL_LK: 80;
+    readonly S_FUNC_SATM: 90;
+    readonly S_FUNC_IPP: 101;
+    readonly S_FUNC_TX_INHIBIT: 102;
+    readonly S_FUNC_DPP: 103;
+    readonly S_TONE_RPTR: 0;
+    readonly S_TONE_SQL: 1;
     readonly S_SQL: 1;
     readonly S_SML: 2;
     readonly S_CSQL: 5;
@@ -46,9 +118,20 @@ export declare const CIV: {
     readonly S_SCP_DAT: 0;
     readonly S_SCP_STS: 16;
     readonly S_SCP_DOP: 17;
+    readonly S_SCP_MSS: 18;
+    readonly S_SCP_SDS: 19;
     readonly S_SCP_MOD: 20;
     readonly S_SCP_SPN: 21;
     readonly S_SCP_EDG: 22;
+    readonly S_SCP_HLD: 23;
+    readonly S_SCP_ATT: 24;
+    readonly S_SCP_REF: 25;
+    readonly S_SCP_SWP: 26;
+    readonly S_SCP_STX: 27;
+    readonly S_SCP_CFQ: 28;
+    readonly S_SCP_VBW: 29;
     readonly S_SCP_FEF: 30;
+    readonly S_SCP_RBW: 31;
+    readonly S_SCP_MKP: 32;
 };
 export declare const ICOM_MODE_FILTER_DEFAULT: 1;

package/dist/rig/IcomCivSpec.js

@@ -13,29 +13,101 @@ exports.CIV = {
     C_RD_MODE: 0x04,
     C_SET_FREQ: 0x05,
     C_SET_MODE: 0x06,
+    C_SET_VFO: 0x07,
+    C_WR_MEM: 0x09,
+    C_MEM2VFO: 0x0a,
+    C_CLR_MEM: 0x0b,
+    C_RD_OFFS: 0x0c,
+    C_SET_OFFS: 0x0d,
+    C_CTL_SCAN: 0x0e,
+    C_CTL_SPLT: 0x0f,
+    C_SET_TS: 0x10,
+    C_CTL_ATT: 0x11,
+    C_CTL_ANT: 0x12,
+    C_CTL_ANN: 0x13,
     C_CTL_LVL: 0x14,
     C_RD_SQSM: 0x15,
     C_CTL_FUNC: 0x16,
+    C_SET_TONE: 0x1b,
     C_CTL_MEM: 0x1a,
     C_CTL_PTT: 0x1c,
+    C_CTL_RIT: 0x21,
     C_SEND_SEL_FREQ: 0x25,
     C_SEND_SEL_MODE: 0x26,
     C_CTL_SCP: 0x27,
+    S_VFOA: 0x00,
+    S_VFOB: 0x01,
+    S_BTOA: 0xa0,
+    S_XCHNG: 0xb0,
+    S_SUBTOMAIN: 0xb1,
+    S_DUAL_OFF: 0xc0,
+    S_DUAL_ON: 0xc1,
+    S_DUAL: 0xc2,
+    S_MAIN: 0xd0,
+    S_SUB: 0xd1,
+    S_BAND_SEL: 0xd2,
+    S_SPLT_OFF: 0x00,
+    S_SPLT_ON: 0x01,
+    S_DUP_OFF: 0x10,
+    S_DUP_M: 0x11,
+    S_DUP_P: 0x12,
     S_PTT: 0x00,
     S_ANT_TUN: 0x01,
     S_RD_TX_FREQ: 0x03,
+    S_RIT_FREQ: 0x00,
+    S_RIT: 0x01,
+    S_XIT: 0x02,
     S_MEM_PARM: 0x05,
     S_MEM_DATA_MODE: 0x06,
+    S_MEM_DUALMODE: 0x59,
+    S_MEM_SATMODE: 0x5a,
     S_LVL_AF: 0x01,
     S_LVL_RF: 0x02,
     S_LVL_SQL: 0x03,
+    S_LVL_IF: 0x04,
+    S_LVL_APF: 0x05,
     S_LVL_NR: 0x06,
+    S_LVL_PBTIN: 0x07,
+    S_LVL_PBTOUT: 0x08,
+    S_LVL_CWPITCH: 0x09,
     S_LVL_RFPOWER: 0x0a,
     S_LVL_MICGAIN: 0x0b,
+    S_LVL_KEYSPD: 0x0c,
+    S_LVL_NOTCHF: 0x0d,
     S_LVL_COMP: 0x0e,
     S_LVL_BKINDL: 0x0f,
+    S_LVL_BALANCE: 0x10,
+    S_LVL_AGC: 0x11,
     S_LVL_NB: 0x12,
     S_LVL_DIGI: 0x13,
+    S_LVL_DRIVE: 0x14,
+    S_LVL_MON: 0x15,
+    S_LVL_VOXGAIN: 0x16,
+    S_LVL_ANTIVOX: 0x17,
+    S_FUNC_PAMP: 0x02,
+    S_FUNC_AGC: 0x12,
+    S_FUNC_NB: 0x22,
+    S_FUNC_APF: 0x32,
+    S_FUNC_NR: 0x40,
+    S_FUNC_ANF: 0x41,
+    S_FUNC_TONE: 0x42,
+    S_FUNC_TSQL: 0x43,
+    S_FUNC_COMP: 0x44,
+    S_FUNC_MON: 0x45,
+    S_FUNC_VOX: 0x46,
+    S_FUNC_BKIN: 0x47,
+    S_FUNC_MN: 0x48,
+    S_FUNC_RF: 0x49,
+    S_FUNC_AFC: 0x4a,
+    S_FUNC_VSC: 0x4c,
+    S_FUNC_DIGISEL: 0x4e,
+    S_FUNC_DIAL_LK: 0x50,
+    S_FUNC_SATM: 0x5a,
+    S_FUNC_IPP: 0x65,
+    S_FUNC_TX_INHIBIT: 0x66,
+    S_FUNC_DPP: 0x67,
+    S_TONE_RPTR: 0x00,
+    S_TONE_SQL: 0x01,
     S_SQL: 0x01,
     S_SML: 0x02,
     S_CSQL: 0x05,
@@ -49,9 +121,20 @@ exports.CIV = {
     S_SCP_DAT: 0x00,
     S_SCP_STS: 0x10,
     S_SCP_DOP: 0x11,
+    S_SCP_MSS: 0x12,
+    S_SCP_SDS: 0x13,
     S_SCP_MOD: 0x14,
     S_SCP_SPN: 0x15,
     S_SCP_EDG: 0x16,
+    S_SCP_HLD: 0x17,
+    S_SCP_ATT: 0x18,
+    S_SCP_REF: 0x19,
+    S_SCP_SWP: 0x1a,
+    S_SCP_STX: 0x1b,
+    S_SCP_CFQ: 0x1c,
+    S_SCP_VBW: 0x1d,
     S_SCP_FEF: 0x1e,
+    S_SCP_RBW: 0x1f,
+    S_SCP_MKP: 0x20,
 };
 exports.ICOM_MODE_FILTER_DEFAULT = 1;

package/dist/rig/IcomControl.d.ts

@@ -1,4 +1,4 @@
-import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, SquelchStatusReading, AudioSquelchReading, OvfStatusReading, PowerLevelReading, CompLevelReading, VoltageReading, CurrentReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics, DisconnectReason, DisconnectOptions, TunerStatusReading, LevelReading, IcomScopeSpanInfo, IcomScopeMode, IcomScopeModeInfo, IcomScopeEdgeInfo, IcomScopeFixedEdgeInfo, IcomSpectrumDisplayState, IcomSpectrumDisplayConfig } from '../types';
+import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, SquelchStatusReading, AudioSquelchReading, OvfStatusReading, PowerLevelReading, CompLevelReading, VoltageReading, CurrentReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics, DisconnectReason, DisconnectOptions, TunerStatusReading, LevelReading, IcomScopeSpanInfo, IcomScopeMode, IcomScopeModeInfo, IcomScopeEdgeInfo, IcomScopeFixedEdgeInfo, IcomSpectrumDisplayState, IcomSpectrumDisplayConfig, IcomFunctionName, IcomLevelName, IcomParameterName, IcomVfoName, IcomVfoOperation, IcomRepeaterShift, IcomSpectrumSpeed, IcomSpectrumCenterType, IcomAudioIfSource } from '../types';
 import { IcomCiv } from './IcomCiv';
 import { IcomAudio } from './IcomAudio';
 import { IcomScopeService } from '../scope/IcomScopeService';
@@ -16,6 +16,7 @@ export declare class IcomControl {
     private macAddress;
     private tokenTimer?;
     private civAssembleBuf;
+    private civRequestManager;
     private meterTimer?;
     private activeProfile;
     private lastFilter;
@@ -396,6 +397,152 @@ export declare class IcomControl {
      * }
      */
     readCurrent(options?: QueryOptions): Promise<CurrentReading | null>;
+    getFunction(name: IcomFunctionName, options?: QueryOptions): Promise<boolean | null>;
+    setFunction(name: IcomFunctionName, enabled: boolean): void;
+    getLevel(name: IcomLevelName, options?: QueryOptions): Promise<number | null>;
+    setLevel(name: IcomLevelName, value: number): void;
+    getParameter(name: IcomParameterName, options?: QueryOptions): Promise<number | boolean | null>;
+    setParameter(name: IcomParameterName, value: number | boolean): void;
+    getNoiseBlankerEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setNoiseBlankerEnabled(enabled: boolean): void;
+    getNoiseReductionEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setNoiseReductionEnabled(enabled: boolean): void;
+    getCompressorEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setCompressorEnabled(enabled: boolean): void;
+    getVoxEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setVoxEnabled(enabled: boolean): void;
+    getMonitorEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setMonitorEnabled(enabled: boolean): void;
+    getAutoNotchEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setAutoNotchEnabled(enabled: boolean): void;
+    getManualNotchEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setManualNotchEnabled(enabled: boolean): void;
+    getDialLockEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setDialLockEnabled(enabled: boolean): void;
+    getBreakInMode(options?: QueryOptions): Promise<'off' | 'semi' | 'full' | null>;
+    setBreakInMode(mode: 'off' | 'semi' | 'full'): void;
+    getRFGain(options?: QueryOptions): Promise<number | null>;
+    setRFGain(value: number): void;
+    getIFShift(options?: QueryOptions): Promise<number | null>;
+    setIFShift(value: number): void;
+    getPbtIn(options?: QueryOptions): Promise<number | null>;
+    setPbtIn(value: number): void;
+    getPbtOut(options?: QueryOptions): Promise<number | null>;
+    setPbtOut(value: number): void;
+    getCwPitch(options?: QueryOptions): Promise<number | null>;
+    setCwPitch(hz: number): void;
+    getKeySpeed(options?: QueryOptions): Promise<number | null>;
+    setKeySpeed(wpm: number): void;
+    getNotchRaw(options?: QueryOptions): Promise<number | null>;
+    setNotchRaw(value: number): void;
+    getCompressionLevel(options?: QueryOptions): Promise<number | null>;
+    setCompressionLevel(value: number): void;
+    getMonitorGain(options?: QueryOptions): Promise<number | null>;
+    setMonitorGain(value: number): void;
+    getVoxGain(options?: QueryOptions): Promise<number | null>;
+    setVoxGain(value: number): void;
+    getAntiVox(options?: QueryOptions): Promise<number | null>;
+    setAntiVox(value: number): void;
+    getRitOffset(options?: QueryOptions): Promise<number | null>;
+    setRitOffset(offsetHz: number): void;
+    getXitOffset(options?: QueryOptions): Promise<number | null>;
+    setXitOffset(offsetHz: number): void;
+    getRitEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setRitEnabled(enabled: boolean): void;
+    getXitEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setXitEnabled(enabled: boolean): void;
+    getVfo(options?: QueryOptions): Promise<IcomVfoName | null>;
+    setVfo(vfo: IcomVfoName): void;
+    vfoOperation(op: IcomVfoOperation): void;
+    getSplitEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setSplitEnabled(enabled: boolean): void;
+    getSplitFrequency(options?: QueryOptions): Promise<number | null>;
+    setSplitFrequency(hz: number): void;
+    getSplitMode(options?: QueryOptions): Promise<{
+        mode: number;
+        filter?: number;
+        modeName?: string;
+        filterName?: string;
+        dataMode?: boolean;
+    } | null>;
+    setSplitMode(mode: IcomMode | number, options?: SetModeOptions): void;
+    getTuningStep(options?: QueryOptions): Promise<number | null>;
+    setTuningStep(hz: number): void;
+    getRepeaterShift(options?: QueryOptions): Promise<IcomRepeaterShift | null>;
+    setRepeaterShift(shift: IcomRepeaterShift): void;
+    getRepeaterOffset(options?: QueryOptions): Promise<number | null>;
+    setRepeaterOffset(offsetHz: number): void;
+    getToneFrequency(options?: QueryOptions): Promise<number | null>;
+    setToneFrequency(hz: number): void;
+    getToneSquelchFrequency(options?: QueryOptions): Promise<number | null>;
+    setToneSquelchFrequency(hz: number): void;
+    getBeepEnabled(options?: QueryOptions): Promise<boolean | null>;
+    setBeepEnabled(enabled: boolean): void;
+    getBacklight(options?: QueryOptions): Promise<number | null>;
+    setBacklight(value: number): void;
+    getScreenSaver(options?: QueryOptions): Promise<number | null>;
+    setScreenSaver(value: number): void;
+    getKeyerType(options?: QueryOptions): Promise<number | null>;
+    setKeyerType(value: number): void;
+    getAudioIfMode(options?: QueryOptions): Promise<IcomAudioIfSource | null>;
+    setAudioIfMode(source: IcomAudioIfSource): void;
+    getSpectrumDataOutput(options?: QueryOptions): Promise<boolean | null>;
+    setSpectrumDataOutput(enabled: boolean): void;
+    getSpectrumHold(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<boolean | null>;
+    setSpectrumHold(enabled: boolean, options?: {
+        receiver?: 0 | 1;
+    }): void;
+    getSpectrumSpeed(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<IcomSpectrumSpeed | null>;
+    setSpectrumSpeed(speed: IcomSpectrumSpeed, options?: {
+        receiver?: 0 | 1;
+    }): void;
+    getSpectrumRef(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<number | null>;
+    setSpectrumRef(db: number, options?: {
+        receiver?: 0 | 1;
+    }): void;
+    getSpectrumAverage(options?: QueryOptions): Promise<number | null>;
+    setSpectrumAverage(value: number): void;
+    getSpectrumVbw(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<number | null>;
+    setSpectrumVbw(value: number, options?: {
+        receiver?: 0 | 1;
+    }): void;
+    getSpectrumRbw(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<number | null>;
+    setSpectrumRbw(value: number, options?: {
+        receiver?: 0 | 1;
+    }): void;
+    getSpectrumDuringTx(options?: QueryOptions): Promise<boolean | null>;
+    setSpectrumDuringTx(enabled: boolean): void;
+    getSpectrumCenterType(options?: QueryOptions): Promise<IcomSpectrumCenterType | null>;
+    setSpectrumCenterType(type: IcomSpectrumCenterType): void;
+    private unsupported;
+    private readFunctionRaw;
+    private writeFunctionRaw;
+    private readLevelRaw;
+    private writeLevelRaw;
+    private readExtParamValue;
+    private writeExtParamValue;
+    private static encodeDataValue;
+    private static decodeDataValue;
+    private readRitOffset;
+    private writeRitOffset;
+    private vfoToSubcmd;
+    private readSplitRaw;
+    private readTone;
+    private writeTone;
+    private audioIfSourceToParameter;
+    private getScopeBoolean;
+    private getScopeByte;
+    private writeScopeSimple;
     private static isReplyOf;
     /**
      * Extract meter data from CI-V response frame