@dgac/nmb2b-client/dist/Flow/types.d.mts

EUROCONTROL Network Manager B2B SOAP client

import { AirNavigationUnitId, B2BRequest, Dataset, DateTimeMinute, DateTimeMinutePeriod, DateTimeSecond, DateYearMonthDay, DistanceM, DurationHourMinute, NMMap, NMSet, PlanDataId, ReplyWithData, UserId } from "../Common/types.mjs";
import { AerodromeICAOId, AirspaceId, FlightLevelRange, ReferenceLocation, RunwayId, TrafficVolumeId, TrafficVolumeIdWildcard, TrafficVolumeSetId, TrafficVolumeSetIdWildcard, WithReferenceLocationOnPrefix, WithReferenceLocationOnPrefixOptional } from "../Airspace/types.mjs";
import { FlightKeys, GroupReroutingIndicator, IFPLId, TrafficType } from "../Flight/types.mjs";

//#region src/Flow/types.d.ts
type ReroutingId = string;
type RegulationId = string;
type MeasureId = {
  REGULATION: RegulationId;
} | {
  REROUTING: ReroutingId;
};
type FlowId = string;
type ScenarioId = string;
type SectorConfigurationId = string;
type PlanDataSource = 'AIRSPACE' | 'MEASURE' | 'NO_DATA' | 'TACTICAL';
type RegulationIdWildcard = string;
type FlightRegulationLocation = WithReferenceLocationOnPrefix<'referenceLocation'> & {
  regulationId: RegulationId;
  toConfirm: boolean;
};
type FlightAtfcmMeasureLocationCommon = WithReferenceLocationOnPrefixOptional<'referenceLocation'> & {
  measureSubType: MeasureSubType;
  hotspotId?: HotspotId;
  mcdmState?: MCDMState;
};
type FlightAtfcmRegulationLocation = {
  FlightAtfcmRegulationLocation: FlightAtfcmMeasureLocationCommon & {
    regulationId: RegulationId;
    toConfirm: boolean;
  };
};
type FlightAtfcmReroutingLocation = {
  FlightAtfcmReroutingLocation: FlightAtfcmMeasureLocationCommon & {
    reroutingId: ReroutingId;
    reroutingApplyKind: ReroutingApplyKind;
    groupReroutingIndicator: GroupReroutingIndicator;
    reroutingPurpose: ReroutingPurpose;
    requestText?: null | string;
    originatorLatestReroutingProposalFlight: boolean;
  };
};
type ReroutingApplyKind = 'EXECUTE' | 'FOR_INDICATION_WITHOUT_AUTOMATIC_PROPOSAL_FLIGHT' | 'FOR_INDICATION_WITH_AUTOMATIC_RRP' | 'FOR_INDICATION_WITH_AUTOMATIC_RRN';
type ReroutingPurpose = 'ATFCM' | 'FLIGHT_EFFICIENCY' | 'STAM' | 'AOLO_REROUTING' | 'ATC_ROUTING' | 'CDR_OPPORTUNITY';
type FlightAtfcmMeasureLocation = FlightAtfcmRegulationLocation | FlightAtfcmReroutingLocation;
interface RegulationCause {
  reason: RegulationReason;
  locationCategory: RegulationLocationCategory;
  iataDelayCode: number;
}
type RegulationLocationCategory = 'ARRIVAL' | 'DEPARTURE' | 'ENROUTE';
type RegulationReason = 'ACCIDENT_INCIDENT' | 'AERODROME_CAPACITY' | 'AERODROME_SERVICES' | 'AIRSPACE_MANAGEMENT' | 'ATC_CAPACITY' | 'ATC_EQUIPMENT' | 'ATC_INDUSTRIAL_ACTION' | 'ATC_ROUTINGS' | 'ATC_STAFFING' | 'ENVIRONMENTAL_ISSUES' | 'NON_ATC_INDUSTRIAL_ACTION' | 'OTHERS' | 'SPECIAL_EVENT' | 'WEATHER';
interface FlightHotspotLocation {
  hotspot: Hotspot;
  referenceLocation: ReferenceLocation;
}
interface Hotspot {
  hotspotId: HotspotId;
  severity: HotspotSeverity;
  status: HotspotStatus;
  remark?: string;
  trafficVolumeDescription?: string;
}
type HotspotSeverity = 'HIGH' | 'LOW' | 'MEDIUM';
type HotspotStatus = 'ACCEPTABLE' | 'ACTIVE' | 'DRAFT' | 'SOLVED';
interface HotspotId {
  applicabilityPeriod: DateTimeMinutePeriod;
  trafficVolume: TrafficVolumeId;
  duration: DurationHourMinute;
}
interface FlightMCDMInfo {
  leastAdvancedMCDMMeasure: MeasureId;
  nrAssociatedMCDMRegulations: number;
  nrAssociatedMCDMReroutings: number;
  nrAssociatedMCDMOnlyMeasures: number;
  leastAdvancedMCDMState: MCDMState;
}
type MCDMState = 'ABANDONED' | 'COORDINATED' | 'DRAFT' | 'FINISHED' | 'IMPLEMENTED' | 'IMPLEMENTING' | 'INTERRUPTED' | 'PROPOSED';
type OtmvStatus = 'PEAK' | 'SUSTAINED';
type CountsCalculationType = 'ENTRY' | 'OCCUPANCY';
interface CountsInterval {
  duration: DurationHourMinute;
  step: DurationHourMinute;
}
type RegulationField = 'applicability' | 'autolink' | 'measureCherryPicked' | 'calculationType' | 'initialConstraints' | 'occupancyConstraints' | 'linkedRegulations' | 'location' | 'protectedLocation' | 'reason' | 'remark' | 'regulationState' | 'supplementaryConstraints' | 'lastUpdate' | 'noDelayWindow' | 'occupancyDuration' | 'updateCapacityRequired' | 'updateTVActivationRequired' | 'externallyEditable' | 'subType' | 'delayTVSet' | 'createdByFMP' | 'sourceHotspot' | 'mcdmRequired' | 'dataId' | 'scenarioReference' | 'delayConfirmationThreshold';
type SectorConfigurationPlanRetrievalRequest = TacticalConfigurationRetrievalRequest & {
  airspace: AirspaceId;
};
type TacticalConfigurationRetrievalRequest = B2BRequest & {
  dataset: Dataset;
  day: DateYearMonthDay;
};
type SectorConfigurationPlanRetrievalReply = ReplyWithData<SectorConfigurationPlanRetrievalReplyData>;
interface SectorConfigurationPlanRetrievalReplyData {
  plan: SectorConfigurationPlan;
}
type KnownConfigurations = NMMap<SectorConfigurationId, NMSet<AirspaceId>>;
interface SectorConfigurationPlan extends TacticalConfigurationPlan {
  airspace: AirspaceId;
  knownConfigurations?: NMMap<SectorConfigurationId, NMSet<AirspaceId>>;
  nmSchedule?: NMSet<PlannedSectorConfigurationActivation>;
  clientSchedule?: NMSet<PlannedSectorConfigurationActivation>;
}
interface PlannedSectorConfigurationActivation {
  applicabilityPeriod: DateTimeMinutePeriod;
  dataSource: PlanDataSource;
  sectorConfigurationId?: SectorConfigurationId;
}
interface TacticalConfigurationPlan {
  dataId: PlanDataId;
  dataset: Dataset;
  day: DateYearMonthDay;
  planTransferred?: boolean;
  planCutOffReached?: boolean;
}
type TrafficCountsByAirspaceRequest = TrafficCountsRequest & {
  airspace: AirspaceId;
  calculationType: CountsCalculationType;
};
type TrafficCountsByTrafficVolumeRequest = TrafficCountsRequest & {
  trafficVolume: TrafficVolumeId;
  calculationType: CountsCalculationType;
  computeOtmvAlerts?: boolean;
  computeFlowCounts?: FlowType;
  includeInvisibleFlights?: boolean;
};
type TrafficCountsRequest = B2BRequest & {
  dataset: Dataset;
  trafficWindow: DateTimeMinutePeriod;
  includeProposalFlights: boolean;
  includeForecastFlights: boolean;
  trafficTypes: NMSet<TrafficType>;
  subTotalComputeMode: CountSubTotalComputeMode;
  countsInterval: CountsInterval;
};
type CountSubTotalComputeMode =
/**
 * Do not compute flight count sub-totals.
 */
