@tx5dr/contracts 1.7.12 → 2.5.0

package/src/schema/websocket.schema.ts

@@ -20,8 +20,16 @@ import type {
   PluginSystemSnapshot,
 } from './plugin.schema.js';
 import { ModeDescriptorSchema } from './mode.schema.js';
-import { QSORecordSchema, TargetSelectionPriorityModeSchema } from './qso.schema.js';
-import { LogBookStatisticsSchema } from './logbook.schema.js';
+import {
+  QSORecordSchema,
+  QSOPersistencePolicySchema,
+  TargetSelectionPriorityModeSchema,
+} from './qso.schema.js';
+import {
+  LogBookStatisticsSchema,
+  LogbookHealthSchema,
+  LogbookOperationErrorCodeSchema,
+} from './logbook.schema.js';
 import { RadioInfoSchema, HamlibConfigSchema, TunerStatusSchema, TunerCapabilitiesSchema, RadioConnectionStatusSchema, ReconnectProgressSchema, CoreRadioCapabilitiesSchema, CoreCapabilityDiagnosticsSchema } from './radio.schema.js';
 import { RadioProfileSchema, ProfileChangedEventSchema } from './radio-profile.schema.js';
 import { UserRole } from './auth.schema.js';
@@ -32,9 +40,27 @@ import { CWDecoderEventSchema, CWDecoderStatusSchema, type CWDecoderEvent, type
 import { CapabilityListSchema, CapabilityStateSchema, WriteCapabilityPayloadSchema } from './radio-capability.schema.js';
 import { RadioPowerStateEventSchema } from './radio-power.schema.js';
 import { AudioSidecarStatusPayloadSchema } from './audio-sidecar.schema.js';
-import { SpectrumCapabilitiesSchema, SpectrumFrameSchema, SpectrumKindSchema, SpectrumSessionControlActionSchema, SpectrumSessionControlIdSchema, SpectrumSessionStateSchema } from './spectrum.schema.js';
+import { SpectrumCapabilitiesSchema, SpectrumFrameSchema, SpectrumKindSchema, SpectrumSessionControlActionSchema, SpectrumSessionControlIdSchema, SpectrumSessionStateSchema, SpectrumViewportSchema } from './spectrum.schema.js';
 import type { RealtimeSettingsResponseData } from './realtime.schema.js';
+import type { AndroidOperatorAudioStatus } from './android-operator-audio.schema.js';
 import { ClockStatusSummarySchema } from './system.schema.js';
+import {
+  ImageRadioStatusSchema,
+  ImageRxEventSchema,
+  ImageRxSubscriptionSchema,
+  FaxCalibrationCommandResultSchema,
+  FaxCalibrationResetCommandSchema,
+  FaxCalibrationSetCommandSchema,
+  SstvTxCancelCommandSchema,
+  SstvTxCommandResultSchema,
+  SstvTxStartCommandSchema,
+  SstvTxStatusSchema,
+  type ImageRadioStatus,
+  type ImageRxEvent,
+  type FaxCalibrationCommandResult,
+  type SstvTxCommandResult,
+  type SstvTxStatus,
+} from './image-radio.schema.js';
 
 // WebSocket消息类型枚举
 export enum WSMessageType {
@@ -50,6 +76,16 @@ export enum WSMessageType {
   STOP_ENGINE = 'stopEngine',
   GET_STATUS = 'getStatus',
   SET_MODE = 'setMode',
+  SUBSCRIBE_IMAGE_RX = 'subscribeImageRx',
+  IMAGE_RADIO_STATUS = 'imageRadioStatus',
+  IMAGE_RX_EVENT = 'imageRxEvent',
+  SSTV_TX_START = 'sstvTxStart',
+  SSTV_TX_CANCEL = 'sstvTxCancel',
+  SSTV_TX_STATUS = 'sstvTxStatus',
+  SSTV_TX_COMMAND_RESULT = 'sstvTxCommandResult',
+  FAX_CALIBRATION_SET = 'faxCalibrationSet',
+  FAX_CALIBRATION_RESET = 'faxCalibrationReset',
+  FAX_CALIBRATION_COMMAND_RESULT = 'faxCalibrationCommandResult',
   
   // ===== 引擎事件 =====
   MODE_CHANGED = 'modeChanged',
@@ -62,6 +98,7 @@ export enum WSMessageType {
   SPECTRUM_FRAME = 'spectrumFrame',
   SPECTRUM_SESSION_STATE_CHANGED = 'spectrumSessionStateChanged',
   INVOKE_SPECTRUM_CONTROL = 'invokeSpectrumControl',
+  SPECTRUM_VIEWPORT_CHANGED = 'spectrumViewportChanged',
   DECODE_ERROR = 'decodeError',
   SYSTEM_STATUS = 'systemStatus',
   BOOTSTRAP_STATUS_CHANGED = 'bootstrapStatusChanged',
@@ -75,11 +112,18 @@ export enum WSMessageType {
   OPERATOR_STATUS_UPDATE = 'operatorStatusUpdate',
   SET_OPERATOR_CONTEXT = 'setOperatorContext',
   SET_OPERATOR_RUNTIME_STATE = 'setOperatorRuntimeState',
+  SET_OPERATOR_STREAM_STATE = 'setOperatorStreamState',
+  INVOKE_OPERATOR_STRATEGY_ACTION = 'invokeOperatorStrategyAction',
   SET_OPERATOR_RUNTIME_SLOT_CONTENT = 'setOperatorRuntimeSlotContent',
   SET_OPERATOR_TRANSMIT_CYCLES = 'setOperatorTransmitCycles',
   START_OPERATOR = 'startOperator',
   STOP_OPERATOR = 'stopOperator',
   OPERATOR_REQUEST_CALL = 'operatorRequestCall',
+  OPERATOR_QUEUE_ENQUEUE = 'operatorQueueEnqueue',
+  OPERATOR_QUEUE_REORDER = 'operatorQueueReorder',
+  OPERATOR_QUEUE_RETRY = 'operatorQueueRetry',
+  OPERATOR_QUEUE_REMOVE = 'operatorQueueRemove',
+  OPERATOR_QUEUE_CLEAR = 'operatorQueueClear',
   
   // ===== 客户端操作员过滤 =====
   SET_CLIENT_ENABLED_OPERATORS = 'setClientEnabledOperators',
@@ -102,6 +146,8 @@ export enum WSMessageType {
   QSO_RECORD_ADDED = 'qsoRecordAdded',
   QSO_RECORD_UPDATED = 'qsoRecordUpdated',
   LOGBOOK_UPDATED = 'logbookUpdated',
+  LOGBOOK_HEALTH_CHANGED = 'logbookHealthChanged',
+  LOGBOOK_WRITE_FAILED = 'logbookWriteFailed',
   // 仅通知的日志本变更事件（专用于日志本WS）
   LOGBOOK_CHANGE_NOTICE = 'logbookChangeNotice',
   
@@ -143,6 +189,8 @@ export enum WSMessageType {
   WRITE_RADIO_CAPABILITY = 'writeRadioCapability',
   /** 客户端请求刷新所有能力值（client → server） */
   REFRESH_RADIO_CAPABILITIES = 'refreshRadioCapabilities',
+  /** 客户端设置 Split TX 频率（client → server） */
+  SET_SPLIT_FREQUENCY = 'setSplitFrequency',
 
   // ===== 电台重连控制 =====
   RADIO_STOP_RECONNECT = 'radioStopReconnect',
@@ -168,6 +216,7 @@ export enum WSMessageType {
   AUTH_PUBLIC_VIEWER = 'authPublicViewer',
   AUTH_RESULT = 'authResult',
   AUTH_EXPIRED = 'authExpired',
+  ACCESS_DENIED = 'accessDenied',
 
   // ===== 语音模式 =====
   VOICE_PTT_REQUEST = 'voicePttRequest',
@@ -178,6 +227,7 @@ export enum WSMessageType {
   VOICE_KEYER_PLAY = 'voiceKeyerPlay',
   VOICE_KEYER_STOP = 'voiceKeyerStop',
   VOICE_KEYER_STATUS_CHANGED = 'voiceKeyerStatusChanged',
+  ANDROID_OPERATOR_AUDIO_STATUS_CHANGED = 'androidOperatorAudioStatusChanged',
 
   // ===== CW 模式 =====
   /** CW 键控器状态变化（server → client） */
@@ -238,7 +288,7 @@ export const SystemStatusSchema = z.object({
     connectionHealthy: z.boolean(),
   }).optional(),
   /** 引擎模式：digital（FT8/FT4）、voice（语音通联）或 cw（莫尔斯码） */
-  engineMode: z.enum(['digital', 'voice', 'cw']).default('digital'),
+  engineMode: z.enum(['digital', 'voice', 'cw', 'image']).default('digital'),
   /** 当前电台调制模式（语音模式下使用，如 USB/LSB/FM/AM） */
   currentRadioMode: z.string().optional(),
   /** 引擎状态机当前状态 */
@@ -325,7 +375,15 @@ export const DecodeErrorInfoSchema = z.object({
   }),
 });
 
-// 频率状态数据结构
+/**
+ * Current dial-frequency projection broadcast to plugins and clients.
+ *
+ * `frequency` is the logical RF dial target in hertz; `mode` is the TX-5DR
+ * engine mode; `band` and `description` are display labels; `radioMode` is the
+ * underlying modulation when known. `observedFrequency` is the latest physical
+ * readback. `source` distinguishes application changes from radio observations;
+ * `revision` and `connectionGeneration` reject stale events.
+ */
 export const FrequencyStateSchema = z.object({
   frequency: z.number(),
   mode: z.string(),
@@ -334,6 +392,20 @@ export const FrequencyStateSchema = z.object({
   radioMode: z.string().optional(),
   radioConnected: z.boolean(),
   source: z.enum(['program', 'radio']).optional(),
+  /** Monotonic operating-state revision for stale-event suppression. */
+  revision: z.number().int().nonnegative().optional(),
+  /** Physical CAT session identity associated with this snapshot. */
+  connectionGeneration: z.number().int().nonnegative().optional(),
+  /** Physical confirmation status for the requested operating state. */
+  confirmation: z.enum(['confirmed', 'pending', 'mismatch', 'offline']).optional(),
+  /** Last frequency read back from the physical radio, when available. */
+  observedFrequency: z.number().optional(),
+  /** Requested logical frequency when it differs from the observed value. */
+  requestedFrequency: z.number().optional(),
+  /** Correlates a snapshot with one programmatic operating-state mutation. */
+  operationId: z.string().optional(),
+  /** Physical radio-mode confirmation status. */
+  modeConfirmation: z.enum(['confirmed', 'unconfirmed', 'unknown']).optional(),
 });
 
 export const SpectrumControlInvocationSchema = z.object({
@@ -346,6 +418,9 @@ export type SpectrumControlInvocation = z.infer<typeof SpectrumControlInvocation
 export const PTTStatusSchema = z.object({
   isTransmitting: z.boolean(),
   operatorIds: z.array(z.string()),
+  phase: z.enum(['idle', 'starting', 'on_air', 'draining', 'stopping', 'unknown']).optional(),
+  frameId: z.string().optional(),
+  source: z.enum(['digital', 'voice', 'voice-keyer', 'cw', 'sstv', 'tune-tone', 'manual', 'test']).optional(),
 });
 
 export const TuneToneStartPayloadSchema = z.object({
@@ -383,6 +458,200 @@ export const StrategyRuntimeContextSchema = z.object({
 });
 export type StrategyRuntimeContext = z.infer<typeof StrategyRuntimeContextSchema>;
 
+export const StrategyStateOptionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1).optional(),
+  transmitText: z.string().optional(),
+});
+export type StrategyStateOption = z.infer<typeof StrategyStateOptionSchema>;
+
+export const StrategyActionInputSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('text'),
+    label: z.string().optional(),
+    value: z.string().optional(),
+    placeholder: z.string().optional(),
+    maxLength: z.number().int().positive().optional(),
+  }),
+  z.object({
+    kind: z.enum(['number', 'audio-frequency']),
+    label: z.string().optional(),
+    value: z.number().optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    step: z.number().positive().optional(),
+    unit: z.string().optional(),
+    spectrumPick: z.boolean().optional(),
+  }),
+]);
+
+export const StrategyActionDescriptorSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  tone: z.enum(['default', 'primary', 'success', 'warning', 'danger']).optional(),
+  presentation: z.enum(['primary', 'secondary', 'menu', 'segmented']).optional(),
+  groupId: z.string().optional(),
+  selected: z.boolean().optional(),
+  disabledReason: z.string().optional(),
+  previewText: z.string().optional(),
+  confirmation: z.object({
+    title: z.string().min(1),
+    description: z.string().optional(),
+    confirmLabel: z.string().optional(),
+    cancelLabel: z.string().optional(),
+  }).optional(),
+  input: StrategyActionInputSchema.optional(),
+  navigation: z.object({
+    kind: z.literal('plugin-page'),
+    pageId: z.string().min(1),
+  }).optional(),
+});
+export type StrategyActionDescriptor = z.infer<typeof StrategyActionDescriptorSchema>;
+
+export const StrategyAttentionSchema = z.object({
+  id: z.string().min(1),
+  tone: z.enum(['info', 'warning', 'danger', 'success']),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  params: z.record(z.string(), z.union([z.string(), z.number()])).optional(),
+  notify: z.boolean().optional(),
+  expiresAt: z.number().optional(),
+  actionIds: z.array(z.string()).optional(),
+});
+export type StrategyAttention = z.infer<typeof StrategyAttentionSchema>;
+
+export const StrategyCompletionProjectionSchema = z.object({
+  state: z.enum(['not-ready', 'ready', 'committing', 'committed', 'failed']),
+  label: z.string().optional(),
+  recordId: z.string().optional(),
+});
+export type StrategyCompletionProjection = z.infer<typeof StrategyCompletionProjectionSchema>;
+
+export const StrategyStreamSnapshotSchema = z.object({
+  streamId: z.string().min(1),
+  currentState: z.string(),
+  targetCallsign: z.string().optional(),
+  targetGrid: z.string().optional(),
+  audioFrequencyHz: z.number().min(0).max(5000),
+  qsoLifecycleEpoch: z.number().int().nonnegative(),
+  stateOptions: z.array(StrategyStateOptionSchema).optional(),
+  actions: z.array(StrategyActionDescriptorSchema).optional(),
+  attentions: z.array(StrategyAttentionSchema).optional(),
+  completion: StrategyCompletionProjectionSchema.optional(),
+  lastReceivedText: z.string().optional(),
+  nextTransmitText: z.string().optional(),
+});
+export type StrategyStreamSnapshot = z.infer<typeof StrategyStreamSnapshotSchema>;
+
+export const StrategyTransmissionSchema = z.object({
+  streamId: z.string().min(1),
+  text: z.string().min(1),
+  audioFrequencyHz: z.number().min(0).max(5000),
+});
+export type StrategyTransmission = z.infer<typeof StrategyTransmissionSchema>;
+
+export const AssistedQueueDisplayStateSchema = z.enum([
+  'TX1', 'TX2', 'TX3', 'TX4', 'TX5', 'engaged', 'closing', 'paused', 'no-response', 'later', 'review',
+  'candidate', 'authorized', 'dupe',
+]);
+export const AssistedQueuePauseReasonSchema = z.enum(['target-busy', 'stale']);
+export const AssistedQueueToneSchema = z.enum(['neutral', 'active', 'success', 'warning', 'danger']);
+export const AssistedQueueIconSchema = z.enum([
+  'circle', 'radio', 'check-circle', 'loader-circle', 'clock', 'pause', 'triangle-alert',
+]);
+export const AssistedQueueRowSchema = z.object({
+  entryId: z.string(),
+  callsign: z.string(),
+  order: z.number().int().nonnegative(),
+  draggable: z.boolean(),
+  displayState: AssistedQueueDisplayStateSchema,
+  tone: AssistedQueueToneSchema,
+  icon: AssistedQueueIconSchema,
+  pauseReason: AssistedQueuePauseReasonSchema.optional(),
+  noResponseCycles: z.number().int().nonnegative().optional(),
+  targetGrid: z.string().optional(),
+  lastSnr: z.number().optional(),
+  lastHeardCyclesAgo: z.number().int().nonnegative().optional(),
+  lastHeardCycle: z.union([z.literal(0), z.literal(1)]).optional(),
+  streamId: z.string().optional(),
+  audioFrequencyHz: z.number().optional(),
+  authorizationId: z.string().optional(),
+  actions: z.array(StrategyActionDescriptorSchema).optional(),
+});
+export const AssistedQueueSnapshotSchema = z.object({
+  version: z.number().int().nonnegative(),
+  activeEntryId: z.string().optional(),
+  activeEntryIds: z.array(z.string()).optional(),
+  maxActiveStreams: z.number().int().min(1).max(5).optional(),
+  requestedMaxActiveStreams: z.number().int().min(1).max(5).optional(),
+  rows: z.array(AssistedQueueRowSchema),
+});
+export type AssistedQueueDisplayState = z.infer<typeof AssistedQueueDisplayStateSchema>;
+export type AssistedQueuePauseReason = z.infer<typeof AssistedQueuePauseReasonSchema>;
+export type AssistedQueueTone = z.infer<typeof AssistedQueueToneSchema>;
+export type AssistedQueueIcon = z.infer<typeof AssistedQueueIconSchema>;
+export type AssistedQueueRow = z.infer<typeof AssistedQueueRowSchema>;
+export type AssistedQueueSnapshot = z.infer<typeof AssistedQueueSnapshotSchema>;
+
+/** Null clears an unsettable runtime report field over JSON/WebSocket. */
+export const OperatorContextReportFieldSchema = z.number().nullish();
+
+export const StrategyMessagePresentationToneSchema = z.enum([
+  'neutral', 'primary', 'secondary', 'success', 'warning', 'danger',
+]);
+export const StrategyMessagePresentationBadgeSchema = z.object({
+  label: z.string().min(1),
+  tone: StrategyMessagePresentationToneSchema,
+});
+export const StrategyMessagePresentationTokenMatchSchema = z.object({
+  firstTokenIn: z.array(z.string().min(1)).optional(),
+  anyTokenIn: z.array(z.string().min(1)).optional(),
+});
+export const StrategyMessagePresentationClassSchema = z.object({
+  badge: StrategyMessagePresentationBadgeSchema.optional(),
+  badges: z.array(StrategyMessagePresentationBadgeSchema).optional(),
+  row: z.object({
+    tone: StrategyMessagePresentationToneSchema,
+    background: z.enum(['none', 'soft']).optional(),
+    accent: z.boolean().optional(),
+  }).optional(),
+  emphasisWhen: z.array(StrategyMessagePresentationTokenMatchSchema).min(1).optional(),
+  textDecoration: z.literal('line-through').optional(),
+  opacity: z.enum(['normal', 'muted']).optional(),
+});
+export const StrategyMessagePresentationProjectionSchema = z.object({
+  revision: z.number().int().nonnegative(),
+  mode: z.enum(['replace-logbook', 'augment']),
+  subject: z.literal('sender-callsign'),
+  partitionBy: z.enum(['band', 'mode', 'none']),
+  eligiblePartitions: z.array(z.string()).optional(),
+  defaultClass: z.string().optional(),
+  classes: z.record(z.string(), StrategyMessagePresentationClassSchema),
+  assignments: z.array(z.object({
+    subject: z.string().min(1),
+    partition: z.string().optional(),
+    classId: z.string().min(1),
+  })),
+  noveltyRules: z.array(z.object({
+    fact: z.literal('grid-field-2'),
+    knownValuesByPartition: z.record(z.string(), z.array(z.string().min(1))),
+    classId: z.string().min(1),
+  })).optional(),
+  tagRules: z.array(z.object({
+    id: z.string().min(1),
+    match: StrategyMessagePresentationTokenMatchSchema,
+    badge: StrategyMessagePresentationBadgeSchema,
+  })).optional(),
+});
+
+export type StrategyMessagePresentationTone = z.infer<typeof StrategyMessagePresentationToneSchema>;
+export type StrategyMessagePresentationBadge = z.infer<typeof StrategyMessagePresentationBadgeSchema>;
+export type StrategyMessagePresentationTokenMatch = z.infer<typeof StrategyMessagePresentationTokenMatchSchema>;
+export type StrategyMessagePresentationClass = z.infer<typeof StrategyMessagePresentationClassSchema>;
+export type StrategyMessagePresentationProjection = z.infer<typeof StrategyMessagePresentationProjectionSchema>;
+
 export const StrategyRuntimeSnapshotSchema = z.object({
   currentState: z.string(),
   slots: z.object({
@@ -395,7 +664,33 @@ export const StrategyRuntimeSnapshotSchema = z.object({
   }).optional(),
   context: StrategyRuntimeContextSchema.optional(),
   availableSlots: z.array(z.string()).optional(),
+  qsoLifecycleEpoch: z.number().int().nonnegative().optional(),
+  streams: z.array(StrategyStreamSnapshotSchema).optional(),
+  queue: AssistedQueueSnapshotSchema.optional(),
+  actions: z.array(StrategyActionDescriptorSchema).optional(),
+  attentions: z.array(StrategyAttentionSchema).optional(),
+  messagePresentation: StrategyMessagePresentationProjectionSchema.optional(),
+  transmitGate: z.object({
+    allowed: z.literal(false),
+    reason: z.string().min(1),
+    actionId: z.string().optional(),
+  }).optional(),
 });
+
+export const StrategyActionTargetSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('runtime') }),
+  z.object({
+    kind: z.literal('stream'),
+    streamId: z.string().min(1),
+    lifecycleEpoch: z.number().int().nonnegative(),
+  }),
+  z.object({
+    kind: z.literal('queue-entry'),
+    entryId: z.string().min(1),
+    queueVersion: z.number().int().nonnegative(),
+  }),
+]);
+export type StrategyActionTarget = z.infer<typeof StrategyActionTargetSchema>;
 export type StrategyRuntimeSnapshot = z.infer<typeof StrategyRuntimeSnapshotSchema>;
 
 export const LevelMeterDisplayStyleSchema = z.enum([
@@ -453,11 +748,12 @@ export const MeterDataSchema = z.object({
     raw: z.number(),
     percent: z.number(),
     alert: z.boolean(),
+    unit: z.enum(['percent', 'dbfs']).optional(),
   }).nullable(),
   level: LevelMeterReadingSchema.nullable(),
   power: z.object({
     raw: z.number(),
-    percent: z.number(),
+    percent: z.number().nullable(),
     watts: z.number().nullable(),  // 绝对瓦数（仅当电台支持 RFPOWER_METER_WATTS 时非 null）
     maxWatts: z.number().nullable(), // 当前频率+模式对应的量程瓦数
   }).nullable(),
@@ -504,6 +800,56 @@ export const WSModeChangedMessageSchema = WSBaseMessageSchema.extend({
   data: ModeDescriptorSchema,
 });
 
+export const WSSubscribeImageRxMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SUBSCRIBE_IMAGE_RX),
+  data: ImageRxSubscriptionSchema,
+});
+
+export const WSImageRadioStatusMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.IMAGE_RADIO_STATUS),
+  data: ImageRadioStatusSchema,
+});
+
+export const WSImageRxEventMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.IMAGE_RX_EVENT),
+  data: ImageRxEventSchema,
+});
+
+export const WSSstvTxStartMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SSTV_TX_START),
+  data: SstvTxStartCommandSchema,
+});
+
+export const WSSstvTxCancelMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SSTV_TX_CANCEL),
+  data: SstvTxCancelCommandSchema,
+});
+
+export const WSSstvTxStatusMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SSTV_TX_STATUS),
+  data: SstvTxStatusSchema,
+});
+
+export const WSSstvTxCommandResultMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SSTV_TX_COMMAND_RESULT),
+  data: SstvTxCommandResultSchema,
+});
+
+export const WSFaxCalibrationSetMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.FAX_CALIBRATION_SET),
+  data: FaxCalibrationSetCommandSchema,
+});
+
+export const WSFaxCalibrationResetMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.FAX_CALIBRATION_RESET),
+  data: FaxCalibrationResetCommandSchema,
+});
+
+export const WSFaxCalibrationCommandResultMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.FAX_CALIBRATION_COMMAND_RESULT),
+  data: FaxCalibrationCommandResultSchema,
+});
+
 export const WSSlotStartMessageSchema = WSBaseMessageSchema.extend({
   type: z.literal(WSMessageType.SLOT_START),
   data: SlotInfoSchema,
@@ -528,9 +874,15 @@ export const WSSubscribeSpectrumMessageSchema = WSBaseMessageSchema.extend({
   type: z.literal(WSMessageType.SUBSCRIBE_SPECTRUM),
   data: z.object({
     kind: SpectrumKindSchema.nullable(),
+    viewport: SpectrumViewportSchema.optional(),
   }),
 });
 
+export const WSSpectrumViewportChangedMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SPECTRUM_VIEWPORT_CHANGED),
+  data: SpectrumViewportSchema.nullable(),
+});
+
 export const WSSpectrumSubscriptionChangedMessageSchema = WSBaseMessageSchema.extend({
   type: z.literal(WSMessageType.SPECTRUM_SUBSCRIPTION_CHANGED),
   data: z.object({
@@ -642,12 +994,16 @@ export const WSGetStatusMessageSchema = WSBaseMessageSchema.extend({
 export const OperatorStatusSchema = z.object({
   id: z.string(),
   isActive: z.boolean(),
-  isTransmitting: z.boolean(), // 是否正在发射（发射开关状态）
+  isTransmitting: z.boolean(), // 是否已授予策略自动发射许可（发射开关状态）
   isInActivePTT: z.boolean().optional(), // 该操作员的音频是否正在被实际播放
+  hasTransmitIntent: z.boolean().optional(), // 当前策略是否有可在合法周期发射的有效内容
+  currentTransmissions: z.array(StrategyTransmissionSchema).optional(),
   currentSlot: z.string().optional(),
   context: z.object({
     myCall: z.string(),
     myGrid: z.string(),
+    /** Canonical active target set; `targetCall` remains the primary compatibility field. */
+    targetCalls: z.array(z.string()).optional(),
     targetCall: z.string(),
     targetGrid: z.string().optional(),
     frequency: z.number().optional(),
@@ -713,8 +1069,8 @@ export const WSSetOperatorContextMessageSchema = WSBaseMessageSchema.extend({
       targetCallsign: z.string().optional(),
       targetGrid: z.string().optional(),
       frequency: z.number().optional(),
-      reportSent: z.number().optional(),
-      reportReceived: z.number().optional(),
+      reportSent: OperatorContextReportFieldSchema,
+      reportReceived: OperatorContextReportFieldSchema,
     }),
   }),
 });
@@ -730,6 +1086,27 @@ export const WSSetOperatorRuntimeStateMessageSchema = WSBaseMessageSchema.extend
   }),
 });
 
+/** Sets one strategy-owned stream to a protocol-approved state. */
+export const WSSetOperatorStreamStateMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SET_OPERATOR_STREAM_STATE),
+  data: z.object({
+    operatorId: z.string(),
+    streamId: z.string().min(1),
+    stateId: z.string().min(1),
+    expectedLifecycleEpoch: z.number().int().nonnegative(),
+  }),
+});
+
+export const WSInvokeOperatorStrategyActionMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.INVOKE_OPERATOR_STRATEGY_ACTION),
+  data: z.object({
+    operatorId: z.string().min(1),
+    target: StrategyActionTargetSchema,
+    actionId: z.string().min(1),
+    payload: z.unknown().optional(),
+  }),
+});
+
 /**
  * 设置操作员运行时槽位内容消息
  */
