aviation

type ADSBCallsign string

type ARINC424Result struct {
	Airports      map[string]FAAAirport
	Navaids       map[string]Navaid
	Fixes         map[string]Fix
	Airways       map[string][]Airway
	EnrouteHolds  map[string][]Hold
	TerminalHolds map[string]map[string][]Hold
}

type ARTCC = Facility

type ATCT TRACON

type ATISIntent struct {
	Letter string
}

type ATPAVolume struct {
	Id                  string `json:"id"`
	ThresholdString     string `json:"runway_threshold"`
	Threshold           math.Point2LL
	Heading             math.MagneticHeading `json:"heading"`
	MaxHeadingDeviation float32              `json:"max_heading_deviation"`
	Floor               float32              `json:"floor"`
	Ceiling             float32              `json:"ceiling"`
	Length              float32              `json:"length"`
	LeftWidth           float32              `json:"left_width"`
	RightWidth          float32              `json:"right_width"`
	FilteredScratchpads []string             `json:"filtered_scratchpads"`
	ExcludedScratchpads []string             `json:"excluded_scratchpads"`
	Enable25nmApproach  bool                 `json:"enable_2.5nm"`
	Dist25nmApproach    float32              `json:"2.5nm_distance"`
}

type AdaptationFix struct {
	Name         string // not in JSON
	Type         string `json:"type"`
	ToFacility   string `json:"to"`   // controller to handoff to
	FromFacility string `json:"from"` // controller to handoff from
	Altitude     [2]int `json:"altitude"`
}

type AdaptationFixes []AdaptationFix

type AircraftClass uint8

type AircraftPerformance struct {
	Name string `json:"name"`
	ICAO string `json:"icao"`
	// engines, weight class, category
	WeightClass string  `json:"weightClass"`
	Ceiling     float32 `json:"ceiling"`
	Engine      struct {
		// AircraftType is "P" for piston, "T" for turboprop, "J" for jet, and
		// "H" for rotorcraft.
		AircraftType string `json:"type"`
	} `json:"engines"`
	Rate struct {
		Climb      float32 `json:"climb"` // ft / minute; reduce by 500 after alt 5000 if this is >=2500
		Descent    float32 `json:"descent"`
		Accelerate float32 `json:"accelerate"` // kts / 2 seconds
		Decelerate float32 `json:"decelerate"`
	} `json:"rate"`
	Category struct {
		SRS   int    `json:"srs"`
		LAHSO int    `json:"lahso"`
		CWT   string `json:"cwt"`
	}
	Runway struct {
		Takeoff float32 `json:"takeoff"` // nm
		Landing float32 `json:"landing"` // nm
	} `json:"runway"`
	Speed struct {
		Min        float32 `json:"min"`
		V2         float32 `json:"v2"`
		Landing    float32 `json:"landing"`
		CruiseTAS  float32 `json:"cruise"`
		CruiseMach float32 `json:"cruiseM"`
		MaxTAS     float32 `json:"max"`
		MaxMach    float32 `json:"maxM"`
	} `json:"speed"`
	Turn struct {
		MaxBankAngle float32 `json:"maxBankAngle"`
		MaxBankRate  float32 `json:"maxBankRate"`
	}
	Capacity struct {
		Passengers int `json:"passengers"`
		FuelPounds int `json:"fuel_pounds"`
	} `json:"capacity"`
}

type AircraftTypeSnippetFormatter struct{}

type Airline struct {
	ICAO     string `json:"icao"`
	Name     string `json:"name"`
	Callsign struct {
		Name            string   `json:"name"`
		CallsignFormats []string `json:"callsignFormats"`
	} `json:"callsign"`
	JSONFleets map[string][][2]any `json:"fleets"`
	Fleets     map[string][]FleetAircraft
}

