hamlib 0.2.0 → 0.2.2

package/src/hamlib.h

@@ -159,6 +159,46 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
   // Reset Function
   Napi::Value Reset(const Napi::CallbackInfo&);
 
+  // Lock Mode (Hamlib >= 4.7.0)
+  Napi::Value SetLockMode(const Napi::CallbackInfo&);
+  Napi::Value GetLockMode(const Napi::CallbackInfo&);
+
+  // Clock (Hamlib >= 4.7.0)
+  Napi::Value SetClock(const Napi::CallbackInfo&);
+  Napi::Value GetClock(const Napi::CallbackInfo&);
+
+  // VFO Info (Hamlib >= 4.7.0)
+  Napi::Value GetVfoInfo(const Napi::CallbackInfo&);
+
+  // Rig Info / Raw / Conf (async)
+  Napi::Value GetInfo(const Napi::CallbackInfo&);
+  Napi::Value SendRaw(const Napi::CallbackInfo&);
+  Napi::Value SetConf(const Napi::CallbackInfo&);
+  Napi::Value GetConf(const Napi::CallbackInfo&);
+
+  // Passband / Resolution (sync)
+  Napi::Value GetPassbandNormal(const Napi::CallbackInfo&);
+  Napi::Value GetPassbandNarrow(const Napi::CallbackInfo&);
+  Napi::Value GetPassbandWide(const Napi::CallbackInfo&);
+  Napi::Value GetResolution(const Napi::CallbackInfo&);
+
+  // Capability queries (sync)
+  Napi::Value GetSupportedParms(const Napi::CallbackInfo&);
+  Napi::Value GetSupportedVfoOps(const Napi::CallbackInfo&);
+  Napi::Value GetSupportedScanTypes(const Napi::CallbackInfo&);
+
+  // Capability queries - batch 2 (sync)
+  Napi::Value GetPreampValues(const Napi::CallbackInfo&);
+  Napi::Value GetAttenuatorValues(const Napi::CallbackInfo&);
+  Napi::Value GetMaxRit(const Napi::CallbackInfo&);
+  Napi::Value GetMaxXit(const Napi::CallbackInfo&);
+  Napi::Value GetMaxIfShift(const Napi::CallbackInfo&);
+  Napi::Value GetAvailableCtcssTones(const Napi::CallbackInfo&);
+  Napi::Value GetAvailableDcsCodes(const Napi::CallbackInfo&);
+  Napi::Value GetFrequencyRanges(const Napi::CallbackInfo&);
+  Napi::Value GetTuningSteps(const Napi::CallbackInfo&);
+  Napi::Value GetFilterList(const Napi::CallbackInfo&);
+
   // Static method to get supported rig models
   static Napi::Value GetSupportedRigs(const Napi::CallbackInfo&);
 
@@ -169,6 +209,10 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
   static Napi::Value SetDebugLevel(const Napi::CallbackInfo&);
   static Napi::Value GetDebugLevel(const Napi::CallbackInfo&);
 
+  // Static copyright/license
+  static Napi::Value GetCopyright(const Napi::CallbackInfo&);
+  static Napi::Value GetLicense(const Napi::CallbackInfo&);
+
   static Napi::Function GetClass(Napi::Env);
 
   // Frequency change callback (uses basic C types via shim)

package/src/shim/hamlib_shim.c

