trunking

type ActiveCall struct {
	Device      *VoiceDevice
	Grant       Grant
	Talkgroup   *TalkGroup
	StartedAt   time.Time
	LastHeardAt time.Time
}

type Affiliation struct {
	System            string              // System name, matches trunking.System.Name
	Protocol          string              // "p25" / "dmr" / "nxdn"
	SourceID          uint32              // radio unit being affiliated
	GroupID           uint32              // talkgroup the unit is joining
	AnnouncementGroup uint32              // optional announcement-group association (0 if unused)
	Response          AffiliationResponse // accepted / failed / denied / refused
	At                time.Time
}

type AffiliationResponse uint8

type AffiliationTracker struct {
	// contains filtered or unexported fields
}

type AffiliationTrackerOptions struct {
	Bus *events.Bus
	// TTL is how long a unit stays in the table after it was last
	// seen. Default 30 minutes.
	TTL time.Duration
	// Now is injectable for tests; defaults to time.Now.
	Now func() time.Time
}

type Cache struct {
	// contains filtered or unexported fields
}

type CachedSystem struct {
	LastFrequencyHz uint32    `json:"last_frequency_hz"`
	LastLockAt      time.Time `json:"last_lock_at,omitempty"`
	NAC             uint16    `json:"nac,omitempty"`
}

type CallComplete struct {
	Grant        Grant
	Talkgroup    *TalkGroup
	DeviceSerial string
	StartedAt    time.Time
	EndedAt      time.Time
	Reason       EndReason
	AudioPath    string
	SampleRate   uint32
}

type CallEncryption struct {
	DeviceSerial     string
	System           string // filled in by the engine on republish
	Protocol         string
	GroupID          uint32
	AlgorithmID      uint8
	KeyID            uint16
	MessageIndicator [9]byte
	At               time.Time
}

type CallEnd struct {
	Grant        Grant
	Talkgroup    *TalkGroup
	DeviceSerial string
	StartedAt    time.Time
	EndedAt      time.Time
	Reason       EndReason
}

type CallSourceUpdate struct {
	DeviceSerial string
	System       string // filled in by the engine on republish
	Protocol     string
	GroupID      uint32 // filled in by the engine on republish from the bound Grant
	SourceID     uint32
	Encrypted    bool
	At           time.Time
}

type CallStart struct {
	Grant        Grant
	Talkgroup    *TalkGroup // resolved via the engine's TalkgroupDB; nil if unknown
	DeviceSerial string     // which Voice SDR is following the call
	StartedAt    time.Time
}

type EndReason uint8

type Engine struct {
	// contains filtered or unexported fields
}

type EngineOptions struct {
	Bus        *events.Bus
	Log        *slog.Logger
	VoicePool  *VoicePool
	Talkgroups *TalkgroupDB
	// CallTimeout is how long a call can run without a Touch before
	// the watchdog reaps it. Default 30 s. The end reason depends on
	// whether the call ever decoded frames: EndReasonNormal when
	// frames arrived and the carrier later dropped (P25's natural
	// end-of-call mechanism, since the CC has no explicit channel
	// release); EndReasonTimeout when no frames ever arrived (silent
	// decode failure).
	CallTimeout time.Duration
	// Now is injectable for tests; defaults to time.Now.
	Now func() time.Time
	// ScanMode controls whether HandleGrant respects the per-talkgroup
	// Scan flag. Default ScanModeAll keeps every non-locked-out grant
	// flowing through; ScanModeList enforces the talkgroup scan list.
	ScanMode ScanMode
}

type FrequencyChecker interface {
	CanTune(hz uint32) bool
}