'NO_SUB_TOTALS'
/**
 * Compute flight count sub-totals by traffic type (see Counts.subTotalsCountsByTrafficType).
 */
| 'SUB_TOTALS_BY_TRAFFIC_TYPE'
/**
 * Compute flight count sub-totals by regulation details (see Counts.subTotalsCountsByRegulationDetails).
 */
| 'SUB_TOTALS_BY_REGULATION_DETAILS';
type TrafficCountsByAirspaceReply = ReplyWithData<TrafficCountsReplyData>;
type TrafficCountsByTrafficVolumeReply = ReplyWithData<TrafficCountsReplyData>;
interface TrafficCountsReplyData {
  effectiveTrafficWindow: DateTimeMinutePeriod;
  flows?: NMSet<Flow>;
  counts?: NMMap<DateTimeMinutePeriod, NMMap<TrafficType, Counts>>;
  otmvAlerts?: NMMap<TrafficType, NMSet<OtmvAlert>>;
  effectiveCapacities?: NMMap<DateTimeMinutePeriod, CountsValue>;
  effectiveOTMVs?: NMMap<DateTimeMinutePeriod, OTMVThresholds>;
}
interface Flow {
  id: FlowId;
  type: FlowType;
  role?: FlowRoleSelection;
  applicableScenarios?: TrafficVolumeScenarios;
  scenarioImpact?: ScenarioImpact;
}
type ScenarioImpact = {
  totalCommonFlightCount: CountsValue;
  totalOtherFlightCount: CountsValue;
  scenarioTrafficVolumeEntryPeriod?: DateTimeMinutePeriod;
};
type FlowType = 'ASSOCIATED' | 'LINKED' | 'SCENARIO';
type FlowRoleSelection = 'EXCLUDED' | 'EXEMPTED' | 'INCLUDED' | 'INCLUDED_AND_EXEMPTED';
interface Counts {
  totalCounts: CountsValue;
  flowCounts?: NMMap<FlowId, CountsValue>;
  subTotalsCountsByTrafficType?: NMMap<SubTotalsTrafficCountsType, CountsValue>;
  subTotalsCountsByRegulationDetails?: NMMap<SubTotalsRegulationDetailedType, CountsValue>;
}
type CountsValue = number;
type OTMVThresholds = {
  peakThreshold?: OTMVThreshold;
  sustainedThreshold?: OTMVThreshold;
  sustainedElapsedDuration?: DurationHourMinute;
  sustainedCrossingOccurences?: number;
};
type SubTotalsTrafficCountsType =
/**
 * Predicted flights that are not suspended
 */