@@ -43,10 +43,10 @@ SHIM_API void shim_rig_set_debug(int level) {
 }
 
 SHIM_API int shim_rig_get_debug(void) {
-    /* Hamlib doesn't have rig_get_debug in all versions,
-       but we use the global variable if available */
-#ifdef HAVE_RIG_GET_DEBUG
-    return (int)rig_get_debug();
+#ifdef SHIM_HAS_GET_DEBUG
+    enum rig_debug_level_e level;
+    rig_get_debug(&level);
+    return (int)level;
 #else
     return -1;  /* Not available */
 #endif
@@ -448,7 +448,7 @@ SHIM_API int shim_rig_get_split_mode(hamlib_shim_handle_t h, int vfo, int* mode,
 }
 
 SHIM_API int shim_rig_set_split_freq_mode(hamlib_shim_handle_t h, int vfo, double freq, int mode, int width) {
-#if HAVE_RIG_SPLIT_FREQ_MODE
+#ifdef SHIM_HAS_SPLIT_FREQ_MODE
     return rig_set_split_freq_mode((RIG*)h, (vfo_t)vfo, (freq_t)freq, (rmode_t)mode, (pbwidth_t)width);
 #else
     /* Fallback: set freq and mode separately */
@@ -459,7 +459,7 @@ SHIM_API int shim_rig_set_split_freq_mode(hamlib_shim_handle_t h, int vfo, doubl
 }
 
 SHIM_API int shim_rig_get_split_freq_mode(hamlib_shim_handle_t h, int vfo, double* freq, int* mode, int* width) {
-#if HAVE_RIG_SPLIT_FREQ_MODE
+#ifdef SHIM_HAS_SPLIT_FREQ_MODE
     freq_t f = 0;
     rmode_t m = 0;
     pbwidth_t w = 0;
@@ -712,7 +712,7 @@ SHIM_API int shim_rig_send_voice_mem(hamlib_shim_handle_t h, int vfo, int ch) {
 }
 
 SHIM_API int shim_rig_stop_voice_mem(hamlib_shim_handle_t h, int vfo) {
-#if HAVE_RIG_STOP_VOICE_MEM
+#ifdef SHIM_HAS_STOP_VOICE_MEM
     return rig_stop_voice_mem((RIG*)h, (vfo_t)vfo);
 #else
     (void)h; (void)vfo;
@@ -794,9 +794,17 @@ SHIM_API int shim_rig_set_ptt_callback(hamlib_shim_handle_t h, shim_ptt_cb_t cb,
     return rig_set_ptt_callback((RIG*)h, shim_ptt_cb_thunk, &ptt_cb_adapter);
 }
 
+/* rig_set_trn: deprecated in Hamlib 4.7.0, may be removed in future versions. */
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
 SHIM_API int shim_rig_set_trn(hamlib_shim_handle_t h, int trn) {
     return rig_set_trn((RIG*)h, trn);
 }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 
 /* ===== Capability queries ===== */
 
@@ -863,3 +871,299 @@ SHIM_API const char* shim_rig_type_str(int rig_type) {
         default:                   return "Unknown";
     }
 }
+
+/* ===== Lock Mode (Hamlib >= 4.7.0) ===== */
+
+SHIM_API int shim_rig_set_lock_mode(hamlib_shim_handle_t h, int lock) {
+#ifdef SHIM_HAS_LOCK_MODE
+    RIG *rig = (RIG *)h;
+    if (!rig) return -RIG_EINVAL;
+    return rig_set_lock_mode(rig, lock);
+#else
+    (void)h; (void)lock;
+    return -RIG_ENIMPL;
+#endif
+}
+
+SHIM_API int shim_rig_get_lock_mode(hamlib_shim_handle_t h, int *lock) {
+#ifdef SHIM_HAS_LOCK_MODE
+    RIG *rig = (RIG *)h;
+    if (!rig) return -RIG_EINVAL;
+    return rig_get_lock_mode(rig, lock);
+#else
+    (void)h; (void)lock;
+    return -RIG_ENIMPL;
+#endif
+}
+
+/* ===== Clock (Hamlib >= 4.7.0) ===== */
+
+SHIM_API int shim_rig_set_clock(hamlib_shim_handle_t h, int year, int month, int day,
+                                 int hour, int min, int sec, double msec, int utc_offset) {
+#ifdef SHIM_HAS_CLOCK
+    RIG *rig = (RIG *)h;
+    if (!rig) return -RIG_EINVAL;
+    return rig_set_clock(rig, year, month, day, hour, min, sec, msec, utc_offset);
+#else
+    (void)h; (void)year; (void)month; (void)day;
+    (void)hour; (void)min; (void)sec; (void)msec; (void)utc_offset;
+    return -RIG_ENIMPL;
+#endif
+}
+
+SHIM_API int shim_rig_get_clock(hamlib_shim_handle_t h, int *year, int *month, int *day,
+                                 int *hour, int *min, int *sec, double *msec, int *utc_offset) {
+#ifdef SHIM_HAS_CLOCK
+    RIG *rig = (RIG *)h;
+    if (!rig) return -RIG_EINVAL;
+    return rig_get_clock(rig, year, month, day, hour, min, sec, msec, utc_offset);
+#else
+    (void)h; (void)year; (void)month; (void)day;
+    (void)hour; (void)min; (void)sec; (void)msec; (void)utc_offset;
+    return -RIG_ENIMPL;
+#endif
+}
+
+/* ===== VFO Info (Hamlib >= 4.7.0) ===== */
+
+SHIM_API int shim_rig_get_vfo_info(hamlib_shim_handle_t h, int vfo,
+                                    double *freq, uint64_t *mode,
+                                    long *width, int *split, int *satmode) {
+#ifdef SHIM_HAS_VFO_INFO
+    RIG *rig = (RIG *)h;
+    if (!rig) return -RIG_EINVAL;
+    freq_t f = 0;
+    rmode_t m = 0;
+    pbwidth_t w = 0;
+    split_t s = RIG_SPLIT_OFF;
+    int sm = 0;
+    int ret = rig_get_vfo_info(rig, (vfo_t)vfo, &f, &m, &w, &s, &sm);
+    if (freq) *freq = (double)f;
+    if (mode) *mode = (uint64_t)m;
+    if (width) *width = (long)w;
+    if (split) *split = (int)s;
+    if (satmode) *satmode = sm;
+    return ret;
+#else
+    (void)h; (void)vfo; (void)freq; (void)mode; (void)width; (void)split; (void)satmode;
+    return -RIG_ENIMPL;
+#endif
+}
+
+/* ===== Rig info / Raw / Conf ===== */
+
+SHIM_API const char* shim_rig_get_info(hamlib_shim_handle_t h) {
+    RIG *rig = (RIG *)h;
+    if (!rig) return "";
+    const char *info = rig_get_info(rig);
+    return info ? info : "";
+}
+
+SHIM_API int shim_rig_send_raw(hamlib_shim_handle_t h,
+    const unsigned char* send, int send_len,
+    unsigned char* reply, int reply_len, const unsigned char* term) {
+#ifdef SHIM_HAS_SEND_RAW
+    RIG *rig = (RIG *)h;
+    if (!rig) return -RIG_EINVAL;
+    return rig_send_raw(rig, send, send_len, reply, reply_len, (unsigned char*)term);
+#else
+    (void)h; (void)send; (void)send_len; (void)reply; (void)reply_len; (void)term;
+    return -RIG_ENIMPL;
+#endif
+}
+
+SHIM_API int shim_rig_set_conf(hamlib_shim_handle_t h, const char* name, const char* val) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !name || !val) return -RIG_EINVAL;
+    token_t token = rig_token_lookup(rig, name);
+    if (token == 0) return -RIG_EINVAL;
+    return rig_set_conf(rig, token, val);
+}
+
+SHIM_API int shim_rig_get_conf(hamlib_shim_handle_t h, const char* name, char* buf, int buflen) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !name || !buf || buflen <= 0) return -RIG_EINVAL;
+    token_t token = rig_token_lookup(rig, name);
+    if (token == 0) return -RIG_EINVAL;
+#ifdef SHIM_HAS_CONF2
+    return rig_get_conf2(rig, token, buf, buflen);
+#else
+    return rig_get_conf(rig, token, buf);
+#endif
+}
+
+/* ===== Passband / Resolution ===== */
+
+SHIM_API int shim_rig_passband_normal(hamlib_shim_handle_t h, int mode) {
+    return (int)rig_passband_normal((RIG*)h, (rmode_t)mode);
+}
+
+SHIM_API int shim_rig_get_resolution(hamlib_shim_handle_t h, int mode) {
+    RIG *rig = (RIG *)h;
+    if (!rig) return 0;
+    return (int)rig_get_resolution(rig, (rmode_t)mode);
+}
+
+/* ===== Capability queries (parm / vfo_ops / scan) ===== */
+
+SHIM_API uint64_t shim_rig_get_caps_has_get_parm(hamlib_shim_handle_t h) {
+    RIG *rig = (RIG *)h;
+    return (uint64_t)(rig->caps->has_get_parm);
+}
+
+SHIM_API uint64_t shim_rig_get_caps_has_set_parm(hamlib_shim_handle_t h) {
+    RIG *rig = (RIG *)h;
+    return (uint64_t)(rig->caps->has_set_parm);
+}
+
+SHIM_API int shim_rig_get_caps_vfo_ops(hamlib_shim_handle_t h) {
+    RIG *rig = (RIG *)h;
+    return (int)(rig->caps->vfo_ops);
+}
+
+SHIM_API int shim_rig_get_caps_has_scan(hamlib_shim_handle_t h) {
+    RIG *rig = (RIG *)h;
+    return (int)(rig->caps->scan_ops);
+}
+
+/* ===== Capability Query: Preamp/Attenuator/Max values ===== */
+
+SHIM_API int shim_rig_get_caps_preamp(hamlib_shim_handle_t h, int* out, int max_count) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !out || max_count <= 0) return 0;
+    int count = 0;
+    for (int i = 0; i < HAMLIB_MAXDBLSTSIZ && rig->caps->preamp[i] != 0 && count < max_count; i++) {
+        out[count++] = rig->caps->preamp[i];
+    }
+    return count;
+}
+
+SHIM_API int shim_rig_get_caps_attenuator(hamlib_shim_handle_t h, int* out, int max_count) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !out || max_count <= 0) return 0;
+    int count = 0;
+    for (int i = 0; i < HAMLIB_MAXDBLSTSIZ && rig->caps->attenuator[i] != 0 && count < max_count; i++) {
+        out[count++] = rig->caps->attenuator[i];
+    }
+    return count;
+}
+
+SHIM_API long shim_rig_get_caps_max_rit(hamlib_shim_handle_t h) {
+    RIG *rig = (RIG *)h;
+    if (!rig) return 0;
+    return (long)rig->caps->max_rit;
+}
+
+SHIM_API long shim_rig_get_caps_max_xit(hamlib_shim_handle_t h) {
+    RIG *rig = (RIG *)h;
+    if (!rig) return 0;
+    return (long)rig->caps->max_xit;
+}
+
+SHIM_API long shim_rig_get_caps_max_ifshift(hamlib_shim_handle_t h) {
+    RIG *rig = (RIG *)h;
+    if (!rig) return 0;
+    return (long)rig->caps->max_ifshift;
+}
+
+/* ===== Capability Query: CTCSS/DCS lists ===== */
+
+SHIM_API int shim_rig_get_caps_ctcss_list(hamlib_shim_handle_t h, unsigned int* out, int max_count) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !out || max_count <= 0) return 0;
+    if (!rig->caps->ctcss_list) return 0;
+    int count = 0;
+    for (int i = 0; rig->caps->ctcss_list[i] != 0 && count < max_count; i++) {
+        out[count++] = rig->caps->ctcss_list[i];
+    }
+    return count;
+}
+
+SHIM_API int shim_rig_get_caps_dcs_list(hamlib_shim_handle_t h, unsigned int* out, int max_count) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !out || max_count <= 0) return 0;
+    if (!rig->caps->dcs_list) return 0;
+    int count = 0;
+    for (int i = 0; rig->caps->dcs_list[i] != 0 && count < max_count; i++) {
+        out[count++] = rig->caps->dcs_list[i];
+    }
+    return count;
+}
+
+/* ===== Capability Query: Frequency ranges ===== */
+
+SHIM_API int shim_rig_get_caps_rx_range(hamlib_shim_handle_t h, shim_freq_range_t* out, int max_count) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !out || max_count <= 0) return 0;
+    int count = 0;
+    for (int i = 0; i < HAMLIB_FRQRANGESIZ && count < max_count; i++) {
+        const freq_range_t *r = &rig->caps->rx_range_list1[i];
+        if (r->startf == 0 && r->endf == 0) break;
+        out[count].start_freq = (double)r->startf;
+        out[count].end_freq = (double)r->endf;
+        out[count].modes = (uint64_t)r->modes;
+        out[count].low_power = (int)r->low_power;
+        out[count].high_power = (int)r->high_power;
+        out[count].vfo = (int)r->vfo;
+        out[count].ant = (int)r->ant;
+        count++;
+    }
+    return count;
+}
+
+SHIM_API int shim_rig_get_caps_tx_range(hamlib_shim_handle_t h, shim_freq_range_t* out, int max_count) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !out || max_count <= 0) return 0;
+    int count = 0;
+    for (int i = 0; i < HAMLIB_FRQRANGESIZ && count < max_count; i++) {
+        const freq_range_t *r = &rig->caps->tx_range_list1[i];
+        if (r->startf == 0 && r->endf == 0) break;
+        out[count].start_freq = (double)r->startf;
+        out[count].end_freq = (double)r->endf;
+        out[count].modes = (uint64_t)r->modes;
+        out[count].low_power = (int)r->low_power;
+        out[count].high_power = (int)r->high_power;
+        out[count].vfo = (int)r->vfo;
+        out[count].ant = (int)r->ant;
+        count++;
+    }
+    return count;
+}
+
+/* ===== Capability Query: Tuning steps / Filters ===== */
+
+SHIM_API int shim_rig_get_caps_tuning_steps(hamlib_shim_handle_t h, shim_mode_value_t* out, int max_count) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !out || max_count <= 0) return 0;
+    int count = 0;
+    for (int i = 0; i < HAMLIB_TSLSTSIZ && count < max_count; i++) {
+        if (rig->caps->tuning_steps[i].modes == 0) break;
+        out[count].modes = (uint64_t)rig->caps->tuning_steps[i].modes;
+        out[count].value = (int)rig->caps->tuning_steps[i].ts;
+        count++;
+    }
+    return count;
+}
+
+SHIM_API int shim_rig_get_caps_filters(hamlib_shim_handle_t h, shim_mode_value_t* out, int max_count) {
+    RIG *rig = (RIG *)h;
+    if (!rig || !out || max_count <= 0) return 0;
+    int count = 0;
+    for (int i = 0; i < HAMLIB_FLTLSTSIZ && count < max_count; i++) {
+        if (rig->caps->filters[i].modes == 0) break;
+        out[count].modes = (uint64_t)rig->caps->filters[i].modes;
+        out[count].value = (int)rig->caps->filters[i].width;
+        count++;
+    }
+    return count;
+}
+
+/* ===== Static info ===== */
+
+SHIM_API const char* shim_rig_copyright(void) {
+    return rig_copyright();
+}
+
+SHIM_API const char* shim_rig_license(void) {
+    return rig_license();
+}