type Grant struct {
	System      string // System name, matches trunking.System.Name
	Protocol    string // "p25" / "dmr" / "nxdn"
	GroupID     uint32 // talkgroup or destination subscriber address
	SourceID    uint32 // originator (subscriber unit)
	FrequencyHz uint32 // voice channel frequency
	ChannelID   uint8  // raw channel ID (P25 band-plan ID, DMR LCN high)
	ChannelNum  uint16 // raw channel number within the ID
	Encrypted   bool
	Emergency   bool
	// AlgorithmID and KeyID carry the encryption parameters the
	// protocol's privacy header advertises (the DMR PI header, etc.).
	// They are meaningful only when Encrypted is true and stay zero
	// until a privacy header has been parsed. Persisted to the call
	// log so an operator can see which key a recorded call needs.
	AlgorithmID uint8
	KeyID       uint16
	DataCall    bool // false = voice call (default)
	// ProVoice marks the grant as an EDACS ProVoice (digital) call. The
	// vocoder is patent + trade-secret encumbered so we cannot ship a
	// built-in decoder; the recorder treats this flag as a directive to
	// emit a `.raw` frame sidecar regardless of its global WriteRaw
	// setting, so researchers can decode out-of-band.
	ProVoice bool
	// PatchedGroups, when non-empty, lists the member talkgroups of a
	// patch / dynamic-regroup super-group: the call on GroupID is
	// physically the shared traffic of these groups. The engine fills
	// it from its PatchRegistry so the call can be attributed to every
	// member. Empty for an ordinary (non-patched) grant.
	PatchedGroups []uint32
	// P25Phase1DemodMode mirrors the system-level
	// trunking.System.P25Phase1DemodMode setting so the voice composer
	// can pick the matching symbol-recovery path on grants for the
	// system (C4FM vs CQPSK / LSM). The control-channel decoder
	// already honours the setting via the ccdecoder connector; without
	// this field every voice grant landed in a hardcoded C4FM voice
	// receiver and never decoded on LSM-modulated simulcast sites
	// (issue #356 follow-up). Populated by the protocol layer when it
	// publishes the grant; ignored for non-P25-Phase-1 grants.
	P25Phase1DemodMode string
	// P25Phase2Decode carries the per-channel FEC parameters the voice
	// composer's Phase 2 chain needs to decode MAC PDUs that
	// interleave with voice subframes on the traffic channel (talker
	// alias, in-call signalling). Populated by the Phase 2 control
	// channel when publishing the grant; zero on non-Phase-2 grants.
	P25Phase2Decode P25Phase2Decode
	At              time.Time
}

type HuntFailed struct {
	System    string    `json:"system"`
	At        time.Time `json:"at"`
	BackoffMs int       `json:"backoff_ms"`
}

type HuntProgress struct {
	System          string    `json:"system"`
	AttemptedFreqHz uint32    `json:"attempted_freq_hz"`
	AttemptIndex    int       `json:"attempt_index"`
	TotalCandidates int       `json:"total_candidates"`
	At              time.Time `json:"at"`
}

type Hunter struct {
	// contains filtered or unexported fields
}

type HunterOptions struct {
	System System
	Tuner  Tuner
	Bus    *events.Bus
	Cache  *Cache
	Log    *slog.Logger
	// Dwell is how long to wait on each candidate before giving up.
	// Defaults to 3 seconds.
	Dwell time.Duration
}

type Location struct {
	System     string  // trunking system name
	Protocol   string  // "p25", "dmr", ...
	RadioID    uint32  // reporting subscriber unit
	Talkgroup  uint32  // associated talkgroup; 0 when not call-associated
	Latitude   float64 // decimal degrees, positive north
	Longitude  float64 // decimal degrees, positive east
	SpeedKnots float64 // 0 when not reported
	HeadingDeg float64 // 0 when not reported
	At         time.Time
}

type LockResult struct {
	System    string
	Frequency uint32
	NAC       uint16
	At        time.Time
}

type LockedPayload interface {
	LockedFrequencyHz() uint32
	LockedNAC() uint16
}