type AirlineSpecifier struct {
	ICAO          string   `json:"icao"`
	Callsign      string   `json:"callsign,omitempty"`
	Fleet         string   `json:"fleet,omitempty"`
	AircraftTypes []string `json:"types,omitempty"`
}

type Airport struct {
	Location       math.Point2LL
	TowerListIndex int `json:"tower_list"`

	Approaches map[string]*Approach `json:"approaches,omitempty"`
	// Departures is optional: an airport that only ever sees published
	// traffic needs no more than its "departure_routes" to fly it.
	Departures []Departure `json:"departures,omitempty"`

	VFR struct {
		Randoms VFRRandomsSpec `json:"random_routes"`
		Routes  []VFRRouteSpec `json:"routes"`
	} `json:"vfr"`

	// Optional: initial tracking controller, for cases where a virtual
	// controller has the initial track.
	DepartureController ControlPosition `json:"departure_controller"`
	HoldForRelease      bool            `json:"hold_for_release"`

	ExitCategories map[ExitID]string `json:"exit_categories"`

	// runway -> (exit -> routes)
	DepartureRoutes map[RunwayID]map[ExitID]ExitRoutes `json:"departure_routes"`

	// TrafficRoutes gives the routes published traffic between this airport
	// and specific other airports flies.
	TrafficRoutes TrafficRoutes `json:"traffic_routes"`

	CRDARegions map[string]*CRDARegion `json:"crda_regions"`
	CRDAPairs   []CRDAPair             `json:"crda_pairs"`

	ATPAVolumes           map[string]*ATPAVolume `json:"atpa_volumes"`
	OmitArrivalScratchpad bool                   `json:"omit_arrival_scratchpad"`
	DepartureRunwaysAsOne []string               `json:"departure_runways_as_one"`
}

type AirportPair struct {
	From, To string
}

type AirportPairRoute struct {
	Route        string // e.g. "NEION J223 CORDS J132 ULW BENEE"
	DepartureFix string // explicit for coded departure routes, empty otherwise
	Type         string // TEC, H, L, NAR, SHD, HSD, SLD, or CDR
	Aircraft     string // "jet", "prop", or empty for no restriction
	RNAVRequired bool
}

type AirportSnippetFormatter struct{}

type Airspace struct {
	Boundaries map[string][]math.Point2LL            `json:"boundaries"`
	Volumes    map[string][]ControllerAirspaceVolume `json:"volumes"`
}

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

type AirspaceVolume struct {
	Id          string             `json:"id"`
	Description string             `json:"description"`
	Type        AirspaceVolumeType `json:"type"`
	Floor       int                `json:"floor"`
	Ceiling     int                `json:"ceiling"`
	// Polygon
	PolygonBounds *math.Extent2D               // not always set
	VerticesStr   util.OneOf[string, []string] `json:"vertices"`
	Vertices      []math.Point2LL
	Holes         [][]math.Point2LL `json:"holes"`
	// Circle
	Center math.Point2LL `json:"center"`
	Radius float32       `json:"radius"`
}

type AirspaceVolumeType int

type Airway struct {
	Name  string
	Fixes []AirwayFix
}

type AirwayDirection int

type AirwayFix struct {
	Fix       string
	Level     AirwayLevel
	Direction AirwayDirection
}

type AirwayLevel int

type AltRestrictionSnippetFormatter struct{}

type AltSnippetFormatter struct{}

type AltitudeDirection int

type AltitudeIntent struct {
	Altitude          float32
	Direction         AltitudeDirection
	AfterFix          string   // altitude change conditional on passing this fix
	AfterSpeed        *float32 // changing altitude only after reaching a speed
	Expedite          bool
	GoodRate          bool
	RateThrough       *float32 // "through/to" altitude for expedite or good rate
	AlreadyExpediting bool
	ThenSpeed         *float32 // speed once we reach the altitude
	ThenSpeedType     SpeedType
}

type AltitudeRestriction struct {
	NavigationRestriction
}