package/src/shim/hamlib_shim.h

@@ -71,9 +71,10 @@ typedef void* hamlib_shim_handle_t;
 /* Passband constants */
 #define SHIM_RIG_PASSBAND_NORMAL  0
 
-/* Port types */
-#define SHIM_RIG_PORT_SERIAL   0
-#define SHIM_RIG_PORT_NETWORK  4
+/* Port types (must match hamlib rig_port_e enum) */
+#define SHIM_RIG_PORT_NONE     0
+#define SHIM_RIG_PORT_SERIAL   1
+#define SHIM_RIG_PORT_NETWORK  2
 
 /* Scan types */
 #define SHIM_RIG_SCAN_STOP   0
@@ -83,6 +84,16 @@ typedef void* hamlib_shim_handle_t;
 #define SHIM_RIG_SCAN_DELTA  (1<<3)
 #define SHIM_RIG_SCAN_PRIO   (1<<4)
 
+/* Parm constants (bit positions for setting_t / uint64_t) */
+#define SHIM_RIG_PARM_ANN        (1ULL << 0)
+#define SHIM_RIG_PARM_APO        (1ULL << 1)
+#define SHIM_RIG_PARM_BACKLIGHT  (1ULL << 2)
+#define SHIM_RIG_PARM_BEEP       (1ULL << 4)
+#define SHIM_RIG_PARM_TIME       (1ULL << 5)
+#define SHIM_RIG_PARM_BAT        (1ULL << 6)
+#define SHIM_RIG_PARM_KEYLIGHT   (1ULL << 7)
+#define SHIM_RIG_PARM_SCREENSAVER (1ULL << 8)
+
 /* Transceive mode */
 #define SHIM_RIG_TRN_POLL    1
 