'PFD'
/**
 * Flights created from a flight plan filed to IFPS that are not suspended, nor ATC_ACTIVATED, nor TACT_ACTIVATED_WITH_FSA, nor TACT_ACTIVATED_WITHOUT_FSA.
 */
| 'IFPL'
/**
 * Suspended Flights. Note that suspended flights are not considered part of the TrafficType.LOAD.
 */
| 'SUSPENDED'
/**
 * ATC activated flights. Note that this also includes terminated flights that were ATC activated.
 */
| 'ATC_ACTIVATED'
/**
 * TACT activated with FSA message expected (but not yet received). Note that this also includes terminated flights that were TACT_ACTIVATED_WITH_FSA.
 */
| 'TACT_ACTIVATED_WITH_FSA'
/**
 * TACT activated with no FSA message expected. Note that this also includes terminated flights that were TACT_ACTIVATED_WITHOUT_FSA.
 */
| 'TACT_ACTIVATED_WITHOUT_FSA';
type SubTotalsRegulationDetailedType =
/**
 * The count of not yet airborne delayed (delay > 0) flights of which most penalising regulation is the target regulation.
 */
'DELAYED_FLIGHTS_NOT_YET_AIRBORNE'
/**
 * The count of airborne delayed (delay > 0) flights of which most penalising regulation is the target regulation.
 */