type AppControllerSnippetFormatter struct{}

type Approach struct {
	Id        string          `json:"cifp_id"`
	FullName  string          `json:"full_name"`
	Type      ApproachType    `json:"type"`
	Runway    string          `json:"runway"`
	Waypoints []WaypointArray `json:"waypoints"`

	// Set in Airport PostDeserialize()
	Threshold         math.Point2LL
	OppositeThreshold math.Point2LL
}

type ApproachIntent struct {
	Type         ApproachIntentType
	ApproachName string // full name of the approach (e.g., "ILS Runway 22L")
	Fix          string // for AtFixCleared
	LAHSORunway  string // runway to hold short of (for LAHSO operations)
	HasLocalizer bool
	StraightIn   bool
}

type ApproachIntentType int

type ApproachSnippetFormatter struct{}

type ApproachType int

type Arrival struct {
	Waypoints       WaypointArray                       `json:"waypoints"`
	RunwayWaypoints map[string]map[string]WaypointArray `json:"runway_waypoints"` // Airport -> runway -> waypoints
	SpawnWaypoint   string                              `json:"spawn"`            // if "waypoints" aren't specified
	CruiseAltitudes util.SingleOrArray[int]             `json:"cruise_altitude"`
	STAR            string                              `json:"star"`

	// STARFeeds are the STARs whose traffic the arrival takes; this is useful e.g. for getting
	// real-world traffic wired up for finals scenarios since we generally get traffic after they've
	// flown STARs in that case.
	STARFeeds []string `json:"star_feeds"`

	// Note: this is *only* used for flight strips displayed to the user; it should not in any way
	// be referenced for an aircraft's route: Waypoints should always be used for that.
	FlightStripDisplayRoute string `json:"route"`

	// DerivedSTAR is the STAR the arrival's waypoints run along, worked out at
	// load for an arrival that spells them out instead of naming a STAR to take
	// them from. Not specified in user JSON.
	DerivedSTAR string

	InitialController   ControlPosition         `json:"initial_controller"`
	InitialAltitudes    util.SingleOrArray[int] `json:"initial_altitude"`
	AssignedAltitude    float32                 `json:"assigned_altitude"`
	ClearedAltitude     float32                 `json:"cleared_altitude"`
	InitialSpeed        float32                 `json:"initial_speed"`
	SpeedRestriction    SpeedRestriction        `json:"speed_restriction"`
	Scratchpad          string                  `json:"scratchpad"`
	SecondaryScratchpad string                  `json:"secondary_scratchpad"`
	Description         string                  `json:"description"`
	CoordinationFix     string                  `json:"coordination_fix"`
	IsRNAV              bool                    `json:"is_rnav"`

	// Aircraft restricts which types of flights the arrival carries; it's
	// used when selecting arrivals with real-world traffic.
	Aircraft AircraftClass `json:"aircraft,omitempty"`

	ExpectApproach util.OneOf[string, map[string]string] `json:"expect_approach"`

	// Airports the arrival brings traffic to, in sorted order. Required,
	// except for an arrival that names a STAR the FAA CIFP charts for some of
	// the scenario's airports: it takes those. Every airport in Airlines must
	// be named here.
	Airports []string `json:"airports"`

	// Airport -> arrival airlines. Optional: without it the scenario can't
	// generate its own arrivals here, but published traffic still can.
	Airlines map[string][]ArrivalAirline `json:"airlines"`
}

type ArrivalAirline struct {
	AirlineSpecifier
	Airport string `json:"airport"`
}

type BasicNumberSnippetFormatter struct{}

type BeaconCodeSnippetFormatter struct{}

type BeaconCodeTable struct {
	VFRCodes [][2]Squawk
}

type BeaconCodeTableSpecifier struct {
	VFRCodes []string `json:"vfr_codes"` // Array of squawk code ranges

}