type P25BandPlanEntry struct {
	ChannelID   uint8  // 0..15; matches the 4-bit IDEN_UP slot index
	BaseHz      uint64 // downlink base frequency for channel 0, Hz
	SpacingHz   uint32 // channel-to-channel step, Hz
	TxOffsetHz  int64  // signed uplink offset (uplink = downlink + offset), Hz
	BandwidthHz uint32 // informational; not consulted by BandPlan.Frequency
}

type P25Phase2Decode struct {
	Trellis    uint8
	RS         uint8
	Interleave uint8
	Scrambler  uint8
	Seed       uint64
}

type Patch struct {
	System     string
	Protocol   string
	SuperGroup uint32
	Members    []uint32
	Vendor     string
	Add        bool // true = patch now active, false = patch cancelled
	At         time.Time
}

type PatchGroup struct {
	SuperGroup uint32
	Members    []uint32
	Vendor     string // "motorola" | "harris"
	UpdatedAt  time.Time
}

type PatchRegistry struct {
	// contains filtered or unexported fields
}

type Protocol uint8

type RID struct {
	ID          uint32 `json:"id"`
	Alias       string `json:"alias"`
	Description string `json:"description,omitempty"`
	Tag         string `json:"tag,omitempty"`   // department / role
	Group       string `json:"group,omitempty"` // top-level grouping (agency)
	Owner       string `json:"owner,omitempty"` // operator/badge assigned to the radio
	Priority    int    `json:"priority,omitempty"`
	// Lockout marks the radio as stale / decommissioned / known-bad so
	// the UI can de-emphasise it. RIDs are not gated like talkgroups
	// today — Lockout is informational only.
	Lockout bool `json:"lockout,omitempty"`
	// Watch flags RIDs of operator interest so they can be surfaced in
	// a watch-list UI. Defaults to true on every loader so a plain
	// catalogue without a Watch column keeps every RID visible.
	Watch bool `json:"watch"`
	// Icon is an optional glyph identifier used by the operator UIs to
	// render a per-RID icon.
	Icon string `json:"icon,omitempty"`
}

type RIDDB struct {
	// contains filtered or unexported fields
}

type ReacquireFunc func(serial string) (Tuner, error)

type RegistrationResponse uint8

type ScanMode uint8