| 'DELAYED_FLIGHTS_ALREADY_AIRBORNE'
/**
 * The count of not yet airborne zero (0) delay flights of which most penalising regulation is the target regulation or any other regulation.
 */
| 'ZERO_DELAY_FLIGHTS_NOT_YET_AIRBORNE'
/**
 * The count of airborne zero (0) delay flights of which most penalising regulation is the target regulation or any other regulation.
 */
| 'ZERO_DELAY_FLIGHTS_ALREADY_AIRBORNE'
/**
 * The count of not yet airborne flights with no most penalising regulation that are regulatable. These flights are typically in the extended periods around the regulation (or when showing the display when newly creating regulations).
 */
| 'NOT_REGULATED_BUT_REGULATABLE_FLIGHTS'
/**
 * The count of airborne flights with no most penalising regulation or, any exempted/excluded (airborne or not) flights with no most penalising regulation or of which most penalising regulation is the target regulation or any other regulation.
 */
| 'NOT_REGULATED_AIRBORNE_OR_EXEMPTED_FLIGHTS'
/**
 * The count of not yet airborne delayed (delay > 0) flights of which most penalising regulation is not the target regulation, excluding target regulation exempted flights.
 */
| 'OTHER_MPR_DELAYED_FLIGHTS_NOT_YET_AIRBORNE'
/**
 * The count of airborne delayed (delay > 0) flights of which most penalising regulation is not the target regulation, excluding target regulation exempted flights.
 */