type CRDAPair struct {
	SourceRegion             string  `json:"source_region"`
	GhostRegion              string  `json:"ghost_region"`
	SourceLeaderDirectionStr string  `json:"source_leader_direction"`
	GhostLeaderDirectionStr  string  `json:"ghost_leader_direction"`
	TieSymbol                string  `json:"tie_symbol"`
	StaggerSymbol            string  `json:"stagger_symbol"`
	TieOffset                float32 `json:"tie_offset"`

	// Set during deserialize.
	SourceLeaderDirection math.CardinalOrdinalDirection
	GhostLeaderDirection  math.CardinalOrdinalDirection
	ConvergencePoint      math.Point2LL
}

type CRDARegion struct {
	Name             string  // set during deserialization from map key
	HeadingTolerance float32 `json:"heading_tolerance"`

	// Straight-line reference (mutually exclusive with ReferenceRoute)
	ReferenceLineHeading   math.MagneticHeading `json:"reference_heading"`
	ReferenceLineLength    float32              `json:"reference_length"`
	ReferencePointAltitude float32              `json:"reference_altitude"`
	ReferencePoint         math.Point2LL        `json:"reference_point"`

	// Route-based reference (mutually exclusive with straight-line fields)
	ReferenceRoute string `json:"reference_route"`

	// lateral qualification region
	NearDistance  float32 `json:"near_distance"`
	NearHalfWidth float32 `json:"near_half_width"`
	FarHalfWidth  float32 `json:"far_half_width"`
	RegionLength  float32 `json:"region_length"`

	// vertical qualification region
	DescentPointDistance   float32 `json:"descent_distance"`
	DescentPointAltitude   float32 `json:"descent_altitude"`
	AboveAltitudeTolerance float32 `json:"above_altitude_tolerance"`
	BelowAltitudeTolerance float32 `json:"below_altitude_tolerance"`

	ScratchpadPatterns []string `json:"scratchpad_patterns"`

	// Computed during PostDeserialize
	Path              Path
	DistToConvergence float32 // distance from path end to convergence point
}

type CRDARoutePoint struct {
	Fix      string
	Location math.Point2LL
	Arc      *DMEArc
}

type CallsignArg struct {
	Callsign           ADSBCallsign
	IsEmergency        bool
	AlwaysFullCallsign bool
}

type CallsignSnippetFormatter struct{}

type CautionWakeTurbulenceIntent struct{}

type ClearedApproachIntent struct {
	Approach    string
	StraightIn  bool
	CancelHold  bool
	LAHSORunway string
}

type CommandIntent interface {
	// Render adds the appropriate text for this intent to the transmission.
	Render(rt *RadioTransmission, r *rand.Rand)
}

type CompoundSpeedIntent struct {
	Segments []CompoundSpeedSegment
}

type CompoundSpeedSegment struct {
	Speed    *SpeedRestriction
	UntilFix string // empty for last (open-ended) segment
}

type ContactIntent struct {
	Type         ContactType
	ToController *Controller // the controller being contacted
	Frequency    Frequency
	IsDeparture  bool // affects rendering (departure vs approach controller)
}

type ContactTowerIntent struct {
	Frequency Frequency
}

type ContactType int

type ControlPosition string

type Controller struct {
	Position           string    // This is the key in the controllers map in JSON (now the sector ID, e.g. "1N", "4P")
	Callsign           string    `json:"callsign,omitempty"` // Human-readable callsign (e.g. "PHL_NA_APP")
	RadioName          string    `json:"radio_name"`
	Frequency          Frequency `json:"frequency"`
	Scope              string    `json:"scope_char"`     // Optional. If unset, facility id is used for external, last char of position for local.
	FacilityIdentifier string    `json:"-"`              // Set programmatically by loadNeighborControllers (e.g. "N" in "N4P")
	ERAMFacility       bool      `json:"-"`              // Set at runtime from facility type; true for ARTCC controllers
	Facility           string    `json:"facility"`       // So we can get the STARS facility from a controller
	Area               string    `json:"area,omitempty"` // For TRACON: auto-derived from first digit of Position. For ERAM: must be manually specified.
}