type System struct {
	Name            string
	Protocol        Protocol
	ControlChannels []uint32 // candidate CC frequencies in Hz
	WACN            uint32   // 20-bit Wide-Area Communication Network ID (P25)
	SystemID        uint16   // 12-bit system identifier (P25 SYSID)
	RFSS            uint8    // RF SubSystem ID (P25)
	Site            uint8    // Site ID

	// TETRAColourCode is the low 30 bits of the extended colour code
	// the TETRA scrambler uses to seed its LFSR per ETSI EN 300 392-2
	// §8.2.5 ("ec" in the spec). The ccdecoder connector forwards this
	// into tetra.ControlChannel.SetColourCode under ChannelCodingOn.
	// Zero is valid only for BSCH (§8.2.5.2). For all other channel
	// types the colour code is the per-cell secret the descrambler
	// needs to recover the type-3 stream — leaving it at zero with
	// channel coding on produces garbage. Bits 30..31 are silently
	// ignored downstream.
	TETRAColourCode uint32
	// TETRAChannel selects which TETRA logical channel lives in each
	// burst window under ChannelCodingOn. Recognised values:
	// "sch/hd" | "sch/f" | "sch/hu" | "bsch" | "aach" (case-insensitive,
	// "/" optional). Empty defaults to "sch/hd" — the most common
	// signaling carrier for cc.locked / Grant events. Forwarded into
	// tetra.ControlChannel.SetExpectedChannel by the ccdecoder
	// connector after parsing via tetra.ParseChannelType.
	TETRAChannel string
	// TETRAChannelCoding gates the full ETSI EN 300 392-2 §8.3.1
	// channel-coding chain (descramble + deinterleave + depuncture +
	// Viterbi + CRC-16 verify + tail strip). Recognised values
	// (case-insensitive): "" / "on" / "true" / "1" → ChannelCodingOn
	// (the new default; required for live on-air captures); "off" /
	// "false" / "0" → ChannelCodingOff (legacy raw-dibit path, opt-out
	// for operators feeding pre-stripped DSD-FME / OP25 fixtures).
	// Forwarded into tetra.ControlChannel.SetChannelCoding by the
	// ccdecoder connector after parsing via tetra.ParseChannelCoding.
	TETRAChannelCoding string

	// LTRFCSMode enables CRC-7 FCS verification on the LTR Status
	// Ingest path (per DSheirer/sdrtrunk's CRCLTR.java layout).
	// Recognised values (case-insensitive): "" / "on" / "true" / "1" →
	// FCSOn (the new default; drop Status words whose 7-bit FCS
	// trailer doesn't match the CRC over the 24-bit message vector);
	// "off" / "false" / "0" → FCSOff (no verification — opt-out for
	// pre-stripped fixtures). Forwarded into
	// ltr.ControlChannel.SetFCSMode by the ccdecoder connector after
	// parsing via ltr.ParseFCSMode.
	LTRFCSMode string
	// LTRManchesterMode controls Manchester decoding of the LTR
	// sub-audible bit stream. Recognised values (case-insensitive):
	// "" / "on" / "soft" → ManchesterSoft (the new default —
	// majority-decode each pair; matches the dominant on-air
	// encoding for sub-audible LTR signaling); "strict" —
	// require a mid-bit transition per pair, drop transition-less
	// pairs; "off" / "nrz" → ManchesterOff (raw NRZ — opt-out for
	// synthesized NRZ fixtures). Forwarded into
	// ltr.ControlChannel.SetManchesterMode by the ccdecoder
	// connector after parsing via ltr.ParseManchesterMode.
	LTRManchesterMode string

	// P25BandPlan seeds the Phase 1 receiver's BandPlan with operator-
	// supplied IdentifierUpdate entries before the decoder runs.
	// Useful for sites that don't broadcast an IDEN_UP TSBK for every
	// channel ID their grants reference (issue #345 — Mt Anakie
	// broadcasts grants on id=10 but never the matching IDEN_UP, so
	// the receiver has nothing to resolve the frequency against).
	// Over-the-air IDEN_UPs naturally override these via the same
	// BandPlan.Apply path; entries here are the floor, not the ceiling.
	// Ignored for non-P25-Phase-1 protocols.
	P25BandPlan []P25BandPlanEntry

	// P25Phase1DemodMode selects the symbol-recovery path for the
	// P25 Phase 1 receiver. Recognised values (case-insensitive):
	// "" / "c4fm" / "fm" → DemodC4FM (the default — FM
	// discriminator + 4-level slicer; matches every previously
	// shipping config and works on conventional non-simulcast P25
	// transmitters); "cqpsk" / "lsm" / "linear" → DemodCQPSK (the
	// linear / LSM path — complex RRC + Gardner + differential
	// QPSK; required for simulcast P25 deployments whose control
	// channel transmits Linear Simulcast Modulation rather than
	// straight C4FM, see issue #275 and TIA-102.BAAA). Forwarded
	// into p25phase1rx.Options.DemodMode by the ccdecoder connector
	// after parsing via p25phase1rx.ParseDemodMode.
	P25Phase1DemodMode string

	// P25Phase2TrellisMode enables the 4-state ½-rate trellis FEC
	// decoder on the P25 Phase 2 MAC PDU window. Recognised values
	// (case-insensitive): "" / "on" / "true" / "1" → TrellisOn (the
	// new default — 146 channel dibits via the TIA-102.AABF trellis
	// decoder); "off" / "false" / "0" → TrellisOff (legacy 72-dibit
	// raw-MAC-PDU path, opt-out for pre-stripped fixtures). Forwarded
	// into p25phase2.ControlChannel.SetTrellisMode by the ccdecoder
	// connector after parsing via p25phase2.ParseTrellisMode.
	P25Phase2TrellisMode string
	// P25Phase2RSMode enables the outer Reed-Solomon RS(24, 16, 9)
	// verification layer on top of the trellis-decoded MAC PDU.
	// Recognised values (case-insensitive): "" / "off" / "false" /
	// "0" → RSOff (the default — no outer RS verification; matches
	// historical decoder behaviour); "on" / "true" / "1" → RSOn
	// (verify RS syndromes per TIA-102.BAAA-A §5.9; drop MAC PDUs
	// whose syndromes are non-zero before parsing). Forwarded into
	// p25phase2.ControlChannel.SetRSMode by the ccdecoder connector
	// after parsing via p25phase2.ParseRSMode.
	P25Phase2RSMode string
	// P25Phase2InterleaveMode enables the TIA-102.BBAC per-burst block
	// deinterleaver applied to the MAC-burst dibits before trellis
	// decoding. Recognised values (case-insensitive): "" / "off" /
	// "false" / "0" → InterleaveOff (the default); "on" / "true" / "1"
	// → InterleaveOn. Forwarded into p25phase2.ControlChannel.
	// SetInterleaveMode by the ccdecoder connector after parsing via
	// p25phase2.ParseInterleaveMode.
	P25Phase2InterleaveMode string
	// P25Phase2ScramblerMode enables the PN44 descrambler per
	// TIA-102.BBAC-1 §7.2.5 on the trellis-decoded MAC PDU bits.
	// Recognised values (case-insensitive): "" / "on" / "true" /
	// "1" → ScramblerOn (the default — live Phase 2 traffic is
	// always scrambled); "off" / "false" / "0" → ScramblerOff
	// (opt-out for unscrambled fixtures). The seed is computed from
	// (WACN, SystemID, low 12 bits of Site as the spec's Color
	// Code = NAC) per spec equation (5). Forwarded into
	// p25phase2.ControlChannel.SetScramblerMode +
	// SetScramblerSeed by the ccdecoder connector.
	P25Phase2ScramblerMode string
	// P25Phase2ClockMode selects the symbol-timing-recovery strategy
	// for the P25 Phase 2 receiver. Recognised values (case-
	// insensitive): "" / "gardner" / "on" → ClockGardner (the new
	// default — non-data-aided Gardner loop; recommended for live
	// SDR captures); "naive" / "off" → ClockNaive (decimate every
	// sps-th sample; works on sample-aligned synthesized IQ).
	// Forwarded into p25phase2rx.Options.ClockMode by the ccdecoder
	// connector after parsing via p25phase2rx.ParseClockMode.
	P25Phase2ClockMode string
	// TETRAClockMode mirrors P25Phase2ClockMode for the TETRA
	// receiver. Same recognised values + parser semantics; the
	// underlying ClockMode enums in the two receivers share the
	// same name + values but are independent types.
	TETRAClockMode string
	// NXDNViterbiMode enables the K=5 ½-rate Viterbi FEC decoder
	// on the NXDN CAC region. Recognised values (case-insensitive):
	// "" / "spec" → ViterbiSpec (the new default — full NXDN-TS-1-A
	// §4.5.1.1 outbound CAC chain); "on" / "true" / "1" → ViterbiOn
	// (intermediate 92-dibit K=5 Viterbi path for older
	// MMDVMHost / DSDcc fixtures); "off" / "false" / "0" → ViterbiOff
	// (legacy 44-dibit raw-CAC path, opt-out for pre-stripped
	// fixtures). Forwarded into nxdn.ControlChannel.SetViterbiMode
	// by the ccdecoder connector after parsing via
	// nxdn.ParseViterbiMode.
	NXDNViterbiMode string
	// NXDNDeviationHz overrides the peak frequency deviation (Hz)
	// the NXDN receiver's slicer is calibrated against. Spec value
	// is 1800 Hz (matches the FM-discriminator output level so live
	// captures slice correctly out of the box). Operators with
	// on-air captures whose dibit distribution is bimodal (outer
	// ±3 dominate, inner ±1 underrepresented) can override here —
	// see samples/nxdn/README.md for the calibration recipe.
	// Forwarded into nxdnrx.Options.DeviationHz by the ccdecoder
	// connector; values <= 0 fall back to the spec default.
	NXDNDeviationHz float64
	// EDACSBCHMode enables the BCH(40, 28, 2) FEC layer on the
	// EDACS CCW. Recognised values (case-insensitive): "" / "on" /
	// "true" / "1" → BCHOn (the new default — 40-bit on-wire
	// BCH(40, 28, 2) decode + single/double-bit correction); "off" /
	// "false" / "0" → BCHOff (legacy pre-stripped 40-bit CCW path,
	// opt-out for pre-stripped fixtures). Forwarded into
	// edacs.ControlChannel.SetBCHMode by the ccdecoder connector
	// after parsing via edacs.ParseBCHMode.
	EDACSBCHMode string
	// MPT1327BCHMode enables the BCH(63, 38) FEC layer on the MPT
	// 1327 codeword. Recognised values (case-insensitive): "" /
	// "on" / "true" / "1" → BCHOn (the new default — 64-bit on-wire
	// BCH(63, 38) decode); "off" / "false" / "0" → BCHOff (legacy
	// 38-bit pre-stripped codeword path, opt-out for pre-stripped
	// fixtures). Forwarded into mpt1327.ControlChannel.SetBCHMode
	// by the ccdecoder connector after parsing via
	// mpt1327.ParseBCHMode.
	MPT1327BCHMode string
	// MPT1327CWSCTolerance sets the Hamming-distance threshold the
	// MPT 1327 Process adapter uses when matching the 16-bit
	// Codeword Synchronisation Code. Recognised values
	// (case-insensitive): "" → 2-bit tolerance (the new default,
	// matches commercial MPT 1327 receivers on noisy on-air
	// captures); "0" / "exact" / "off" → exact match (for
	// pre-stripped synthesized fixtures); a decimal integer in
	// [0, 15]. Forwarded into mpt1327.ControlChannel.SetCWSCTolerance
	// by the ccdecoder connector after parsing via
	// mpt1327.ParseCWSCTolerance.
	MPT1327CWSCTolerance string
	// MotorolaBCHMode enables the BCH(64, 16, 11) FEC layer on the
	// Motorola Type II OSW. Recognised values (case-insensitive):
	// "" / "on" / "true" / "1" → BCHOn (the new default — two
	// 64-bit BCH(64, 16, 11) codewords reassembled into the 32-bit
	// OSW, with up to 11 bit errors corrected per codeword); "off" /
	// "false" / "0" → BCHOff (legacy 32-bit raw-OSW path, opt-out
	// for pre-stripped fixtures). Forwarded into
	// motorola.ControlChannel.SetBCHMode by the ccdecoder
	// connector after parsing via motorola.ParseBCHMode.
	MotorolaBCHMode string
	// DStarFECMode enables the JARL DV-mode header FEC chain on the
	// D-STAR Process adapter. Recognised values (case-insensitive):
	// "" / "off" / "false" / "0" → FECOff (the default — reads 328
	// info bits straight off the wire, matches synthesized fixtures
	// + pre-FEC-stripped inputs); "on" / "true" / "1" → FECOn (660
	// on-wire bits → deinterleave 22×30 → PN15 descramble →
	// depuncture → K=5 R=1/2 Viterbi → 328 info bits → ParseHeader).
	// Forwarded into dstar.ControlChannel.SetFECMode by the
	// ccdecoder connector after parsing via dstar.ParseFECMode.
	DStarFECMode string
}