@@ -796,6 +1173,52 @@ export const WSOperatorRequestCallMessageSchema = WSBaseMessageSchema.extend({
   }),
 });
 
+export const WSOperatorQueueEnqueueMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.OPERATOR_QUEUE_ENQUEUE),
+  data: z.object({
+    operatorId: z.string(),
+    callsign: z.string(),
+    selectedFrame: WSSelectedFrameSchema.optional(),
+    startIfIdle: z.boolean().optional(),
+  }),
+});
+
+export const WSOperatorQueueReorderMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.OPERATOR_QUEUE_REORDER),
+  data: z.object({
+    operatorId: z.string(),
+    entryId: z.string(),
+    beforeEntryId: z.string().nullable(),
+    expectedVersion: z.number().int().nonnegative(),
+  }),
+});
+
+export const WSOperatorQueueRetryMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.OPERATOR_QUEUE_RETRY),
+  data: z.object({
+    operatorId: z.string(),
+    entryId: z.string(),
+    expectedVersion: z.number().int().nonnegative(),
+  }),
+});
+
+export const WSOperatorQueueRemoveMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.OPERATOR_QUEUE_REMOVE),
+  data: z.object({
+    operatorId: z.string(),
+    entryId: z.string(),
+    expectedVersion: z.number().int().nonnegative(),
+  }),
+});
+
+export const WSOperatorQueueClearMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.OPERATOR_QUEUE_CLEAR),
+  data: z.object({
+    operatorId: z.string(),
+    expectedVersion: z.number().int().nonnegative(),
+  }),
+});
+
 /**
  * 设置客户端启用的操作员列表消息
  */