type ControllerAirspaceVolume struct {
	LowerLimit    int               `json:"lower"`
	UpperLimit    int               `json:"upper"`
	Boundaries    [][]math.Point2LL `json:"boundary_polylines"` // not in JSON
	BoundaryNames []string          `json:"boundaries"`
	Label         string            `json:"label"`
	LabelPosition math.Point2LL     `json:"label_position"`
}

type DMEArc struct {
	Fix            string
	Center         math.Point2LL
	Radius         float32
	Length         float32
	InitialHeading math.MagneticHeading
	Direction      DMEArcDirection
}

type DMEArcDirection int

type DMELocator interface {
	LocateDME(fix string) (math.Point2LL, int, bool)
}

type DepControllerSnippetFormatter struct{}

type Departure struct {
	Exit ExitID `json:"exit"`

	Destination    string                  `json:"destination"`
	Altitudes      util.SingleOrArray[int] `json:"altitude,omitempty"`
	Route          string                  `json:"route"`
	RouteWaypoints WaypointArray           // not specified in user JSON
	// Airlines is optional: without it the scenario can't generate its own
	// departures here, but published traffic still flies the exit and route.
	Airlines            []DepartureAirline `json:"airlines"`
	Scratchpad          string             `json:"scratchpad"`           // optional
	SecondaryScratchpad string             `json:"secondary_scratchpad"` // optional
	Description         string             `json:"description"`
}

type DepartureAirline struct {
	AirlineSpecifier
}

type ERAMAdaptation struct {
	ARTCC             string                     // not in JSON
	CoordinationFixes map[string]AdaptationFixes `json:"coordination_fixes"`
}

type ERAMMap struct {
	LabelLine1 string
	LabelLine2 string

	Lines   []MapLine
	Symbols []MapSymbol
	Labels  []MapLabel
}

type ERAMMapGroup struct {
	Name       string
	LabelLine1 string
	LabelLine2 string
	BCGNames   []string // BCGs in source order; per feature BCGIndex references this.
	Maps       []ERAMMap

	// BaseMap is drawn whenever this group is loaded: the geometry can't be toggled off and
	// consumes no filter-menu slot. BCGIndex resolves against BCGNames as for any other map.
	BaseMap ERAMMap
}

type EnrouteSquawkCodePool struct {
	Available *util.IntRangeSet

	// Initial is maintained as a read-only snapshot of the initial set of
	// available codes; it allows us to catch cases where the caller tries
	// to return code that is inside the range we cover but was removed
	// from the pool when it was first initialized.
	Initial *util.IntRangeSet
}

type ExitID string

type ExitRoute struct {
	SID              string        `json:"sid"`
	AssignedAltitude int           `json:"assigned_altitude"`
	ClearedAltitude  int           `json:"cleared_altitude"`
	Waypoints        WaypointArray `json:"waypoints"`
	Description      string        `json:"description"`
	IsRNAV           bool          `json:"is_rnav"`
	HoldForRelease   bool          `json:"hold_for_release"`
	// optional, control position to handoff to at a /ho
	HandoffController ControlPosition `json:"handoff_controller"`
	// optional, the initial tracking controller for the departure.
	DepartureController ControlPosition `json:"departure_controller"`

	// Aircraft restricts which types of flights take the route; it's used
	// when an exit routes them differently.
	Aircraft AircraftClass `json:"aircraft,omitempty"`

	WaitToContactDeparture bool // whether the aircraft waits until a /TC point to contact departure
}

type ExitRoutes []*ExitRoute

type FAAAirport struct {
	Id         string
	Name       string
	Country    string
	Elevation  int
	Location   math.Point2LL
	Runways    []Runway
	Approaches map[string]Approach
	STARs      map[string]STAR
	ARTCC      string
}