| 'OTHER_MPR_DELAYED_FLIGHTS_ALREADY_AIRBORNE';
interface OtmvAlert {
  period: DateTimeMinutePeriod;
  status: OtmvStatus;
}
type RegulationState = 'APPLIED' | 'APPLYING' | 'CANCELLED' | 'CANCELLING' | 'TERMINATED';
type RegulationListRequest = RegulationOrMCDMOnlyListRequest & {
  requestedRegulationFields: NMSet<RegulationField>;
  regulationStates?: NMSet<RegulationState>;
};
type RegulationListReply = ReplyWithData<RegulationListReplyData>;
interface RegulationListReplyData extends RegulationOrMCDMOnlyListReplyData {
  regulations: NMSet<Regulation>;
}
interface RegulationOrMCDMOnlyListReplyData extends MeasureListReplyData {}
interface MeasureListReplyData {
  planTransferred?: boolean;
  planCutOffReached?: boolean;
  dataset: Dataset;
}
type RegulationOrMCDMOnlyListRequest = MeasureListRequest & {
  regulations?: NMSet<RegulationIdWildcard>;
  reasons?: NMSet<RegulationReason>;
};
type MeasureListRequest = B2BRequest & {
  dataset: Dataset;
  queryPeriod: DateTimeMinutePeriod;
  tvs?: NMSet<TrafficVolumeIdWildcard>;
  tvSets?: NMSet<TrafficVolumeSetIdWildcard>;
};
type Regulation = RegulationOrMCDMOnly & {
  regulationState?: RegulationState;
};
type TrafficVolumeScenarios = {
  solutionTrafficVolumeId: TrafficVolumeId;
  trafficVolumeMatchingKind: ScenarioTrafficVolumeMatchingKind;
  scenarios: NMSet<ScenarioId>;
};
type ScenarioTrafficVolumeMatchingKind = 'INDIRECT_OFFLOAD' | 'OVERLAPPING_REFERENCE_LOCATION' | 'SAME_REFERENCE_LOCATION' | 'SAME_TRAFFIC_VOLUME';
interface IRegulationOrMCDMOnly extends Measure {
  regulationId: RegulationId;
  reason?: RegulationReason;
  location?: TrafficVolumeLocation;
  calculationType?: null | CountsCalculationType;
  initialConstraints?: RegulationInitialConstraint[];
  supplementaryConstraints?: RegulationSupplementaryConstraint[];
  occupancyConstraints?: RegulationOccupancyConstraint[];
  remark?: string;
  autolink?: boolean;
  linkedRegulations?: NMSet<RegulationId>;
  noDelayWindow?: DurationHourMinute;
  occupancyDuration?: DurationHourMinute;
  updateCapacityRequired?: boolean;
  updateTCActivationRequired?: boolean;
  delayTVSet?: TrafficVolumeSetId;
  delayConfirmationThreshold?: DurationHourMinute;
}
type RegulationOrMCDMOnly = WithReferenceLocationOnPrefixOptional<'protectedLocation'> & IRegulationOrMCDMOnly;
interface Measure {
  dataId?: PlanDataId;
  applicability?: DateTimeMinutePeriod;
  measureCherryPicked?: boolean;
  lastUpdate?: LifeCycleEvent;
  externallyEditable?: boolean;
  subType?: MeasureSubType;
  createdByFMP?: boolean;
  mcdmRequired?: boolean;
  sourceHotspot?: HotspotId;
  scenarioReference?: MeasureFromScenarioRepository;
  mcdmInfo?: MCDMMeasureTopic;
}
type MeasureSubType = 'AIRBORNE_HORIZONTAL_REROUTING' | 'AIRBORNE_LEVEL_CAP' | 'GROUND_DELAY' | 'GROUND_HORIZONTAL_REROUTING' | 'GROUND_LEVEL_CAP' | 'MILES_MINUTES_IN_TRAIL' | 'MINIMUM_DEPARTURE_INTERVAL' | 'OTHER_KIND_OF_STAM_MEASURE' | 'TAKE_OFF_NOT_AFTER' | 'TAKE_OFF_NOT_BEFORE' | 'TERMINAL_PROCEDURE_CHANGE';
interface MeasureFromScenarioRepository {
  scenarioId: ScenarioId;
  measureId: MeasureId;
}
interface LifeCycleEvent {
  eventTime: DateTimeSecond;
  userUpdateEventTime?: DateTimeSecond;
  userUpdateType: LifeCycleEventType;
  userId: UserId;
}
interface MCDMMeasureTopic extends MCDMStatefulTopic {
  userCategories?: NMSet<MCDMRoleUserCategory>;
  deadlines?: MCDMDeadlines;
  flightTopics?: NMSet<MCDMFlightTopic>;
  predefinedUsersForFlightCoordinationLevel?: NMSet<MCDMUserAndRole>;
  remark?: string;
  proposalNote?: string;
  proposalFeedback?: string;
}
interface MCDMStatefulTopic extends MCDMTopic {
  measureId?: MeasureId;
  state?: MCDMState;
  hotspotId?: HotspotId;
  initiator?: AirNavigationUnitId;
  initiatorIsImplementer?: boolean;
  userRolesAndApprovalStates?: NMSet<MCDMUserRoleAndApprovalState>;
}
interface MCDMTopic {
  topicId: MCDMTopicId;
  dataId?: PlanDataId;
}
type MCDMTopicId = string;
interface MCDMRoleUserCategory {
  category: MCDMUserCategory;
  coordinationLevel: MCDMCoordinationLevel;
  role: MCDMRole;
}
interface MCDMDeadlines {
  timeToCoordinate?: DateTimeMinute;
  timeToStartImplement?: DateTimeMinute;
  timeToImplement?: DateTimeMinute;
}
interface MCDMFlightTopic extends MCDMStatefulTopic {
  flightKeys: FlightKeys;
  ifplId?: IFPLId;
  ticket?: EhelpDeskTicketChoice;
}
type EhelpDeskTicketChoice = unknown;
interface MCDMUserAndRole {
  user: AirNavigationUnitId;
  role?: MCDMRole;
}
type MCDMCoordinationLevel = 'FLIGHT' | 'MEASURE';
type MCDMUserCategory = 'IMPACTED_FMP' | 'ALL_FMP' | 'TOWER' | 'AIRCRAFT_OPERATOR' | 'NMOC';
interface MCDMUserRoleAndApprovalState {
  user: AirNavigationUnitId;
  role?: MCDMRole;
  approvalState?: MCDMApprovalState;
}
type MCDMRole = 'APPROVAL' | 'IMPLEMENTER' | 'INFO' | 'INITIATOR' | 'NOT_INVOLVED' | 'ROLE_INFO';
type MCDMApprovalState = 'ACKNOWLEDGED' | 'APPROVED' | 'REJECTED' | 'UNKNOWN';
type LifeCycleEventType = 'CREATION' | 'DELETION' | 'UPDATE';
type TrafficVolumeLocation = WithReferenceLocationOnPrefix<'referenceLocation'> & {
  id: TrafficVolumeId;
  flightLevels?: FlightLevelRange;
  description?: string;
  setIds?: NMSet<TrafficVolumeSetId>;
};
interface RegulationInitialConstraint {
  constraintPeriod: DateTimeMinutePeriod;
  normalRate: number;
  pendingRate: number;
  equipmentRate: number;
  exceptionalConstraint?: RegulationExceptionalConstraint;
}
interface RegulationExceptionalConstraint {
  runwayVisualRange?: DistanceM;
  fcmMandatory: boolean;
  shift: boolean;
}
interface RegulationSupplementaryConstraint {
  constraintPeriod: DateTimeMinutePeriod;
  supplementaryRate: number;
}
interface RegulationOccupancyConstraint {
  constraintPeriod: DateTimeMinutePeriod;
  occupancyRate: number;
  peakCapacity: number;
  pendingCapacityPercentage: number;
}
type HotspotListRequest = B2BRequest & {
  dataset: Dataset;
  day: DateYearMonthDay;
  trafficVolume?: TrafficVolumeId;
  duration?: DurationHourMinute;
  hotspotKind: HotspotKind;
};
type HotspotKind = 'LOCATION_OF_INTEREST' | 'PROBLEM';
type HotspotListReply = ReplyWithData<HotspotListReplyData>;
type HotspotListReplyData = {
  plans: HotspotPlans;
};
interface HotspotPlans {
  dataId: PlanDataId;
  dataset: Dataset;
  day: DateYearMonthDay;
  planTransferred?: boolean;
  planCutOffReached?: boolean;
  hotspotKind: HotspotKind;
  schedules: NMMap<TrafficVolumeId, NMMap<DurationHourMinute, NMSet<Hotspot>>>;
}
interface OTMVWithDuration {
  trafficVolume: TrafficVolumeId;
  otmvDuration?: DurationHourMinute;
}
type OTMVPlanRetrievalRequest = TacticalConfigurationRetrievalRequest & {
  otmvsWithDuration?: NMSet<OTMVWithDuration>;
};
type OTMVPlans = TacticalConfigurationPlan & {
  tvsOTMVs: NMMap<TrafficVolumeId, NMMap<DurationHourMinute, OTMVPlanForDuration>>;
};
interface OTMVPlanForDuration {
  nmSchedule?: NMSet<PlannedOTMV>;
  clientSchedule: NMSet<PlannedOTMV>;
}
interface PlannedOTMV {
  applicabilityPeriod: DateTimeMinutePeriod;
  dataSource: PlanDataSource;
  otmv?: OTMV;
}
interface OTMV {
  trafficVolume: TrafficVolumeId;
  otmvDuration: DurationHourMinute;
  peak?: OTMVPeak;
  sustained?: OTMVSustained;
  remark?: string;
}
interface OTMVPeak {
  threshold: OTMVThreshold;
}
interface OTMVSustained {
  threshold: OTMVThreshold;
  crossingOccurrences: number;
  elapsed: DurationHourMinute;
}
type OTMVThreshold = number;
type OTMVPlanRetrievalReply = ReplyWithData<OTMVPlanRetrievalReplyData>;
interface OTMVPlanRetrievalReplyData {
  plans: OTMVPlans;
}
type OTMVPlanUpdateRequest = B2BRequest & {
  plans: OTMVPlans;
};
type OTMVPlanUpdateReply = ReplyWithData<OTMVPlanUpdateReplyData>;
interface OTMVPlanUpdateReplyData {
  plans: OTMVPlans;
}
type CapacityPlanRetrievalRequest = TacticalConfigurationRetrievalRequest & {
  trafficVolumes?: NMSet<TrafficVolumeId>;
};
type CapacityPlanRetrievalReply = ReplyWithData<CapacityPlanRetrievalReplyData>;
interface CapacityPlanRetrievalReplyData {
  plans: CapacityPlans;
}
type CapacityPlans = TacticalConfigurationPlan & {
  tvCapacities: NMMap<TrafficVolumeId, PlannedCapacities>;
};
interface PlannedCapacities {
  nmSchedule?: NMSet<PlannedCapacity>;
  clientSchedule: NMSet<PlannedCapacity>;
}
interface PlannedCapacity {
  applicabilityPeriod: DateTimeMinutePeriod;
  dataSource: PlanDataSource;
  capacity?: Capacity;
}
type Capacity = number;
type CapacityPlanUpdateRequest = B2BRequest & {
  plans: CapacityPlans;
};
type CapacityPlanUpdateReply = ReplyWithData<CapacityPlanUpdateReplyData>;
interface CapacityPlanUpdateReplyData {
  plans: CapacityPlans;
}
type RunwayConfigurationPlanRetrievalReply = ReplyWithData<RunwayConfigurationPlanRetrievalData>;
interface RunwayConfigurationPlanRetrievalData {
  plan: RunwayConfigurationPlan;
}
interface RunwayConfigurationPlan extends TacticalConfigurationPlan {
  knownRunwayIds?: NMSet<RunwayId>;
  nmSchedule?: NMSet<RunwayConfigurationPlanSchedule>;
  clientSchedule?: NMSet<RunwayConfigurationPlanSchedule>;
}
interface RunwayConfigurationPlanSchedule {
  applicabilityPeriod: DateTimeMinutePeriod;
  dataSource: PlanDataSource;
  runwayConfigurations?: NMSet<RunwayConfiguration>;
}
interface RunwayConfiguration {
  runway: RunwayId;
  usage?: RunwayUsage;
  runwayUsageDataSource: PlanDataSource;
  departureTaxiTime?: DurationHourMinute;
  departureTaxiTimeDataSource: PlanDataSource;
  timeToInsertInSequence?: DurationHourMinute;
  timeToInsertInSequenceDataSource: PlanDataSource;
  timeToRemoveFromSequence?: DurationHourMinute;
  timeToRemoveFromSequenceDataSource: PlanDataSource;
  arrivalTaxiTime?: DurationHourMinute;
  arrivalTaxiTimeDataSource: PlanDataSource;
}
type RunwayConfigurationPlanRetrievalRequest = TacticalConfigurationRetrievalRequest & {
  aerodrome: AerodromeICAOId;
};
type RunwayUsage = 'DEPARTURE' | 'ARRIVAL' | 'DEPARTURE_ARRIVAL' | 'INACTIVE';
//#endregion
export { Capacity, CapacityPlanRetrievalReply, CapacityPlanRetrievalReplyData, CapacityPlanRetrievalRequest, CapacityPlanUpdateReply, CapacityPlanUpdateReplyData, CapacityPlanUpdateRequest, CapacityPlans, CountSubTotalComputeMode, Counts, CountsCalculationType, CountsInterval, CountsValue, EhelpDeskTicketChoice, FlightAtfcmMeasureLocation, FlightAtfcmMeasureLocationCommon, FlightAtfcmRegulationLocation, FlightAtfcmReroutingLocation, FlightHotspotLocation, FlightMCDMInfo, FlightRegulationLocation, Flow, FlowId, FlowRoleSelection, FlowType, Hotspot, HotspotId, HotspotKind, HotspotListReply, HotspotListReplyData, HotspotListRequest, HotspotPlans, HotspotSeverity, HotspotStatus, IRegulationOrMCDMOnly, KnownConfigurations, LifeCycleEvent, LifeCycleEventType, MCDMApprovalState, MCDMCoordinationLevel, MCDMDeadlines, MCDMFlightTopic, MCDMMeasureTopic, MCDMRole, MCDMRoleUserCategory, MCDMState, MCDMStatefulTopic, MCDMTopic, MCDMTopicId, MCDMUserAndRole, MCDMUserCategory, MCDMUserRoleAndApprovalState, Measure, MeasureFromScenarioRepository, MeasureId, MeasureListReplyData, MeasureListRequest, MeasureSubType, OTMV, OTMVPeak, OTMVPlanForDuration, OTMVPlanRetrievalReply, OTMVPlanRetrievalReplyData, OTMVPlanRetrievalRequest, OTMVPlanUpdateReply, OTMVPlanUpdateReplyData, OTMVPlanUpdateRequest, OTMVPlans, OTMVSustained, OTMVThreshold, OTMVThresholds, OTMVWithDuration, OtmvAlert, OtmvStatus, PlanDataSource, PlannedCapacities, PlannedCapacity, PlannedOTMV, PlannedSectorConfigurationActivation, Regulation, RegulationCause, RegulationExceptionalConstraint, RegulationField, RegulationId, RegulationIdWildcard, RegulationInitialConstraint, RegulationListReply, RegulationListReplyData, RegulationListRequest, RegulationLocationCategory, RegulationOccupancyConstraint, RegulationOrMCDMOnly, RegulationOrMCDMOnlyListReplyData, RegulationOrMCDMOnlyListRequest, RegulationReason, RegulationState, RegulationSupplementaryConstraint, ReroutingApplyKind, ReroutingId, ReroutingPurpose, RunwayConfiguration, RunwayConfigurationPlan, RunwayConfigurationPlanRetrievalData, RunwayConfigurationPlanRetrievalReply, RunwayConfigurationPlanRetrievalRequest, RunwayConfigurationPlanSchedule, RunwayUsage, ScenarioId, ScenarioImpact, ScenarioTrafficVolumeMatchingKind, SectorConfigurationId, SectorConfigurationPlan, SectorConfigurationPlanRetrievalReply, SectorConfigurationPlanRetrievalReplyData, SectorConfigurationPlanRetrievalRequest, SubTotalsRegulationDetailedType, SubTotalsTrafficCountsType, TacticalConfigurationPlan, TacticalConfigurationRetrievalRequest, TrafficCountsByAirspaceReply, TrafficCountsByAirspaceRequest, TrafficCountsByTrafficVolumeReply, TrafficCountsByTrafficVolumeRequest, TrafficCountsReplyData, TrafficCountsRequest, TrafficVolumeLocation, TrafficVolumeScenarios };
//# sourceMappingURL=types.d.mts.map