hamlib 0.4.0 → 0.4.2

package/index.d.ts

@@ -378,6 +378,62 @@ interface SerialConfigOptions {
   dcd_type: string[];
 }
 
+type HamlibConfigFieldType =
+  | 'string'
+  | 'combo'
+  | 'numeric'
+  | 'checkbutton'
+  | 'button'
+  | 'binary'
+  | 'int'
+  | 'unknown';
+
+interface HamlibConfigFieldDescriptor {
+  token: number;
+  name: string;
+  label: string;
+  tooltip: string;
+  defaultValue: string;
+  type: HamlibConfigFieldType;
+  numeric?: {
+    min: number;
+    max: number;
+    step: number;
+  };
+  options?: string[];
+}
+
+type HamlibPortType =
+  | 'none'
+  | 'serial'
+  | 'network'
+  | 'device'
+  | 'packet'
+  | 'dtmf'
+  | 'ultra'
+  | 'rpc'
+  | 'parallel'
+  | 'usb'
+  | 'udp-network'
+  | 'cm108'
+  | 'gpio'
+  | 'gpion'
+  | 'other';
+
+interface HamlibPortCaps {
+  portType: HamlibPortType;
+  serialRateMin?: number;
+  serialRateMax?: number;
+  serialDataBits?: number;
+  serialStopBits?: number;
+  serialParity?: string;
+  serialHandshake?: string;
+  writeDelay: number;
+  postWriteDelay: number;
+  timeout: number;
+  retry: number;
+}
+
 /**
  * HamLib class - for controlling amateur radio devices
  */