type Facility struct {
	Name      string
	Latitude  float32
	Longitude float32
	Radius    float32
}

type Fix struct {
	Id       string
	Location math.Point2LL
}

type FixSnippetFormatter struct{}

type FleetAircraft struct {
	ICAO  string
	Count int
}

type Flight struct {
	Airport      string // the facility airport it departs from or arrives at
	Callsign     string
	Other        string // the airport at the other end
	AircraftType string
	Day          uint16 // UTC date, in days from 1970-01-01
	Minute       int    // minutes after UTC midnight
	Departure    bool
}

type FlightPlan struct {
	Rules            FlightRules
	AircraftType     string
	CruiseSpeed      int
	DepartureAirport string
	DepartureRunway  string
	Altitude         int
	ArrivalAirport   string
	AlternateAirport string
	Exit             ExitID
	Route            string
	Remarks          string
}

type FlightRules int

type Frequency int

type FrequencySnippetFormatter struct{}

type GACallsignArg struct {
	Callsign     ADSBCallsign
	AircraftType string // e.g., "C172"
	UseTypeForm  bool   // If true, use type+trailing3 form
	IsEmergency  bool
}

type GhostTrack struct {
	ADSBCallsign        ADSBCallsign
	Position            math.Point2LL
	Groundspeed         int
	LeaderLineDirection math.CardinalOrdinalDirection
	TrackId             string
}

type GroupFormSnippetFormatter struct{}

type HeadingIntent struct {
	Heading    math.MagneticHeading
	Type       HeadingType
	Turn       HeadingTurn // for HeadingAssign: which way to turn
	Degrees    int         // for HeadingTurnLeft/Right: how many degrees
	CancelHold bool        // heading cancels an active hold
}

type HeadingSnippetFormatter struct{}

type HeadingTurn int

type HeadingType int

type Hold struct {
	Fix             string               // Fix identifier where hold is located
	InboundCourse   math.MagneticHeading // Inbound magnetic course to the fix
	TurnDirection   TurnDirection
	LegLengthNM     float32 // Distance-based leg length (nautical miles), 0 if time-based
	LegMinutes      float32 // Time-based leg duration (minutes), 0 if distance-based
	MinimumAltitude int     // Minimum altitude for hold (feet)
	MaximumAltitude int     // Maximum altitude for hold (feet), 0 if no maximum
	HoldingSpeed    int     // Speed limit in hold (knots), 0 if not specified
	Procedure       string  // Associated procedure (e.g., "ILS06 (IAP)", "CAMRN5", "ENROUTE HIGH")
}

type HoldEntry int

type HourRanges uint32

type InboundFlow struct {
	Arrivals    []Arrival    `json:"arrivals"`
	Overflights []Overflight `json:"overflights"`
}

type LetterSnippetFormatter struct{}

type LineStyle uint8

type LocalPool struct {
	Initial     *util.IntRangeSet
	Available   *util.IntRangeSet
	Ranges      [][2]Squawk
	Backups     string
	FlightRules FlightRules
}

type LocalSquawkCodePool struct {
	Pools           map[string]LocalPool
	BeaconCodeTable BeaconCodeTable
}

type LocalSquawkCodePoolSpecifier struct {
	Pools           map[string]PoolSpecifier `json:"auto_assignable_codes"`
	BeaconCodeTable BeaconCodeTableSpecifier `json:"beacon_code_table"`
}

type Locator interface {
	// Locate returns the lat-long coordinates of the named point if they
	// are available; the bool indicates whether the point was known.
	Locate(fix string) (math.Point2LL, bool)

	// If Locate fails, Similar can be called to get alternatives that are
	// similarly-spelled to be offered in error messages.
	Similar(fix string) []string
}

type LookForFieldIntent int