@@ -504,6 +515,86 @@ SHIM_API int shim_rig_sprintf_mode(uint64_t modes, char* buf, int buflen);
 /* Rig type to string conversion */
 SHIM_API const char* shim_rig_type_str(int rig_type);
 
+/* ===== Capability Query: Structured data types ===== */
+
+/* ABI-safe struct for frequency range (no Hamlib types cross boundary) */
+typedef struct {
+    double start_freq;   /* Hz */
+    double end_freq;     /* Hz */
+    uint64_t modes;      /* rmode_t bitmask */
+    int low_power;       /* mW */
+    int high_power;      /* mW */
+    int vfo;             /* vfo_t */
+    int ant;             /* ant_t */
+} shim_freq_range_t;
+
+/* ABI-safe struct for tuning step / filter */
+typedef struct {
+    uint64_t modes;      /* rmode_t bitmask */
+    int value;           /* step Hz or filter width Hz */
+} shim_mode_value_t;
+
+/* Group A: Simple value queries */
+SHIM_API int shim_rig_get_caps_preamp(hamlib_shim_handle_t h, int* out, int max_count);
+SHIM_API int shim_rig_get_caps_attenuator(hamlib_shim_handle_t h, int* out, int max_count);
+SHIM_API long shim_rig_get_caps_max_rit(hamlib_shim_handle_t h);
+SHIM_API long shim_rig_get_caps_max_xit(hamlib_shim_handle_t h);
+SHIM_API long shim_rig_get_caps_max_ifshift(hamlib_shim_handle_t h);
+
+/* Group B: Tone/code lists */
+SHIM_API int shim_rig_get_caps_ctcss_list(hamlib_shim_handle_t h, unsigned int* out, int max_count);
+SHIM_API int shim_rig_get_caps_dcs_list(hamlib_shim_handle_t h, unsigned int* out, int max_count);
+
+/* Group C: Structured data */
+SHIM_API int shim_rig_get_caps_rx_range(hamlib_shim_handle_t h, shim_freq_range_t* out, int max_count);
+SHIM_API int shim_rig_get_caps_tx_range(hamlib_shim_handle_t h, shim_freq_range_t* out, int max_count);
+SHIM_API int shim_rig_get_caps_tuning_steps(hamlib_shim_handle_t h, shim_mode_value_t* out, int max_count);
+SHIM_API int shim_rig_get_caps_filters(hamlib_shim_handle_t h, shim_mode_value_t* out, int max_count);
+
+/* ===== Lock Mode (Hamlib >= 4.7.0) ===== */
+
+SHIM_API int shim_rig_set_lock_mode(hamlib_shim_handle_t h, int lock);
+SHIM_API int shim_rig_get_lock_mode(hamlib_shim_handle_t h, int *lock);
+
+/* ===== Clock (Hamlib >= 4.7.0) ===== */
+
+SHIM_API int shim_rig_set_clock(hamlib_shim_handle_t h, int year, int month, int day,
+                                 int hour, int min, int sec, double msec, int utc_offset);
+SHIM_API int shim_rig_get_clock(hamlib_shim_handle_t h, int *year, int *month, int *day,
+                                 int *hour, int *min, int *sec, double *msec, int *utc_offset);
+
+/* ===== VFO Info (Hamlib >= 4.7.0) ===== */
+
+SHIM_API int shim_rig_get_vfo_info(hamlib_shim_handle_t h, int vfo,
+                                    double *freq, uint64_t *mode,
+                                    long *width, int *split, int *satmode);
+
+/* ===== Rig info / Raw / Conf ===== */
+
+SHIM_API const char* shim_rig_get_info(hamlib_shim_handle_t h);
+SHIM_API int shim_rig_send_raw(hamlib_shim_handle_t h,
+    const unsigned char* send, int send_len,
+    unsigned char* reply, int reply_len, const unsigned char* term);
+SHIM_API int shim_rig_set_conf(hamlib_shim_handle_t h, const char* name, const char* val);
+SHIM_API int shim_rig_get_conf(hamlib_shim_handle_t h, const char* name, char* buf, int buflen);
+
+/* ===== Passband / Resolution ===== */
+
+SHIM_API int shim_rig_passband_normal(hamlib_shim_handle_t h, int mode);
+SHIM_API int shim_rig_get_resolution(hamlib_shim_handle_t h, int mode);
+
+/* ===== Capability queries (parm / vfo_ops / scan) ===== */
+
+SHIM_API uint64_t shim_rig_get_caps_has_get_parm(hamlib_shim_handle_t h);
+SHIM_API uint64_t shim_rig_get_caps_has_set_parm(hamlib_shim_handle_t h);
+SHIM_API int shim_rig_get_caps_vfo_ops(hamlib_shim_handle_t h);
+SHIM_API int shim_rig_get_caps_has_scan(hamlib_shim_handle_t h);
+
+/* ===== Static info ===== */
+
+SHIM_API const char* shim_rig_copyright(void);
+SHIM_API const char* shim_rig_license(void);
+
 #ifdef __cplusplus
 }
 #endif