type TalkGroup struct {
	ID          uint32 `json:"id"`
	AlphaTag    string `json:"alpha_tag"`
	Description string `json:"description,omitempty"`
	Tag         string `json:"tag,omitempty"`      // department / category
	Group       string `json:"group,omitempty"`    // top-level group
	Mode        string `json:"mode,omitempty"`     // D=digital, A=analog, M=mixed
	Priority    int    `json:"priority,omitempty"` // 1 = highest, 10 = lowest, 0 = unset
	Lockout     bool   `json:"lockout,omitempty"`
	Scan        bool   `json:"scan"`
	// Stream gates whether completed calls on this talkgroup are
	// uploaded to the outbound broadcast aggregators
	// (internal/broadcast). Defaults to true on every loader so a
	// legacy CSV/JSON without a Stream column keeps streaming every
	// call; an explicit "no"/"false" in the CSV (or `"stream": false`
	// in JSON) opts a sensitive talkgroup out of all feeds.
	Stream bool `json:"stream"`
	// Record gates whether calls on this talkgroup are written to
	// disk by the per-call WAV recorder. Defaults to true on every
	// loader; an explicit "no"/"false" excludes a talkgroup from
	// recording (the call is still followed and played live).
	Record bool `json:"record"`
	// Mute, when true, suppresses this talkgroup's calls from the
	// live audio player — the call is still followed, recorded, and
	// streamed, just not played on the host's speakers. Defaults to
	// false (not muted).
	Mute bool `json:"mute,omitempty"`
	// Icon is an optional icon name assigned to this talkgroup, used
	// by the operator UIs to render a per-talkgroup glyph (the data
	// model behind SDRtrunk's Icon Manager). Empty = default icon.
	Icon string `json:"icon,omitempty"`
}