type MVA struct {
	MinimumLimit          int                      `xml:"minimumLimit"`
	MinimumLimitReference string                   `xml:"minimumLimitReference"`
	Proj                  *MVAHorizontalProjection `xml:"horizontalProjection"`
	Bounds                math.Extent2D
	ExteriorRing          [][2]float32
	InteriorRings         [][][2]float32
}

type MVAExterior struct {
	LinearRing MVALinearRing `xml:"LinearRing"`
}

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

type MVAHorizontalProjection struct {
	Surface MVASurface `xml:"Surface"`
}

type MVAInterior struct {
	LinearRing MVALinearRing `xml:"LinearRing"`
}

type MVALinearRing struct {
	PosList string `xml:"posList"`
}

type MVAPatches struct {
	PolygonPatch MVAPolygonPatch `xml:"PolygonPatch"`
}

type MVAPolygonPatch struct {
	Exterior  MVAExterior   `xml:"exterior"`
	Interiors []MVAInterior `xml:"interior"`
}

type MVASurface struct {
	Patches MVAPatches `xml:"patches"`
}

type MachSnippetFormatter struct{}

type MagneticGrid struct {
	MinLatitude, MaxLatitude   float32
	MinLongitude, MaxLongitude float32
	LatLongStep                float32
	Samples                    []float32
}

type MapLabel struct {
	P         math.Point2LL
	Text      string
	Size      uint8
	XOffset   int8
	YOffset   int8
	Underline bool
	Opaque    bool
	BCGIndex  uint8 // 0 = use the map's group BCG
}

type MapLibrary struct {
	Maps          map[string]STARSMap
	ERAMMapGroups map[string]ERAMMapGroup
}

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

type MapLine struct {
	Points    []math.Point2LL
	Style     LineStyle
	Thickness uint8
	BCGIndex  uint8 // 0 = use the map's group BCG
}

type MapSymbol struct {
	P        math.Point2LL
	Style    SymbolStyle
	Size     uint8
	BCGIndex uint8 // 0 = use the map's group BCG
}

type MixUpIntent struct {
	Callsign    ADSBCallsign
	IsEmergency bool
}

type Navaid struct {
	Id       string
	Type     string
	Name     string
	Location math.Point2LL

	HasDME          bool
	DMELocation     math.Point2LL
	DMEElevation    int
	HasDMEElevation bool
}

type NavigationIntent struct {
	Type             NavigationType
	Fix              string
	SecondFix        string                        // for DepartFixDirect
	Heading          math.MagneticHeading          // for DepartFixHeading
	Turn             TurnDirection                 // for NavDirectFix / NavDirectFixFromHold
	HoldDirection    string                        // "left" or "right" for holds
	HoldLegLength    string                        // e.g., "2 mile" or "1 minute"
	AltRestriction   *AltitudeRestriction          // for Cross{FixAt,DistanceFromFixAt,DME}
	SpeedRestriction *SpeedRestriction             // for Cross{FixAt,DistanceFromFixAt,DME}
	Distance         float32                       // for Cross{DistanceFromFixAt,DME}
	Direction        math.CardinalOrdinalDirection // for CrossDistanceFromFixAt
}

type NavigationRestriction struct {
	Range [2]float32
}

type NavigationType int

type Overflight struct {
	Waypoints           WaypointArray           `json:"waypoints"`
	InitialAltitudes    util.SingleOrArray[int] `json:"initial_altitude"`
	CruiseAltitudes     util.SingleOrArray[int] `json:"cruise_altitude"`
	AssignedAltitude    float32                 `json:"assigned_altitude"`
	InitialSpeed        float32                 `json:"initial_speed"`
	AssignedSpeed       float32                 `json:"assigned_speed"`
	SpeedRestriction    SpeedRestriction        `json:"speed_restriction"`
	InitialController   ControlPosition         `json:"initial_controller"`
	Scratchpad          string                  `json:"scratchpad"`
	SecondaryScratchpad string                  `json:"secondary_scratchpad"`
	Description         string                  `json:"description"`
	IsRNAV              bool                    `json:"is_rnav"`
	Airlines            []OverflightAirline     `json:"airlines"`
	TypeOfFlightString  string                  `json:"flight_type"`
	TypeOfFlight        TypeOfFlight            // set via TypeOfFlightString
}

