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

//#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';
interface SectorConfigurationPlanRetrievalRequest extends TacticalConfigurationRetrievalRequest {
  airspace: AirspaceId;
}
interface TacticalConfigurationRetrievalRequest {
  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 CapacityPlans extends TacticalConfigurationPlan {
  tvCapacities: NMMap<TrafficVolumeId, PlannedCapacities>;
}
interface PlannedSectorConfigurationActivation {
  applicabilityPeriod: DateTimeMinutePeriod;
  dataSource: PlanDataSource;
  sectorConfigurationId?: SectorConfigurationId;
}
interface TacticalConfigurationPlan {
  dataId: PlanDataId;
  dataset: Dataset;
  day: DateYearMonthDay;
  planTransferred?: boolean;
  planCutOffReached?: boolean;
}
interface TrafficCountsByAirspaceRequest extends TrafficCountsRequest {
  airspace: AirspaceId;
  calculationType: CountsCalculationType;
}
interface TrafficCountsByTrafficVolumeRequest extends TrafficCountsRequest {
  trafficVolume: TrafficVolumeId;
  calculationType: CountsCalculationType;
  computeOtmvAlerts?: boolean;
  computeFlowCounts?: FlowType;
  includeInvisibleFlights?: boolean;
}
interface TrafficCountsRequest {
  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>;
};
interface MeasureListRequest {
  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;
  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;
}
interface HotspotListRequest {
  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;
}
interface OTMVPlanRetrievalRequest extends TacticalConfigurationRetrievalRequest {
  otmvsWithDuration: NMSet<OTMVWithDuration>;
}
interface OTMVPlans extends 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;
}
interface OTMVPlanUpdateRequest {
  plans: OTMVPlans;
}
type OTMVPlanUpdateReply = ReplyWithData<OTMVPlanUpdateReplyData>;
interface OTMVPlanUpdateReplyData {
  plans: OTMVPlans;
}
interface CapacityPlanRetrievalRequest extends TacticalConfigurationRetrievalRequest {
  trafficVolumes: NMSet<TrafficVolumeId>;
}
type CapacityPlanRetrievalReply = ReplyWithData<CapacityPlanRetrievalReplyData>;
interface CapacityPlanRetrievalReplyData {
  plans: CapacityPlans;
}
interface CapacityPlans extends TacticalConfigurationPlan {
  tvCapacities: NMMap<TrafficVolumeId, PlannedCapacities>;
}
interface PlannedCapacities {
  nmSchedule?: NMSet<PlannedCapacity>;
  clientSchedule: NMSet<PlannedCapacity>;
}
interface PlannedCapacity {
  applicabilityPeriod: DateTimeMinutePeriod;
  dataSource: PlanDataSource;
  capacity?: Capacity;
}
type Capacity = number;
interface CapacityPlanUpdateRequest {
  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;
}
interface RunwayConfigurationPlanRetrievalRequest extends 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.ts.map