@@ -856,6 +912,18 @@ declare class HamLib extends EventEmitter {
    */
   getSupportedSerialConfigs(): SerialConfigOptions;
 
+  /**
+   * Get backend-specific configuration schema for the current rig model.
+   * This can be queried before opening the connection and is suitable for
+   * driving dynamic configuration UIs.
+   */
+  getConfigSchema(): HamlibConfigFieldDescriptor[];
+
+  /**
+   * Get backend port capabilities and effective connection defaults.
+   */
+  getPortCaps(): HamlibPortCaps;
+
   // Power Control
 
   /**
@@ -1543,6 +1611,7 @@ export { ConnectionInfo, ModeInfo, SupportedRigInfo, AntennaInfo, VFO, RadioMode
          MemoryChannelInfo, SplitModeInfo, SplitStatusInfo, LevelType, FunctionType,
          ScanType, VfoOperationType, SerialConfigParam, SerialBaudRate, SerialParity,
          SerialHandshake, SerialControlState, PttType, DcdType, SerialConfigOptions,
+         HamlibConfigFieldType, HamlibConfigFieldDescriptor, HamlibPortType, HamlibPortCaps,
          SpectrumScopeInfo, SpectrumModeInfo, SpectrumAverageModeInfo, SpectrumLine,
          SpectrumCapabilities, SpectrumSupportSummary, SpectrumConfig, SpectrumDisplayState,
          ClockInfo, VfoInfo, HamLib };

package/lib/index.js

@@ -589,6 +589,25 @@ class HamLib extends EventEmitter {
     return this._nativeInstance.getSupportedSerialConfigs();
   }
 
+  /**
+   * Get backend-specific configuration schema for the selected rig model.
+   * This can be queried before opening the connection and is intended for
+   * dynamic configuration UIs.
+   * @returns {Array<Object>} List of config field descriptors
+   */
+  getConfigSchema() {
+    return this._nativeInstance.getConfigSchema();
+  }
+
+  /**
+   * Get backend port capabilities and effective connection defaults derived
+   * from Hamlib rig caps for the selected model.
+   * @returns {Object} Port type and default connection parameters
+   */
+  getPortCaps() {
+    return this._nativeInstance.getPortCaps();
+  }
+
   // Power Control
 
   /**

package/lib/spectrum.d.ts

@@ -60,6 +60,4 @@ export type {
   SpectrumSupportSummary,
 };
 
-// @ts-ignore
-export = spectrumModule;
 export default spectrumModule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Node.js bindings for Hamlib rig control with official spectrum streaming support",
   "main": "index.js",
   "module": "lib/index.mjs",
@@ -12,9 +12,16 @@
       "types": "./index.d.ts"
     },
     "./spectrum": {
-      "import": "./lib/spectrum.mjs",
-      "require": "./lib/spectrum.js",
-      "types": "./lib/spectrum.d.ts"
+      "import": "./spectrum.mjs",
+      "require": "./spectrum.js",
+      "types": "./spectrum.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "spectrum": [
+        "spectrum.d.ts"
+      ]
     }
   },
   "gypfile": true,
@@ -38,6 +45,9 @@
     "docs/",
     "index.js",
     "index.d.ts",
+    "spectrum.js",
+    "spectrum.mjs",
+    "spectrum.d.ts",
     "binding.gyp",
     "COPYING",
     "README.md"

package/spectrum.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/spectrum';
+export { default } from './lib/spectrum';

package/spectrum.js

@@ -0,0 +1 @@
+module.exports = require('./lib/spectrum.js');

package/spectrum.mjs

@@ -0,0 +1,2 @@
+export * from './lib/spectrum.mjs';
+export { default } from './lib/spectrum.mjs';

package/src/hamlib.cpp

@@ -40,6 +40,23 @@ struct RigListData {
   Napi::Env env;
 };
 
+struct RigConfigFieldDescriptor {
+  int token;
+  std::string name;
+  std::string label;
+  std::string tooltip;
+  std::string defaultValue;
+  int type;
+  double numericMin;
+  double numericMax;
+  double numericStep;
+  std::vector<std::string> options;
+};
+
+struct RigConfigSchemaData {
+  std::vector<RigConfigFieldDescriptor> fields;
+};
+
 using namespace Napi;
 
 Napi::FunctionReference NodeHamLib::constructor;
@@ -55,6 +72,31 @@ static std::string publicVfoToken(int vfo) {
   return rawToken;
 }
 
+static const char* publicConfTypeName(int type) {
+  switch (type) {
+    case 0:
+      return "string";
+    case 1:
+      return "combo";
+    case 2:
+      return "numeric";
+    case 3:
+      return "checkbutton";
+    case 4:
+      return "button";
+    case 5:
+      return "binary";
+    case 6:
+      return "int";
+    default:
+      return "unknown";
+  }
+}
+
+static bool hasPositiveValue(int value) {
+  return value > 0;
+}
+
 static int parseVfoString(Napi::Env env, const std::string& vfoToken) {
   int vfo = shim_rig_parse_vfo(vfoToken.c_str());
   if (vfo == SHIM_RIG_VFO_NONE) {
@@ -3832,6 +3874,8 @@ Napi::Function NodeHamLib::GetClass(Napi::Env env) {
       NodeHamLib::InstanceMethod("setDcdType", & NodeHamLib::SetDcdType),
       NodeHamLib::InstanceMethod("getDcdType", & NodeHamLib::GetDcdType),
       NodeHamLib::InstanceMethod("getSupportedSerialConfigs", & NodeHamLib::GetSupportedSerialConfigs),
+      NodeHamLib::InstanceMethod("getConfigSchema", & NodeHamLib::GetConfigSchema),
+      NodeHamLib::InstanceMethod("getPortCaps", & NodeHamLib::GetPortCaps),
       
       // Power Control
       NodeHamLib::InstanceMethod("setPowerstat", & NodeHamLib::SetPowerstat),
@@ -4220,7 +4264,7 @@ Napi::Value NodeHamLib::GetSupportedSerialConfigs(const Napi::CallbackInfo& info
   pttTypeOptions[5u] = Napi::String::New(env, "GPIO");
   pttTypeOptions[6u] = Napi::String::New(env, "GPION");
   pttTypeOptions[7u] = Napi::String::New(env, "NONE");
-  configs.Set("intype", pttTypeOptions);
+  configs.Set("ptt_type", pttTypeOptions);
   
   // DCD type options
   Napi::Array dcdTypeOptions = Napi::Array::New(env, 9);
@@ -4233,11 +4277,124 @@ Napi::Value NodeHamLib::GetSupportedSerialConfigs(const Napi::CallbackInfo& info
   dcdTypeOptions[6u] = Napi::String::New(env, "GPIO");
   dcdTypeOptions[7u] = Napi::String::New(env, "GPION");
   dcdTypeOptions[8u] = Napi::String::New(env, "NONE");
-  configs.Set("intype", dcdTypeOptions);
+  configs.Set("dcd_type", dcdTypeOptions);
   
   return configs;
 }
 
+int NodeHamLib::rig_config_callback(const shim_confparam_info_t* info, void* data) {
+  RigConfigSchemaData* schema_data = static_cast<RigConfigSchemaData*>(data);
+
+  if (!schema_data || !info) {
+    return 0;
+  }
+
+  RigConfigFieldDescriptor field;
+  field.token = info->token;
+  field.name = info->name;
+  field.label = info->label;
+  field.tooltip = info->tooltip;
+  field.defaultValue = info->dflt;
+  field.type = info->type;
+  field.numericMin = info->numeric_min;
+  field.numericMax = info->numeric_max;
+  field.numericStep = info->numeric_step;
+
+  for (int i = 0; i < info->combo_count; ++i) {
+    field.options.emplace_back(info->combo_options[i]);
+  }
+
+  schema_data->fields.push_back(field);
+  return 1;
+}
+
+Napi::Value NodeHamLib::GetConfigSchema(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RETURN_NULL_IF_RIG_HANDLE_INVALID();
+
+  RigConfigSchemaData schemaData{};
+  int result = shim_rig_cfgparams_foreach(my_rig, rig_config_callback, &schemaData);
+
+  if (result != SHIM_RIG_OK) {
+    Napi::Error::New(env, shim_rigerror(result)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Array schemaArray = Napi::Array::New(env, schemaData.fields.size());
+  for (size_t i = 0; i < schemaData.fields.size(); ++i) {
+    const RigConfigFieldDescriptor& descriptor = schemaData.fields[i];
+    Napi::Object field = Napi::Object::New(env);
+    field.Set("token", Napi::Number::New(env, descriptor.token));
+    field.Set("name", Napi::String::New(env, descriptor.name));
+    field.Set("label", Napi::String::New(env, descriptor.label));
+    field.Set("tooltip", Napi::String::New(env, descriptor.tooltip));
+    field.Set("defaultValue", Napi::String::New(env, descriptor.defaultValue));
+    field.Set("type", Napi::String::New(env, publicConfTypeName(descriptor.type)));
+
+    if (descriptor.type == 2 || descriptor.type == 6) {
+      Napi::Object numeric = Napi::Object::New(env);
+      numeric.Set("min", Napi::Number::New(env, descriptor.numericMin));
+      numeric.Set("max", Napi::Number::New(env, descriptor.numericMax));
+      numeric.Set("step", Napi::Number::New(env, descriptor.numericStep));
+      field.Set("numeric", numeric);
+    }
+
+    if (!descriptor.options.empty()) {
+      Napi::Array options = Napi::Array::New(env, descriptor.options.size());
+      for (size_t optionIndex = 0; optionIndex < descriptor.options.size(); ++optionIndex) {
+        options[static_cast<uint32_t>(optionIndex)] =
+            Napi::String::New(env, descriptor.options[optionIndex]);
+      }
+      field.Set("options", options);
+    }
+
+    schemaArray[static_cast<uint32_t>(i)] = field;
+  }
+
+  return schemaArray;
+}
+
+Napi::Value NodeHamLib::GetPortCaps(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RETURN_NULL_IF_RIG_HANDLE_INVALID();
+
+  shim_rig_port_caps_t caps{};
+  int result = shim_rig_get_port_caps(my_rig, &caps);
+
+  if (result != SHIM_RIG_OK) {
+    Napi::Error::New(env, shim_rigerror(result)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object portCaps = Napi::Object::New(env);
+  portCaps.Set("portType", Napi::String::New(env, caps.port_type));
+  portCaps.Set("writeDelay", Napi::Number::New(env, caps.write_delay));
+  portCaps.Set("postWriteDelay", Napi::Number::New(env, caps.post_write_delay));
+  portCaps.Set("timeout", Napi::Number::New(env, caps.timeout));
+  portCaps.Set("retry", Napi::Number::New(env, caps.retry));
+
+  if (hasPositiveValue(caps.serial_rate_min)) {
+    portCaps.Set("serialRateMin", Napi::Number::New(env, caps.serial_rate_min));
+  }
+  if (hasPositiveValue(caps.serial_rate_max)) {
+    portCaps.Set("serialRateMax", Napi::Number::New(env, caps.serial_rate_max));
+  }
+  if (hasPositiveValue(caps.serial_data_bits)) {
+    portCaps.Set("serialDataBits", Napi::Number::New(env, caps.serial_data_bits));
+  }
+  if (hasPositiveValue(caps.serial_stop_bits)) {
+    portCaps.Set("serialStopBits", Napi::Number::New(env, caps.serial_stop_bits));
+  }
+  if (caps.serial_parity[0] != '\0' && std::string(caps.serial_parity) != "Unknown") {
+    portCaps.Set("serialParity", Napi::String::New(env, caps.serial_parity));
+  }
+  if (caps.serial_handshake[0] != '\0' && std::string(caps.serial_handshake) != "Unknown") {
+    portCaps.Set("serialHandshake", Napi::String::New(env, caps.serial_handshake));
+  }
+
+  return portCaps;
+}
+
 // Power Control Methods
 Napi::Value NodeHamLib::SetPowerstat(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
@@ -6156,11 +6313,7 @@ private:
 
 Napi::Value NodeHamLib::SetConf(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-
-  if (!rig_is_open) {
-    Napi::TypeError::New(env, "Rig is not open!").ThrowAsJavaScriptException();
-    return env.Null();
-  }
+  RETURN_NULL_IF_RIG_HANDLE_INVALID();
 
   if (info.Length() < 2 || !info[0].IsString() || !info[1].IsString()) {
     Napi::TypeError::New(env, "Expected (name: string, value: string)").ThrowAsJavaScriptException();
@@ -6212,11 +6365,7 @@ private:
 
 Napi::Value NodeHamLib::GetConf(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-
-  if (!rig_is_open) {
-    Napi::TypeError::New(env, "Rig is not open!").ThrowAsJavaScriptException();
-    return env.Null();
-  }
+  RETURN_NULL_IF_RIG_HANDLE_INVALID();
 
   if (info.Length() < 1 || !info[0].IsString()) {
     Napi::TypeError::New(env, "Expected (name: string)").ThrowAsJavaScriptException();

package/src/hamlib.h

@@ -99,6 +99,8 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
   Napi::Value SetDcdType(const Napi::CallbackInfo&);
   Napi::Value GetDcdType(const Napi::CallbackInfo&);
   Napi::Value GetSupportedSerialConfigs(const Napi::CallbackInfo&);
+  Napi::Value GetConfigSchema(const Napi::CallbackInfo&);
+  Napi::Value GetPortCaps(const Napi::CallbackInfo&);
 
   // Power Control
   Napi::Value SetPowerstat(const Napi::CallbackInfo&);
@@ -242,6 +244,7 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
 
   // Static callback helper for shim_rig_list_foreach
   static int rig_list_callback(const shim_rig_info_t* info, void* data);
+  static int rig_config_callback(const shim_confparam_info_t* info, void* data);
 
   void EmitSpectrumLine(const shim_spectrum_line_t& line);
   void StopSpectrumStreamInternal();

package/src/shim/hamlib_shim.c

@@ -66,6 +66,19 @@ struct shim_list_adapter {
     void* user_data;
 };
 
+struct shim_cfg_adapter {
+    RIG* rig;
+    shim_rig_cfg_cb_t user_cb;
+    void* user_data;
+};
+
+static void shim_copy_string(char* dest, size_t dest_size, const char* src) {
+    if (!dest || dest_size == 0) return;
+    if (!src) src = "";
+    strncpy(dest, src, dest_size - 1);
+    dest[dest_size - 1] = '\0';
+}
+
 static int shim_list_foreach_adapter(const struct rig_caps *caps, void *data) {
     struct shim_list_adapter *adapter = (struct shim_list_adapter*)data;
     shim_rig_info_t info;
@@ -85,6 +98,137 @@ SHIM_API int shim_rig_list_foreach(shim_rig_list_cb_t cb, void* data) {
     return rig_list_foreach(shim_list_foreach_adapter, &adapter);
 }
 
+static int shim_cfg_foreach_adapter(const struct confparams* param, rig_ptr_t data) {
+    struct shim_cfg_adapter* adapter = (struct shim_cfg_adapter*)data;
+    const struct confparams* lookup;
+    shim_confparam_info_t info;
+    int i;
+
+    if (!adapter || !adapter->user_cb || !param) {
+        return 0;
+    }
+
+    if (!adapter->rig || !param->name) {
+        return 1;
+    }
+
+    lookup = rig_confparam_lookup(adapter->rig, param->name);
+    if (!lookup || lookup->token != param->token) {
+        return 1;
+    }
+
+    memset(&info, 0, sizeof(info));
+    info.token = (int)param->token;
+    info.type = (int)param->type;
+
+    shim_copy_string(info.name, sizeof(info.name), param->name);
+    shim_copy_string(info.label, sizeof(info.label), param->label);
+    shim_copy_string(info.tooltip, sizeof(info.tooltip), param->tooltip);
+    shim_copy_string(info.dflt, sizeof(info.dflt), param->dflt);
+
+    if (param->type == RIG_CONF_NUMERIC || param->type == RIG_CONF_INT) {
+        info.numeric_min = param->u.n.min;
+        info.numeric_max = param->u.n.max;
+        info.numeric_step = param->u.n.step;
+    } else if (param->type == RIG_CONF_COMBO) {
+        for (i = 0; i < RIG_COMBO_MAX && i < SHIM_CONF_COMBO_MAX; ++i) {
+            if (!param->u.c.combostr[i] || !*param->u.c.combostr[i]) {
+                break;
+            }
+
+            shim_copy_string(
+                info.combo_options[i],
+                sizeof(info.combo_options[i]),
+                param->u.c.combostr[i]
+            );
+            info.combo_count++;
+        }
+    }
+
+    return adapter->user_cb(&info, adapter->user_data);
+}
+
+SHIM_API int shim_rig_cfgparams_foreach(hamlib_shim_handle_t h, shim_rig_cfg_cb_t cb, void* data) {
+    RIG* rig = (RIG*)h;
+    struct shim_cfg_adapter adapter;
+
+    if (!rig || !cb) {
+        return -RIG_EINVAL;
+    }
+
+    adapter.rig = rig;
+    adapter.user_cb = cb;
+    adapter.user_data = data;
+
+    return rig_token_foreach(rig, shim_cfg_foreach_adapter, &adapter);
+}
+
+static const char* shim_port_type_name(enum rig_port_e port_type) {
+    switch (port_type) {
+        case RIG_PORT_NONE: return "none";
+        case RIG_PORT_SERIAL: return "serial";
+        case RIG_PORT_NETWORK: return "network";
+        case RIG_PORT_DEVICE: return "device";
+        case RIG_PORT_PACKET: return "packet";
+        case RIG_PORT_DTMF: return "dtmf";
+        case RIG_PORT_ULTRA: return "ultra";
+        case RIG_PORT_RPC: return "rpc";
+        case RIG_PORT_PARALLEL: return "parallel";
+        case RIG_PORT_USB: return "usb";
+        case RIG_PORT_UDP_NETWORK: return "udp-network";
+        case RIG_PORT_CM108: return "cm108";
+        case RIG_PORT_GPIO: return "gpio";
+        case RIG_PORT_GPION: return "gpion";
+        default: return "other";
+    }
+}
+
+static const char* shim_serial_parity_name(enum serial_parity_e parity) {
+    switch (parity) {
+        case RIG_PARITY_NONE: return "None";
+        case RIG_PARITY_ODD: return "Odd";
+        case RIG_PARITY_EVEN: return "Even";
+        case RIG_PARITY_MARK: return "Mark";
+        case RIG_PARITY_SPACE: return "Space";
+        default: return "Unknown";
+    }
+}
+
+static const char* shim_serial_handshake_name(enum serial_handshake_e handshake) {
+    switch (handshake) {
+        case RIG_HANDSHAKE_NONE: return "None";
+        case RIG_HANDSHAKE_XONXOFF: return "XONXOFF";
+        case RIG_HANDSHAKE_HARDWARE: return "Hardware";
+        default: return "Unknown";
+    }
+}
+
+SHIM_API int shim_rig_get_port_caps(hamlib_shim_handle_t h, shim_rig_port_caps_t* out_caps) {
+    RIG* rig = (RIG*)h;
+    const struct rig_caps* caps;
+
+    if (!rig || !out_caps || !rig->caps) {
+        return -RIG_EINVAL;
+    }
+
+    caps = rig->caps;
+    memset(out_caps, 0, sizeof(*out_caps));
+
+    shim_copy_string(out_caps->port_type, sizeof(out_caps->port_type), shim_port_type_name(caps->port_type));
+    out_caps->serial_rate_min = caps->serial_rate_min;
+    out_caps->serial_rate_max = caps->serial_rate_max;
+    out_caps->serial_data_bits = caps->serial_data_bits;
+    out_caps->serial_stop_bits = caps->serial_stop_bits;
+    shim_copy_string(out_caps->serial_parity, sizeof(out_caps->serial_parity), shim_serial_parity_name(caps->serial_parity));
+    shim_copy_string(out_caps->serial_handshake, sizeof(out_caps->serial_handshake), shim_serial_handshake_name(caps->serial_handshake));
+    out_caps->write_delay = caps->write_delay;
+    out_caps->post_write_delay = caps->post_write_delay;
+    out_caps->timeout = caps->timeout;
+    out_caps->retry = caps->retry;
+
+    return RIG_OK;
+}
+
 SHIM_API const char* shim_rig_strstatus(int status) {
     return rig_strstatus((enum rig_status_e)status);
 }

package/src/shim/hamlib_shim.h

@@ -293,6 +293,44 @@ typedef struct {
     int rig_type;
 } shim_rig_info_t;
 
+#define SHIM_CONF_NAME_MAX 64
+#define SHIM_CONF_LABEL_MAX 128
+#define SHIM_CONF_TOOLTIP_MAX 256
+#define SHIM_CONF_DEFAULT_MAX 128
+#define SHIM_CONF_COMBO_MAX 16
+#define SHIM_CONF_COMBO_VALUE_MAX 64
+#define SHIM_PORT_TYPE_MAX 32
+#define SHIM_PARITY_MAX 32
+#define SHIM_HANDSHAKE_MAX 32
+
+typedef struct {
+    int token;
+    char name[SHIM_CONF_NAME_MAX];
+    char label[SHIM_CONF_LABEL_MAX];
+    char tooltip[SHIM_CONF_TOOLTIP_MAX];
+    char dflt[SHIM_CONF_DEFAULT_MAX];
+    int type;
+    double numeric_min;
+    double numeric_max;
+    double numeric_step;
+    int combo_count;
+    char combo_options[SHIM_CONF_COMBO_MAX][SHIM_CONF_COMBO_VALUE_MAX];
+} shim_confparam_info_t;
+
+typedef struct {
+    char port_type[SHIM_PORT_TYPE_MAX];
+    int serial_rate_min;
+    int serial_rate_max;
+    int serial_data_bits;
+    int serial_stop_bits;
+    char serial_parity[SHIM_PARITY_MAX];
+    char serial_handshake[SHIM_HANDSHAKE_MAX];
+    int write_delay;
+    int post_write_delay;
+    int timeout;
+    int retry;
+} shim_rig_port_caps_t;
+
 typedef struct {
     int id;
     char name[64];
@@ -331,6 +369,8 @@ typedef int (*shim_spectrum_cb_t)(void* handle, const shim_spectrum_line_t* line
 
 /* Rig list callback: (info, data) -> int */
 typedef int (*shim_rig_list_cb_t)(const shim_rig_info_t* info, void* data);
+/* Rig config callback: (info, data) -> int */
+typedef int (*shim_rig_cfg_cb_t)(const shim_confparam_info_t* info, void* data);
 
 /* ===== Lifecycle functions ===== */
 
@@ -347,6 +387,8 @@ SHIM_API int  shim_rig_get_debug(void);
 SHIM_API const char* shim_rig_get_version(void);
 SHIM_API int  shim_rig_load_all_backends(void);
 SHIM_API int  shim_rig_list_foreach(shim_rig_list_cb_t cb, void* data);
+SHIM_API int  shim_rig_cfgparams_foreach(hamlib_shim_handle_t h, shim_rig_cfg_cb_t cb, void* data);
+SHIM_API int  shim_rig_get_port_caps(hamlib_shim_handle_t h, shim_rig_port_caps_t* out_caps);
 SHIM_API const char* shim_rig_strstatus(int status);
 
 /* ===== Port configuration (before open) ===== */