type TalkerAlias struct {
	System   string // System name, matches trunking.System.Name
	Protocol string // "p25-phase2"
	SourceID uint32 // radio unit the alias names
	Alias    string // the reassembled display name
	At       time.Time
}

type TalkgroupDB struct {
	// contains filtered or unexported fields
}

type Tuner interface {
	SetCenterFreq(hz uint32) error
}

type UnitActivity struct {
	RadioID   uint32 `json:"radio_id"`
	Talkgroup uint32 `json:"talkgroup"`
	System    string `json:"system"`
	Protocol  string `json:"protocol"`
	// Explicit is true when the association came from a decoded
	// affiliation message (P25 Group Affiliation Response); false when
	// it was observed from a voice-channel grant naming the unit as
	// the source. Both are ground truth — a grant proves the unit is
	// transmitting on that talkgroup — but the distinction is useful
	// in the UI.
	Explicit bool `json:"explicit"`
	// Registered is true once the unit has been seen in a unit
	// registration message.
	Registered bool      `json:"registered"`
	FirstSeen  time.Time `json:"first_seen"`
	LastSeen   time.Time `json:"last_seen"`
	// CallCount counts grants observed for this unit since it entered
	// the table — a simple "recurring radio" signal for the RID list
	// (issue #376).
	CallCount uint64 `json:"call_count"`
	// TalkerAlias is the most-recently-decoded over-the-air talker
	// alias for this unit (the radio's own display name), distinct
	// from any operator-assigned alias in the RIDDB.
	TalkerAlias   string    `json:"talker_alias,omitempty"`
	TalkerAliasAt time.Time `json:"talker_alias_at,omitempty"`
}

type UnitRegistration struct {
	System   string               // System name, matches trunking.System.Name
	Protocol string               // "p25" / "dmr" / "nxdn"
	SourceID uint32               // radio unit's WUID
	WACN     uint32               // 20-bit Wide Area Communications Network ID
	SystemID uint16               // 12-bit system identifier
	Response RegistrationResponse // accepted / failed / denied / refused
	At       time.Time
}

type VoiceDevice struct {
	Tuner  Tuner
	Serial string
}

type VoicePool struct {
	// contains filtered or unexported fields
}