@@ -856,6 +1279,8 @@ export type WSOperatorsListMessage = z.infer<typeof WSOperatorsListMessageSchema
 export type WSOperatorStatusUpdateMessage = z.infer<typeof WSOperatorStatusUpdateMessageSchema>;
 export type WSSetOperatorContextMessage = z.infer<typeof WSSetOperatorContextMessageSchema>;
 export type WSSetOperatorRuntimeStateMessage = z.infer<typeof WSSetOperatorRuntimeStateMessageSchema>;
+export type WSSetOperatorStreamStateMessage = z.infer<typeof WSSetOperatorStreamStateMessageSchema>;
+export type WSInvokeOperatorStrategyActionMessage = z.infer<typeof WSInvokeOperatorStrategyActionMessageSchema>;
 export type WSSetOperatorRuntimeSlotContentMessage = z.infer<typeof WSSetOperatorRuntimeSlotContentMessageSchema>;
 export type WSSetOperatorTransmitCyclesMessage = z.infer<typeof WSSetOperatorTransmitCyclesMessageSchema>;
 export type WSStartOperatorMessage = z.infer<typeof WSStartOperatorMessageSchema>;
@@ -875,6 +1300,11 @@ export const WSTransmissionLogMessageSchema = WSBaseMessageSchema.extend({
   type: z.literal(WSMessageType.TRANSMISSION_LOG),
   data: z.object({
     operatorId: z.string(),
+    frameId: z.string(),
+    revision: z.number().int().nonnegative(),
+    playbackGeneration: z.number().int().positive(),
+    phase: z.literal('on_air'),
+    physicalConfirmed: z.literal(true),
     time: z.string(),
     message: z.string(),
     frequency: z.number(),
@@ -951,6 +1381,34 @@ export const WSLogbookUpdatedMessageSchema = WSBaseMessageSchema.extend({
 
 export type WSLogbookUpdatedMessage = z.infer<typeof WSLogbookUpdatedMessageSchema>;
 
+export const WSLogbookHealthChangedMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.LOGBOOK_HEALTH_CHANGED),
+  data: z.object({
+    logBookId: z.string(),
+    health: LogbookHealthSchema,
+  }),
+});
+
+export type WSLogbookHealthChangedMessage = z.infer<typeof WSLogbookHealthChangedMessageSchema>;
+
+export const WSLogbookWriteFailedMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.LOGBOOK_WRITE_FAILED),
+  data: z.object({
+    logBookId: z.string(),
+    operatorId: z.string().optional(),
+    attemptId: z.string().min(8).max(128).regex(/^[A-Za-z0-9._:-]+$/).optional(),
+    unsavedCount: z.number().int().positive().optional(),
+    error: z.object({
+      code: LogbookOperationErrorCodeSchema,
+      message: z.string(),
+      systemCode: z.string().optional(),
+      occurredAt: z.number(),
+    }),
+  }).strict(),
+});
+
+export type WSLogbookWriteFailedMessage = z.infer<typeof WSLogbookWriteFailedMessageSchema>;
+
 /**
  * 电台状态变化消息
  */