type OverflightAirline struct {
	AirlineSpecifier
	DepartureAirport string `json:"departure_airport"`
	ArrivalAirport   string `json:"arrival_airport"`
}

type PTType int

type Path struct {
	Segments []PathSegment
	Length   float32
}

type PathArc struct {
	Center     [2]float32
	Radius     float32
	StartAngle float32 // angle from center to P0 (radians)
	Sweep      float32 // signed: positive=CCW, negative=CW
}

type PathSegment struct {
	P0, P1    [2]float32 // start/end in NM coordinates
	Arc       *PathArc   // nil for straight segments
	StartDist float32    // cumulative distance at segment start
	Length    float32    // segment length
}

type PhraseFormatString string

type PoolSpecifier struct {
	Ranges  []string `json:"ranges"`
	Rules   string   `json:"flight_rules"`
	Backups string   `json:"backup_pool_list"`
}

type ProcedureIntent struct {
	Type ProcedureType
}

type ProcedureTurn struct {
	Type         PTType
	RightTurns   bool
	ExitAltitude int     `json:",omitempty"`
	MinuteLimit  float32 `json:",omitempty"`
	NmLimit      float32 `json:",omitempty"`
	Entry180NoPT bool    `json:",omitempty"`
}

type ProcedureType int

type RadarSite struct {
	Char           string        `json:"char"`
	PositionString string        `json:"position"`
	Position       math.Point2LL // not in JSON, set during deserialize

	Elevation      int32   `json:"elevation"`
	PrimaryRange   int32   `json:"primary_range"`
	SecondaryRange int32   `json:"secondary_range"`
	SlopeAngle     float32 `json:"slope_angle"`
	SilenceAngle   float32 `json:"silence_angle"`
}

type RadarTrack struct {
	ADSBCallsign        ADSBCallsign
	Squawk              Squawk
	Mode                TransponderMode
	Ident               bool
	TrueAltitude        float32
	TransponderAltitude float32
	Location            math.Point2LL
	Heading             math.MagneticHeading
	Groundspeed         float32
	TypeOfFlight        TypeOfFlight
}

type RadioTransmission struct {
	Strings []PhraseFormatString
	Args    [][]any // each slice contains values passed to the corresponding PhraseFormatString
	Type    RadioTransmissionType
}

type RadioTransmissionType int

type ReportAltitudeIntent struct {
	Current   float32
	Assigned  *float32
	Direction AltitudeDirection // if climbing/descending
}

type ReportHeadingIntent struct {
	Current  math.MagneticHeading
	Assigned *math.MagneticHeading
}

type ReportMachIntent struct {
	Current  float32  // current mach (e.g., 0.78)
	Assigned *float32 // assigned mach, if any
}

type ReportSpeedIntent struct {
	Current  float32
	Assigned *float32
}

type ReportingPoint struct {
	Fix      string
	Location math.Point2LL
}

type RestrictionArea struct {
	Title        string        `json:"title"`
	Text         [2]string     `json:"text"`
	BlinkingText bool          `json:"blinking_text"`
	HideId       bool          `json:"hide_id"`
	TextPosition math.Point2LL `json:"text_position"`
	CircleCenter math.Point2LL `json:"circle_center"`
	CircleRadius float32       `json:"circle_radius"`
	VerticesUser WaypointArray `json:"vertices"`
	Vertices     [][]math.Point2LL
	Closed       bool `json:"closed"`
	Shaded       bool `json:"shade_region"`
	Color        int  `json:"color"`

	Tris [][3]math.Point2LL
}