@@ -973,6 +1431,8 @@ export const WSRadioStatusChangedMessageSchema = WSBaseMessageSchema.extend({
     meterCapabilities: MeterCapabilitiesSchema.optional(), // 电台数值表能力（connected=true 时应始终携带）
     /** @deprecated Tuner capability is now in radioCapabilityList event. Kept for backward compat. */
     tunerCapabilities: TunerCapabilitiesSchema.optional(),
+    /** 虚拟频差实际生效状态（多op发射时为 false） */
+    fakeFrequencyEffective: z.boolean().optional(),
   }),
 });
 
@@ -1199,6 +1659,8 @@ export const WSTextMessageSchema = WSBaseMessageSchema.extend({
     text: z.string(),
     color: z.enum(['success', 'warning', 'danger', 'default']).optional(),
     timeout: z.number().nullable().optional(), // null 表示需要手动关闭，number 表示自动关闭的毫秒数
+    /** 服务端创建消息的时间戳，用于前端识别后台积压消息 */
+    createdAtMs: z.number().optional(),
     /** i18n key，前端有此字段时优先翻译显示 */
     key: z.string().optional(),
     /** i18n 插值参数 */
@@ -1255,6 +1717,19 @@ export const WSWriteRadioCapabilityMessageSchema = WSBaseMessageSchema.extend({
 
 export type WSWriteRadioCapabilityMessage = z.infer<typeof WSWriteRadioCapabilityMessageSchema>;
 
+export const SetSplitFrequencyPayloadSchema = z.object({
+  txFrequency: z.number().finite().int().min(1_000_000).max(1_000_000_000),
+});
+
+export type SetSplitFrequencyPayload = z.infer<typeof SetSplitFrequencyPayloadSchema>;
+
+export const WSSetSplitFrequencyMessageSchema = WSBaseMessageSchema.extend({
+  type: z.literal(WSMessageType.SET_SPLIT_FREQUENCY),
+  data: SetSplitFrequencyPayloadSchema,
+});
+
+export type WSSetSplitFrequencyMessage = z.infer<typeof WSSetSplitFrequencyMessageSchema>;
+
 // ===== 认证相关消息 =====
 
 /**
@@ -1291,6 +1766,20 @@ export const WSAuthPublicViewerMessageSchema = WSBaseMessageSchema.extend({
 
 export type WSAuthPublicViewerMessage = z.infer<typeof WSAuthPublicViewerMessageSchema>;
 
+export const WSAccessDeniedDataSchema = z.object({
+  reason: z.enum([
+    'capacity_reached',
+    'origin_not_allowed',
+    'authentication_timeout',
+    'handshake_timeout',
+    'ip_limit_reached',
+  ]),
+  current: z.number().int().nonnegative().optional(),
+  limit: z.number().int().positive().optional(),
+  retryAfterMs: z.number().int().nonnegative().optional(),
+});
+export type WSAccessDeniedData = z.infer<typeof WSAccessDeniedDataSchema>;
+
 /**
  * 认证结果（服务端到客户端）
  */
@@ -1378,12 +1867,23 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
   WSPongMessageSchema,
   // 服务端到客户端
   WSModeChangedMessageSchema,
+  WSSubscribeImageRxMessageSchema,
+  WSImageRadioStatusMessageSchema,
+  WSImageRxEventMessageSchema,
+  WSSstvTxStartMessageSchema,
+  WSSstvTxCancelMessageSchema,
+  WSSstvTxStatusMessageSchema,
+  WSSstvTxCommandResultMessageSchema,
+  WSFaxCalibrationSetMessageSchema,
+  WSFaxCalibrationResetMessageSchema,
+  WSFaxCalibrationCommandResultMessageSchema,
   WSSlotStartMessageSchema,
   WSSubWindowMessageSchema,
   WSSlotPackUpdatedMessageSchema,
   WSSpectrumCapabilitiesMessageSchema,
   WSSubscribeSpectrumMessageSchema,
   WSSpectrumSubscriptionChangedMessageSchema,
+  WSSpectrumViewportChangedMessageSchema,
   WSSpectrumFrameMessageSchema,
   WSSpectrumSessionStateChangedMessageSchema,
   WSInvokeSpectrumControlMessageSchema,
@@ -1408,11 +1908,18 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
   WSOperatorStatusUpdateMessageSchema,
   WSSetOperatorContextMessageSchema,
   WSSetOperatorRuntimeStateMessageSchema,
+  WSSetOperatorStreamStateMessageSchema,
+  WSInvokeOperatorStrategyActionMessageSchema,
   WSSetOperatorRuntimeSlotContentMessageSchema,
   WSSetOperatorTransmitCyclesMessageSchema,
   WSStartOperatorMessageSchema,
   WSStopOperatorMessageSchema,
   WSOperatorRequestCallMessageSchema,
+  WSOperatorQueueEnqueueMessageSchema,
+  WSOperatorQueueReorderMessageSchema,
+  WSOperatorQueueRetryMessageSchema,
+  WSOperatorQueueRemoveMessageSchema,
+  WSOperatorQueueClearMessageSchema,
   
   // 音量控制消息
   WSSetVolumeGainMessageSchema,
@@ -1422,6 +1929,8 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
   WSQSORecordAddedMessageSchema,
   WSQSORecordUpdatedMessageSchema,
   WSLogbookUpdatedMessageSchema,
+  WSLogbookHealthChangedMessageSchema,
+  WSLogbookWriteFailedMessageSchema,
   
   // 客户端启用操作员列表消息
   WSSetClientEnabledOperatorsMessageSchema,
@@ -1446,6 +1955,7 @@ export const WSMessageSchema = z.discriminatedUnion('type', [
 
   // 频率管理消息
   WSFrequencyChangedMessageSchema,
+  WSSetSplitFrequencyMessageSchema,
 
   // PTT状态管理消息
   WSPTTStatusChangedMessageSchema,
@@ -1498,6 +2008,7 @@ export type WSSlotPackUpdatedMessage = z.infer<typeof WSSlotPackUpdatedMessageSc
 export type WSSpectrumCapabilitiesMessage = z.infer<typeof WSSpectrumCapabilitiesMessageSchema>;
 export type WSSubscribeSpectrumMessage = z.infer<typeof WSSubscribeSpectrumMessageSchema>;
 export type WSSpectrumSubscriptionChangedMessage = z.infer<typeof WSSpectrumSubscriptionChangedMessageSchema>;
+export type WSSpectrumViewportChangedMessage = z.infer<typeof WSSpectrumViewportChangedMessageSchema>;
 export type WSSpectrumFrameMessage = z.infer<typeof WSSpectrumFrameMessageSchema>;
 export type WSSpectrumSessionStateChangedMessage = z.infer<typeof WSSpectrumSessionStateChangedMessageSchema>;
 export type WSInvokeSpectrumControlMessage = z.infer<typeof WSInvokeSpectrumControlMessageSchema>;
@@ -1515,13 +2026,33 @@ export type WSGetStatusMessage = z.infer<typeof WSGetStatusMessageSchema>;
 
 export const TransmitRequestSchema = z.object({
   operatorId: z.string(),
+  streamId: z.string().min(1).optional(),
   transmission: z.string(),
+  audioFrequencyHz: z.number().min(0).max(5000).optional(),
   /** 是否覆盖同一操作员在同一时隙的现有 TX 帧（自动重决策时为 true） */
   replaceExisting: z.boolean().optional(),
+  source: z.enum(['standard-qso', 'plugin', 'late-decode', 'operator-edit', 'manual']).optional(),
+  reason: z.string().optional(),
+  /** Host command epoch used to tombstone stale encode/mix callbacks. */
+  decisionEpoch: z.number().int().nonnegative().optional(),
 });
 
 export type TransmitRequest = z.infer<typeof TransmitRequestSchema>;
 
+export const TransmitBatchRequestSchema = z.object({
+  operatorId: z.string(),
+  transmissions: z.array(z.object({
+    streamId: z.string().min(1),
+    transmission: z.string(),
+    audioFrequencyHz: z.number().min(0).max(5000),
+  })).max(5),
+  replaceExisting: z.boolean().optional(),
+  source: z.enum(['standard-qso', 'plugin', 'late-decode', 'operator-edit', 'manual']).optional(),
+  reason: z.string().optional(),
+  decisionEpoch: z.number().int().nonnegative().optional(),
+});
+export type TransmitBatchRequest = z.infer<typeof TransmitBatchRequestSchema>;
+
 // ===== 前端应用事件接口 =====
 
 /**
@@ -1529,7 +2060,12 @@ export type TransmitRequest = z.infer<typeof TransmitRequestSchema>;
  */
 export const TransmissionCompleteInfoSchema = z.object({
   operatorId: z.string(),
+  streamId: z.string().optional(),
+  trackId: z.string().optional(),
   success: z.boolean(),
+  frameId: z.string().optional(),
+  physicalConfirmed: z.boolean().optional(),
+  terminalReason: z.string().optional(),
   duration: z.number().optional(),
   error: z.string().optional(),
   mixedWith: z.array(z.string()).optional(), // 与其他操作员混音的ID列表
@@ -1559,9 +2095,16 @@ export interface DigitalRadioEngineEvents {
 
   // 发射相关事件
   requestTransmit: (request: TransmitRequest) => void;
+  requestTransmitBatch: (request: TransmitBatchRequest) => void;
   transmissionComplete: (info: TransmissionCompleteInfo) => void;
   transmissionLog: (data: {
     operatorId: string;
+    streamId: string;
+    frameId: string;
+    revision: number;
+    playbackGeneration: number;
+    phase: 'on_air';
+    physicalConfirmed: true;
     time: string;
     message: string;
     frequency: number;
@@ -1584,7 +2127,7 @@ export interface DigitalRadioEngineEvents {
   // 连接事件
   connected: () => void;
   reconnecting: (data: { attempt: number; delayMs: number }) => void;
-  disconnected: () => void;
+  disconnected: (data?: WSAccessDeniedData) => void;
   handshakeComplete: (data: z.infer<typeof WSServerHandshakeCompleteMessageSchema>['data']) => void;
   connectionReplaced: (data: { reason: string }) => void;
   error: (error: Error) => void;
@@ -1598,6 +2141,11 @@ export interface DigitalRadioEngineEvents {
   // PTT状态控制事件
   pttStatusChanged: (data: PTTStatus) => void;
   tuneToneStatusChanged: (data: TuneToneStatus) => void;
+  imageRadioStatus: (data: ImageRadioStatus) => void;
+  imageRxEvent: (data: ImageRxEvent) => void;
+  sstvTxStatus: (data: SstvTxStatus) => void;
+  sstvTxCommandResult: (data: SstvTxCommandResult) => void;
+  faxCalibrationCommandResult: (data: FaxCalibrationCommandResult) => void;
 
   // 电台数值表事件
   meterData: (data: MeterData) => void;
@@ -1609,6 +2157,8 @@ export interface DigitalRadioEngineEvents {
   qsoRecordAdded: (data: { operatorId: string; logBookId: string; qsoRecord: z.infer<typeof QSORecordSchema> }) => void;
   qsoRecordUpdated: (data: { operatorId: string; logBookId: string; qsoRecord: z.infer<typeof QSORecordSchema> }) => void;
   logbookUpdated: (data: { logBookId: string; statistics: z.infer<typeof LogBookStatisticsSchema>; operatorId?: string }) => void;
+  logbookHealthChanged: (data: { logBookId: string; health: z.infer<typeof LogbookHealthSchema> }) => void;
+  logbookWriteFailed: (data: z.infer<typeof WSLogbookWriteFailedMessageSchema>['data']) => void;
   textMessage: (data: z.infer<typeof WSTextMessageSchema>['data']) => void;
 
   /** @deprecated Tuner state is now delivered via radioCapabilityChanged event (id='tuner_switch') */
@@ -1629,18 +2179,20 @@ export interface DigitalRadioEngineEvents {
 
   // Profile 管理事件
   profileChanged: (data: z.infer<typeof ProfileChangedEventSchema>) => void;
-  profileListUpdated: (data: { profiles: z.infer<typeof RadioProfileSchema>[]; activeProfileId: string | null }) => void;
+  profileListUpdated: (data: { profiles: z.infer<typeof RadioProfileSchema>[]; activeProfileId: string | null; hasConfiguredProfiles?: boolean }) => void;
   realtimeSettingsChanged: (data: RealtimeSettingsResponseData) => void;
 
   // 认证事件
   authRequired: (data: { allowPublicViewing: boolean }) => void;
   authResult: (data: { success: boolean; role?: UserRole; label?: string; operatorIds?: string[]; error?: string }) => void;
   authExpired: (data: { reason?: string }) => void;
+  accessDenied: (data: WSAccessDeniedData) => void;
 
   // 语音模式事件
   voicePttLockChanged: (data: VoicePTTLock) => void;
   voiceRadioModeChanged: (data: { radioMode: string }) => void;
   voiceKeyerStatusChanged: (data: VoiceKeyerStatus) => void;
+  androidOperatorAudioStatusChanged: (data: AndroidOperatorAudioStatus) => void;
 
   // CW 模式事件
   cwKeyerStatusChanged: (data: CWKeyerStatus) => void;
@@ -1693,10 +2245,46 @@ export interface DigitalRadioEngineEvents {
   transmitStart: (slotInfo: z.infer<typeof SlotInfoSchema>) => void;
   timingWarning: (data: { title: string; text: string }) => void;
   operatorSlotChanged: (data: { operatorId: string; slot: string }) => void;
+  operatorStreamStateChanged: (data: {
+    operatorId: string;
+    streamId: string;
+    state: string;
+    commandEpoch?: number;
+    source?: 'manual' | 'plugin' | 'late-decode' | 'slot-auto';
+  }) => void;
   operatorSlotContentChanged: (data: { operatorId: string; slot: string; content: string }) => void;
   operatorFrequencyChanged: (data: { operatorId: string; frequency: number }) => void;
-  operatorTransmitCyclesChanged: (data: { operatorId: string; transmitCycles: number[] }) => void;
-  recordQSO: (data: { operatorId: string; qsoRecord: z.infer<typeof QSORecordSchema> }) => void;
+  operatorTransmitCyclesChanged: (data: {
+    operatorId: string;
+    previousTransmitCycles?: number[];
+    transmitCycles: number[];
+    commandEpoch?: number;
+    source?: 'manual' | 'plugin' | 'late-decode' | 'slot-auto';
+    reason?: string;
+  }) => void;
+  qsoLifecycleChanged: (data: {
+    operatorId: string;
+    streamId?: string;
+    lifecycleEpoch: number;
+    runtimeGeneration?: number;
+  }) => void;
+  recordQSO: (data: {
+    operatorId: string;
+    streamId?: string;
+    qsoLifecycleId?: string;
+    qsoLifecycleEpoch?: number;
+    qsoRuntimeGeneration?: number;
+    qsoRecord: z.infer<typeof QSORecordSchema>;
+    persistencePolicy?: z.infer<typeof QSOPersistencePolicySchema>;
+    destination?:
+      | { kind: 'plugin-session'; sessionId: string }
+      | { kind: 'plugin-session-key'; sessionKey: string };
+    sourcePluginName?: string;
+    metadata?: Record<string, unknown>;
+    retryAttemptId?: string;
+    resolve?: (record: z.infer<typeof QSORecordSchema>) => void;
+    reject?: (error: unknown) => void;
+  }) => void;
   checkHasWorkedCallsign: (data: { operatorId: string; callsign: string; requestId: string }) => void;
   hasWorkedCallsignResponse: (data: { requestId: string; hasWorked: boolean }) => void;
 }