import { WithReferenceLocationOnPrefix, WithReferenceLocationOnPrefixOptional, ReferenceLocation, TrafficVolumeId, AirspaceId, TrafficVolumeIdWildcard, TrafficVolumeSetIdWildcard, TrafficVolumeSetId, FlightLevelRange, AerodromeICAOId, ICAOPoint, FlightLevel, AirSpeed, TerminalProcedure, PublishedPointId, RunwayId as RunwayId$1, AerodromeOrPublishedPointId, NetworkAddress, NonPublishedPoint, FIRICAOId, RouteOrTerminalProcedure, AirspaceType, FlightPlanProcessing, RestrictionId, LoadState, AerodromeSetId } from './Airspace/types.cjs';
import { D as DateTimeMinutePeriod, a as DurationHourMinute, b as Dataset, c as DateYearMonthDay, R as ReplyWithData, N as NMMap, d as NMSet, P as PlanDataId, e as DateTimeSecond, U as UserId, A as AirNavigationUnitId, f as DateTimeMinute, g as DistanceM, W as WeightKg, F as FlightLevelM, h as Duration, i as DurationMinute, j as ShiftHourMinute, k as ReceivedOrSent, l as DistanceNM, m as NMList, C as Cost, n as SignedDurationHourMinuteSecond, o as Colours, p as DurationHourMinuteSecond, T as TimeHourMinutePeriod, q as Position$1 } from './types-B66r3qfk.cjs';

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 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 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>;
}
type RunwayId = string;
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';

type IFPLId = string;
type FlightDataset = 'flight' | 'flightPlan' | 'flightPlanHistory';
type FlightIdentificationInput = {
    id: IFPLId;
} | {
    keys: FlightKeys;
} | {
    iataKeys: IATAFlightKeys;
};
interface FlightIdentificationOutput {
    id?: IFPLId;
    keys?: FlightKeys;
}
type AircraftICAOId = string;
type ExtendedAircraftICAOId = string;
type AircraftRegistrationMark = string;
type ICAOAircraftAddress = string;
type SSRCode = string;
type SSRMode = 'A';
type AircraftTypeICAOId = string;
type OtherAircraftTypeDesignation_DataType = string;
type AircraftOperatorICAOId = string;
type AircraftIATAId = string;
type FlightTrend = 'CLIMB' | 'CRUISE' | 'DESCENT' | 'NONE';
type FlightState = 'ATC_ACTIVATED' | 'CANCELLED' | 'FILED' | 'FILED_SLOT_ALLOCATED' | 'FILED_SLOT_ISSUED' | 'PLANNED' | 'PLANNED_REROUTED' | 'PLANNED_SLOT_ALLOCATED' | 'PLANNED_SLOT_ALLOCATED_REROUTED' | 'TACT_ACTIVATED' | 'TERMINATED';
type ATFMMessageType = 'DES' | 'ERR' | 'FCM' | 'FLS' | 'FUM' | 'REA' | 'RFI' | 'RJT' | 'RRN' | 'RRP' | 'SAM' | 'SIP' | 'SLC' | 'SMM' | 'SPA' | 'SJR' | 'SRM' | 'SWM' | 'UNK';

interface FlightKeys {
    aircraftId: ExtendedAircraftICAOId;
    aerodromeOfDeparture?: AerodromeICAOId;
    nonICAOAerodromeOfDeparture?: boolean;
    airFiled: boolean;
    aerodromeOfDestination?: AerodromeICAOId;
    nonICAOAerodromeOfDestination?: boolean;
    estimatedOffBlockTime: DateTimeMinute;
}
type IATAFlightKeys = {
    flightDesignator: AircraftIATAId;
    estimatedOffBlockTime: DateTimeMinute;
};
interface TimeAndModel {
    model: TrafficType;
    dateTime: DateTimeSecond;
}
type TrafficType = 'DEMAND' | 'LOAD' | 'REGULATED_DEMAND';
type FlightField = 'divertedAerodromeOfDestination' | 'readyEstimatedOffBlockTime' | 'cdmEstimatedOffBlockTime' | 'calculatedOffBlockTime' | 'actualOffBlockTime' | 'aircraftType' | 'estimatedTakeOffTime' | 'calculatedTakeOffTime' | 'actualTakeOffTime' | 'ctotShiftAlreadyAppliedByTower' | 'taxiTime' | 'currentDepartureTaxiTimeAndProcedure' | 'revisionTimes' | 'estimatedTimeOfArrival' | 'calculatedTimeOfArrival' | 'actualTimeOfArrival' | 'requestedFlightLevel' | 'timeAtReferenceLocationEntry' | 'timeAtReferenceLocationExit' | 'flightLevelAtReferenceLocationEntry' | 'flightLevelAtReferenceLocationExit' | 'trendAtReferenceLocationEntry' | 'trendAtReferenceLocationExit' | 'trendAtReferenceLocationMiddle' | 'lateFiler' | 'lateUpdater' | 'suspensionStatus' | 'suspensionInfo' | 'exclusionFromRegulations' | 'famStatus' | 'readyStatus' | 'aircraftOperator' | 'operatingAircraftOperator' | 'reroutingIndicator' | 'newRouteMinShiftDelayImprovement' | 'reroutable' | 'cdm' | 'slotIssued' | 'proposalInformation' | 'bestReroutingIndicator' | 'exemptedFromRegulations' | 'delay' | 'delayCharacteristics' | 'mostPenalisingRegulation' | 'hasOtherRegulations' | 'regulationLocations' | 'atfcmMeasureLocations' | 'lastATFMMessageType' | 'lastATFMMessageReceivedOrSent' | 'runwayVisualRange' | 'confirmedCTFM' | 'requestedInitialFlightLevel' | 'requestedInitialSpeed' | 'estimatedElapsedTime' | 'filingRule' | 'initialFPLMessageOriginator' | 'lastFPLMessageOriginator' | 'icaoRoute' | 'routeLength' | 'defaultReroutingRequestedFlightLevel' | 'defaultReroutingRequestedSpeed' | 'departureTolerance' | 'mostPenalisingRegulationCause' | 'lastATFMMessageOriginator' | 'ftfmPointProfile' | 'rtfmPointProfile' | 'ctfmPointProfile' | 'ftfmAirspaceProfile' | 'rtfmAirspaceProfile' | 'ctfmAirspaceProfile' | 'ftfmRequestedFlightLevels' | 'rtfmRequestedFlightLevels' | 'ctfmRequestedFlightLevels' | 'flightHistory' | 'operationalLog' | 'equipmentCapabilityAndStatus' | 'ftfmRestrictionProfile' | 'rtfmRestrictionProfile' | 'ctfmRestrictionProfile' | 'cfmuFlightType' | 'ccamsSSRCode' | 'filedRegistrationMark' | 'isProposalFlight' | 'hasBeenForced' | 'caughtInHotspots' | 'hotspots' | 'mcdmInfo' | 'worstLoadStateAtReferenceLocation' | 'compareWithOtherTrafficType' | 'ctotLimitReason' | 'profileValidity' | 'targetTimeOverFix' | 'flightState' | 'lastKnownPosition' | 'highestModelPointProfile' | 'highestModelAirspaceProfile' | 'highestModelRestrictionProfile' | 'slotSwapCounter' | 'slotSwapCandidateList' | 'aircraftAddress' | 'arrivalInformation' | 'slotZone' | 'flightDataVersionNr' | 'applicableScenarios' | 'apiSubmissionRules' | 'avoidedRegulations' | 'routeChargeIndicator' | 'fuelConsumptionIndicator' | 'excludedRegulations' | 'yoyoFlightForLocation' | 'turnFlightForLocation' | 'minimumRequestedRVR' | 'wakeTurbulenceCategory' | 'alternateAerodromes' | 'flightCriticality' | 'oceanicReroute' | 'visibility';
type FlightPlanOutput = {
    structured: StructuredFlightPlan;
};
interface BasicTrajectoryData {
    takeOffWeight?: WeightKg;
    topOfClimb?: Array<Relative4DPoint>;
    topOfDescent?: Array<Relative4DPoint>;
    bottomOfClimb?: Array<Relative4DPoint>;
    bottomOfDescent?: Array<Relative4DPoint>;
    distanceAtLocationInfo?: DistanceAtLocation;
}
type DistanceAtLocation = {
    adesDAL?: AerodromeDAL;
    dalPoints?: Array<PointDAL>;
};
type PointDAL = {
    point: ICAOPoint;
    cumulativeDistance: DistanceM;
};
type AerodromeDAL = {
    aerodrome: AerodromeICAOId;
    cumulativeDistance: DistanceM;
};
type Relative4DPoint = {
    cumulativeDistance: DistanceM;
    altitude: FlightLevelM;
    elapsedTime: Duration;
};
interface DepartureData {
    taxiTime: DurationMinute;
}
type FIXMFlight = Record<string, unknown>;
interface StructuredFlightPlan {
    flightPlan?: FlightPlan;
    basicTrajectoryData?: BasicTrajectoryData;
    departureData?: DepartureData;
}
type FlightPlanHistory = {
    infos?: Array<FlightPlanHistoryInfo>;
};
type FlightPlanHistoryInfo = {
    timeStamp?: DateTimeSecond;
    checkPoint?: string;
    mode?: string;
    msgIn?: string;
    msgOut?: string;
    addresses?: Array<string>;
    detail?: string;
};
interface Flight {
    flightId: FlightIdentificationOutput;
    divertedAerodromeOfDestination?: AerodromeICAOId;
    aircraftType?: AircraftTypeICAOId;
    readyEstimatedOffBlockTime?: DateTimeMinute;
    cdmEstimatedOffBlockTime?: DateTimeMinute;
    calculatedOffBlockTime?: DateTimeMinute;
    actualOffBlockTime?: DateTimeMinute;
    revisionTimes?: {
        timeToInsertInSequence?: DurationHourMinute;
        timeToRemoveFromSequence?: DurationHourMinute;
    };
    estimatedTakeOffTime?: DateTimeMinute;
    calculatedTakeOffTime?: DateTimeMinute;
    actualTakeOffTime?: DateTimeMinute;
    ctotShiftAlreadyAppliedByTower?: ShiftHourMinute;
    requestedFlightLevel?: FlightLevel;
    taxiTime?: DurationHourMinute;
    currentDepartureTaxiTimeAndProcedure?: TaxiTimeAndProcedure;
    estimatedTimeOfArrival?: DateTimeMinute;
    calculatedTimeOfArrival?: DateTimeMinute;
    actualTimeOfArrival?: DateTimeMinute;
    lateFilter?: boolean;
    lateUpdater?: boolean;
    suspensionStatus?: SuspensionStatus;
    suspensionInfo?: string;
    famStatus?: FAMStatus;
    readyStatus?: ReadyStatus;
    aircraftOperator?: AircraftOperatorICAOId;
    operatingAircraftOperator?: AircraftOperatorICAOId;
    reroutingIndicator?: ReroutingIndicator;
    newRouteMinShiftDelayImprovement?: DurationHourMinute;
    reroutable?: 'CANNOT_BE_REROUTED' | 'TRY_ALLOWED' | 'TRY_AND_APPLY_ALLOWED';
    cdm?: CDM;
    slotIssued?: boolean;
    proposalInformation?: ProposalInformation;
    timeAtReferenceLocationEntry?: TimeAndModel;
    timeAdReferenceLocationExit?: TimeAndModel;
    flightLevelAtReferenceLocationEntry?: FlightLevel;
    flightLevelAtReferenceLocationExit?: FlightLevel;
    trendAtReferenceLocationEntry?: FlightTrend;
    trendAtReferenceLocationExit?: FlightTrend;
    trendAtReferenceLocationMiddle?: FlightTrend;
    bestReroutingIndicator?: GroupReroutingSummary;
    exemptedFromRegulations?: boolean;
    delay?: DurationHourMinute;
    delayCharacteristics?: 'ADJUSTED_TO_CLOCK' | 'EXCEEDS_DELAY_CONFIRMATION';
    mostPenalisingRegulation?: RegulationId;
    hasOtherRegulations?: boolean;
    regulationLocations?: FlightRegulationLocation[];
    atfcmMeasureLocations?: NMSet<FlightAtfcmMeasureLocation>;
    lastATFMMessageType?: ATFMMessageType;
    lastATFMMessageReceivedOrSent?: ReceivedOrSent;
    runwayVisualRange?: DistanceM;
    minimumRequestedRVR?: DistanceM;
    confirmedCTFM?: DistanceNM;
    exclusionFromRegulations?: ExclusionFromRegulations;
    requestedInitialFlightLevel?: FlightLevel;
    requestedInitialSpeed?: AirSpeed;
    estimatedElapsedTime?: DurationHourMinute;
    filingRule?: 'FILING_ALLOWED_BY_AO_CFMU' | 'NOT_AUTHORISED' | 'OPERATOR_MUST_REFILE';
    initialFPLMessageOriginator?: MessageOriginator;
    lastFPLMessageOriginator?: MessageOriginator;
    icaoRoute?: string;
    routeLength?: DistanceNM;
    defaultReroutingRequestedFlightLevel?: FlightLevel;
    defaultReroutingRequestedSpeed?: AirSpeed;
    departureTolerance?: DepartureTolerance;
    mostPenalisingRegulationCause?: RegulationCause;
    lastATFMMessageOriginator?: MessageOriginator;
    ftfmPointProfile?: FlightPoint[];
    rtfmPointProfile?: FlightPoint[];
    ctfmPointProfile?: FlightPoint[];
    ftfmAirspaceProfile?: FlightAirspace[];
    rtfmAirspaceProfile?: FlightAirspace[];
    ctfmAirspaceProfile?: FlightAirspace[];
    ftfmRequestedFlightLevels?: RequestedFlightLevel[];
    rtfmRequestedFlightLevels?: RequestedFlightLevel[];
    ctfmRequestedFlightLevels?: RequestedFlightLevel[];
    ftfmTrafficVolumeProfile?: FlightTrafficVolume[];
    rtfmTrafficVolumeProfile?: FlightTrafficVolume[];
    ctfmTrafficVolumeProfile?: FlightTrafficVolume[];
    flightHistory?: FlightEvent[];
    operationalLog?: FlightOperationalLogEntry[];
    equipmentCapabilityAndStatus?: EquipmentCapabilityAndStatus;
    ftfmRestrictionProfile?: FlightRestriction[];
    rtfmRestrictionProfile?: FlightRestriction[];
    ctfmRestrictionProfile?: FlightRestriction[];
    cfmuFlightType?: CfmuFlightType;
    ccamsSSRCode?: SSRCode;
    filedRegistrationMark?: AircraftRegistrationMark;
    isProposalFlight?: boolean;
    proposalExists?: boolean;
    hasBeenForced?: boolean;
    caughtInHotspots?: number;
    hotspots?: FlightHotspotLocation[];
    mcdmInfo?: FlightMCDMInfo;
    worstLoadStateAtReferenceLocation?: LoadStateAtReferenceLocation;
    compareWithOtherTrafficType?: DeltaEntry;
    ctotLimitReason?: CTOTLimitReason;
    profileValidity?: ProfileValidity;
    targetTimeOverFix?: TargetTime;
    flightState?: FlightState;
    lastKnownPosition?: FourDPosition;
    slotSwapCounter?: {
        currentCounter: number;
        maxLimit: number;
    };
    slotSwapCandidateList?: NMList<{
        ifplId: IFPLId;
        subjectDeltaDelayMinutes: number;
        candidateDeltaDelayMinutes: number;
        swapDecideByTime: DateTimeMinute;
    }>;
    aircraftAddress?: ICAOAircraftAddress;
    arrivalInformation?: ArrivalInformation;
    slotZone?: {
        beforeCTO: DurationMinute;
        afterCTO: DurationMinute;
    };
    flightDataVersionNr?: number;
    applicableScenarios?: NMList<TrafficVolumeScenarios>;
    apiSubmissionRules?: APISubmissionRules;
    avoidedRegulations?: NMSet<RegulationId>;
    routeChargeIndicator?: number;
    fuelConsumptionIndicator?: number;
    excludedRegulations?: NMSet<RegulationId>;
    yoyoFlightForLocation?: YoYoFlightForLocation;
    turnFlightForLocation?: TurnFlightForLocation;
    wakeTurbulenceCategory?: WakeTurbulenceCategory;
    alternateAerodromes?: NMList<AerodromeICAOId>;
    flightCriticality?: FlightCriticalityIndicator;
    oceanicRoute?: boolean;
    visibility?: FlightVisibility;
    iataFlightDesignator?: AircraftIATAIdFromDataSource;
    activeACDMAlerts?: NMList<ACDMAlertData>;
    aoReroutingFeedbacks?: NMList<ReroutingFeedback>;
}
type ReroutingFeedbackKind = 'LIKE' | 'DISLIKE';
type ReroutingFeedbackReason = 'TOTAL_COST' | 'FUEL_SAVINGS' | 'ROUTE_CHARGES' | 'ATFM_DELAY_VALUE' | 'DISTANCE' | 'FLYING_TIME' | 'OBT_VALIDITY' | 'AO_INTERNAL_REASONS' | 'OTHER';
type ReroutingFeedback = {
    kind: ReroutingFeedbackKind;
    icaoRoute: string;
    reason: ReroutingFeedbackReason;
    comment?: string;
    reroutingId?: ReroutingId;
};
type ACDMAlertCode = string;
type ACDMAlertSeverity = 'HIGH' | 'MEDIUM' | 'LOW';
type ACDMAlertData = {
    alertCode: ACDMAlertCode;
    timestamp: DateTimeMinute;
    inconsistencyDetected: string;
    actionToTake: string;
    consequencesNote?: string;
    severity?: ACDMAlertSeverity;
};
type AircraftIATAIdFromDataSource = {
    id: AircraftIATAId;
    dataSource: AircraftIdDataSource;
};
type AircraftIdDataSource = 'DDR' | 'API' | 'DPI' | 'FPM';
type FlightTrafficVolume = {
    trafficVolumeId: TrafficVolumeId;
    entryTime: DateTimeSecond;
    entryFlightLevel?: FlightLevel;
    entryTrend: FlightTrend;
    middleTrend: FlightTrend;
    exitTime: DateTimeSecond;
    exitFlightLevel?: FlightLevel;
    exitTrend: FlightTrend;
    activated: boolean;
    exempted: boolean;
    flows: NMList<Flow>;
};
type FlightVisibility = 'NO_VISIBILITY' | 'VISIBLE' | 'INVISIBLE' | 'INVISIBLE_BEFORE_VISIBLE' | 'VISIBLE_AFTER_INVISIBLE' | 'VISIBLE_BEFORE_INVISIBLE' | 'VISIBLE_BETWEEN_INVISIBLE' | 'VISIBLE_WITH_SKIPOUT';
type APISubmissionRules = {
    latestSubmissionTargetTakeOffAPI?: DateTimeMinute;
    earliestSubmissionTargetTimeOverAPI?: DateTimeMinute;
};
type WakeTurbulenceCategory = 'HEAVY' | 'LIGHT' | 'MEDIUM' | 'SUPER';
type FlightCriticalityIndicator = {
    kind: FlightCriticalityKind;
    comment?: string;
};
type GroupReroutingSummary = {
    groupReroutingIndicator: GroupReroutingIndicator;
    reroutingId: ReroutingId;
    deltaCost: Cost;
    deltaDelay?: SignedDurationHourMinuteSecond;
};
type GroupReroutingIndicator = 'NO_REROUTING' | 'UNINTERESTING' | 'INTERESTING' | 'OPPORTUNITY' | 'EXECUTED';
type FlightCriticalityKind = 'CRITICAL_DUE_TO_AIRFRAME_UTILISATION' | 'CRITICAL_DUE_TO_AIRPORT_CLOSURE' | 'CRITICAL_DUE_TO_CREW_TIME' | 'CRITICAL_DUE_TO_NOISE_ABATEMENT' | 'CRITICAL_DUE_TO_OTHER_REASONS' | 'CRITICAL_DUE_TO_PASSENGER_CONNECTIONS' | 'CRITICAL_DUE_TO_PASSENGER_DELAY_COMPENSATION' | 'CRITICAL_DUE_TO_TURNAROUND_CRITICAL';
type TurnFlightForLocation = {
    ftfmTurn: TurnFlightForLocationKind;
    locationModelTurnKind: TurnFlightForLocationKind;
};
type TurnFlightForLocationKind = 'CRITICAL_ELSEWHERE' | 'CRITICAL_INSIDE' | 'CRITICAL_SHARP_TURN' | 'NON_CRITICAL_ELSEWHERE' | 'NON_CRITICAL_INSIDE' | 'NON_CRITICAL_SHARP_TURN' | 'NO_SHARP_TURN';
type YoYoFlightForLocation = {
    ftfmYoYo: YoYoFlightForLocationKind;
    locationModelYoYoKind: YoYoFlightForLocationKind;
};
type YoYoFlightForLocationKind = 'CRITICAL_COMPLETELY_INSIDE' | 'CRITICAL_ELSEWHERE' | 'CRITICAL_ENDS_INSIDE' | 'CRITICAL_STARTS_INSIDE' | 'CRITICAL_YOYO' | 'LOCATION_INSIDE_CRITICAL' | 'LOCATION_INSIDE_NON_CRITICAL' | 'NON_CRITICAL_COMPLETELY_INSIDE' | 'NON_CRITICAL_ELSEWHERE' | 'NON_CRITICAL_ENDS_INSIDE' | 'NON_CRITICAL_STARTS_INSIDE' | 'NON_CRITICAL_YOYO' | 'NO_YOYO';
type ArrivalInformation = {
    flightStatusInbound?: ATVFlightStatusInbound;
    registrationMark?: AircraftRegistrationMark;
    aircraftType?: AircraftTypeICAOId;
    aircraftIATAId?: AircraftIATAId;
    arrivalTaxiTime?: DurationHourMinute;
    apiArrivalProcedure?: TerminalProcedure;
    nmArrivalProcedure?: TerminalProcedure;
    initialApproachFix?: PublishedPointId;
    arrivalRunway?: RunwayId$1;
    arrivalTerminal?: TerminalOrApronStandName;
    arrivalApronStand?: TerminalOrApronStandName;
    minimumTurnaroundTime?: DurationHourMinute;
    landingTime?: DateTimeMinute;
    scheduledInBlockTime?: DateTimeMinute;
    inBlockTime?: DateTimeMinute;
    airportSlotArrival?: DateTimeMinute;
    impactSeverityIndicator?: ImpactSeverityIndicator;
    coordinationFix?: AerodromeOrPublishedPointId;
    targetTimeOver?: DateTimeMinute;
    earliestTargetTimeOver?: DateTimeMinute;
    consolidatedTargetTimeOver?: DateTimeMinute;
    calculatedTimeOver?: DateTimeMinute;
    regulationId?: RegulationId;
    minCalculatedTimeOver?: DateTimeMinute;
    maxCalculatedTimeOver?: DateTimeMinute;
    estimatedOrActualTimeOver?: DateTimeMinute;
};
type ImpactSeverityIndicator = 'E' | 'EI' | 'L' | 'LI' | 'LIP' | 'OT';
type ProposalInformation = {
    proposalKink: ProposalKind;
    responseBy: DateTimeMinute;
    proposedCTOT?: DateTimeMinute;
    routeId?: ReroutingRouteId;
    reroutingId?: ReroutingId;
};
type ReroutingRouteId = {
    routeType: ReroutingRouteType;
    standardRouteId: StandardRouteId;
};
type StandardRouteId = {
    from: AerodromeICAOId;
    to: AerodromeICAOId;
    seqNr: number;
};
type ReroutingRouteType = 'GENERATED' | 'STANDARD' | 'USER' | 'VERTICAL';
type ProposalKind = 'DELAY_CONF' | 'RRP' | 'RVR' | 'SIP' | 'STAM_SLOT';
type MessageOriginator = {
    airNavigationUnitId: AirNavigationUnitId;
} | {
    address: NetworkAddress;
};
type TaxiTimeAndProcedure = {
    taxiTime: DurationHourMinute;
    taxiTimeSource: TaxiTimeSource;
    terminalProcedure?: TerminalProcedure;
};
type TaxiTimeSource = 'ENV' | 'FPL' | 'RWY' | 'REA' | 'CDM';
type SuspensionStatus = 'AIRPORT_SUSPENSION' | 'DELAY_CONFIRMATION' | 'FLIGHT_PLAN_REVALIDATION' | 'MANUAL_SUSPENSION' | 'NOT_REPORTED_AS_AIRBORNE' | 'NOT_SUSPENDED' | 'REGULATION_CONFIRMATION' | 'SLOT_MISSED' | 'TRAFFIC_VOLUMES_CONDITION' | 'V_MANUAL_SUSPENSION';
type FAMStatus = 'AIRBORNE_WHEN_SHIFTED_BY_FAM' | 'AIRBORNE_WHEN_SUSPENDED_BY_FAM' | 'NOT_UNDER_FAM' | 'SHIFTED_BY_FAM' | 'SUBJECT_TO_FAM' | 'SUSPENDED_BY_FAM' | 'WAS_SHIFTED_BY_FAM' | 'WAS_SUBJECT_TO_FAM' | 'WAS_SUSPENDED_BY_FAM';
interface ReadyStatus {
    readyForImprovement?: boolean;
    readyToDepart: boolean;
    revisedTaxiTime?: DurationHourMinute;
}
interface ReroutingIndicator {
    rerouted: boolean;
    reason?: ReroutingReason;
    state?: ReroutingState;
}
type ReroutingReason = 'AO' | 'ATC_PURPOSE_PROPOSAL' | 'ATFCM_PURPOSE_PROPOSAL' | 'ATFM_EXECUTED' | 'CDR_OPPORTUNITY_PROPOSAL' | 'FLIGHT_EFFICIENCY_PURPOSE_PROPOSAL' | 'STAM_PURPOSE_PROPOSAL';
type ReroutingState = 'EXECUTED' | 'NO_MATCH' | 'PRODUCED' | 'REJECTED' | 'REVOKED' | 'TIMED_OUT';
type OtherAerodromeDesignation = {
    aerodromeName?: string;
    aerodromeLocation?: NonPublishedPoint;
    firstLastRoutePoint?: ICAOPoint;
};
type Aerodrome = {
    icaoId: AerodromeICAOId;
} | {
    otherDesignation: OtherAerodromeDesignation;
};
interface AirFiledData {
    atsUnitId?: AtsUnitId_DataType;
    startingPoint: ICAOPoint;
    clearedLevel: FlightLevel;
    estimatedTimeOver: DateTimeSecond;
}
type AtsUnitId_DataType = string;
interface AlternateAerodrome {
    icaoId: AerodromeICAOId;
    nameLocationDescription: string;
}
interface AerodromesOfDestination {
    aerodromeOfDestination: Aerodrome;
    alternate1?: AlternateAerodrome;
    alternate2?: AlternateAerodrome;
}
type AlternateAerodrome_DataType = string;
interface SSRInfo {
    code: SSRCode;
    mode: SSRMode;
}
interface AircraftIdentification {
    aircraftId?: AircraftICAOId;
    registrationMark: AircraftRegistrationMark;
    aircraftAddress?: ICAOAircraftAddress;
    ssrInfo?: SSRInfo;
}
type AircraftType = {
    icaoId: AircraftTypeICAOId;
} | {
    otherDesignation: OtherAircraftTypeDesignation_DataType;
};
interface FlightPlan {
    ifplId?: IFPLId;
    airFiledData?: AirFiledData;
    aerodromeOfDeparture?: Aerodrome;
    aerodromesOfDestination?: AerodromesOfDestination;
    enrouteAlternateAerodromes?: AlternateAerodrome_DataType;
    takeOffAlternateAerodromes?: AlternateAerodrome_DataType;
    aircraftId?: AircraftIdentification;
    whatIfRerouteReference?: number;
    numberOfAircraft?: number;
    aircraftType?: AircraftType;
    totalEstimatedElapsedTime?: DurationHourMinute;
    eetsToLocations?: EstimatedElapsedTimeAtLocation[];
    wakeTurbulenceCategory?: WakeTurbulenceCategory;
    flightType?: FlightType;
    flightRules?: FlightRules;
    estimatedOffBlockTime: DateTimeMinute;
    icaoRoute?: string;
    stayInformation?: Array<string>;
    enrouteDelays?: Array<EnrouteDelay>;
    equipmentCapabilityAndStatus?: EquipmentCapabilityAndStatus;
    surveillanceEquipment?: SurveillanceEquipment;
    otherInformation?: OtherInformation;
    supplementaryInformation?: SupplementaryInformation;
}
type SupplementaryInformation = {
    fuelEndurance?: DurationHourMinute;
    numberOfPersons?: number;
    frequencyAvailability?: Array<FrequencyOnAircraft>;
    survivalEquipment?: Array<SurvivalEquipment>;
    otherSurvivalEquipment?: string;
    lifeJacketEquipment?: Array<LifeJacketEquipment>;
    dinghiesInformation?: Dinghies;
    aircraftColourAndMarkings?: string;
    pilotInCommand?: string;
};
type FrequencyOnAircraft = 'ELT' | 'UHF' | 'VHF';
type SurvivalEquipment = 'DESERT' | 'JUNGLE' | 'MARITIME' | 'POLAR';
type LifeJacketEquipment = 'FLUORESCEIN' | 'LIGHTS' | 'UHF' | 'VHF';
type Dinghies = {
    numberOfDinghies?: number;
    totalCapacity?: number;
    areCovered?: boolean;
    colours?: Colours;
};
type OtherInformation = {
    selCalCode: string;
    nameOfOperator?: AircraftOperatorName_DataType;
    reasonForSpecialHandling?: SpecialHandlingIndicators;
    aircraftPerformanceData?: AircraftPerformanceCategory;
    communicationEquipment?: string;
    datalinkCapabilities?: DatalinkCapabilities;
    navigationEquipment?: string;
    performanceBasedNavigationCodes?: Array<PerformanceBasedNavigationCode>;
    otherSurveillanceEquipments?: string;
    replacementFlightPlanIndicator?: number;
    runwayVisualRange?: DistanceM;
    reclearanceInFlight?: ReclearanceInFlight;
    otherRemarks?: Array<string>;
};
type ReclearanceInFlight = {
    icaoRoute: string;
    aerodrome: AerodromeICAOId;
};
type PerformanceBasedNavigationCode = 'BASIC_RNP_1_ALL' | 'BASIC_RNP_1_DME_DME' | 'BASIC_RNP_1_DME_DME_IRU' | 'BASIC_RNP_1_GNSS' | 'RNAV_10' | 'RNAV_1_ALL' | 'RNAV_1_DME_DME' | 'RNAV_1_DME_DME_IRU' | 'RNAV_1_GNSS' | 'RNAV_2_ALL' | 'RNAV_2_DME_DME' | 'RNAV_2_DME_DME_IRU' | 'RNAV_2_GNSS' | 'RNAV_5_ALL' | 'RNAV_5_DME_DME' | 'RNAV_5_GNSS' | 'RNAV_5_INS_OR_IRS' | 'RNAV_5_LORAN_C' | 'RNAV_5_VOR_DME' | 'RNP_4' | 'RNP_APCH' | 'RNP_APCH_BARO_VNAV' | 'RNP_AR_APCH_NO_RF' | 'RNP_AR_APCH_RF';
type DatalinkCapabilities = {
    value?: string;
};
type AircraftPerformanceCategory = 'CAT_A' | 'CAT_B' | 'CAT_C' | 'CAT_D' | 'CAT_E' | 'CAT_H';
type SpecialHandlingIndicators = {
    icaoSTSIndicators?: Array<ICAOSTSIndicator>;
    eurSTSIndicators?: Array<EURSTSIndicator>;
};
type ICAOSTSIndicator = 'ALTRV' | 'ATFMX' | 'FFR' | 'FLTCK' | 'HAZMAT' | 'HEAD' | 'HOSP' | 'HUM' | 'MARSA' | 'MEDEVAC' | 'NONRVSM' | 'SAR' | 'STATE';
type EURSTSIndicator = 'CPDLCX' | 'EXM833' | 'PROTECTED' | 'RNAVINOP' | 'RNAVX' | 'OAT';
type AircraftOperatorName_DataType = string;
type SurveillanceEquipment = {
    modeA?: EquipmentStatus;
    modeAAndC?: EquipmentStatus;
    modeS?: EquipmentStatus;
    modeSCapabilities?: ModeSCapabilities;
    adsb1900Out?: EquipmentStatus;
    adsb1900OutInt?: EquipmentStatus;
    adsbOutUAT?: EquipmentStatus;
    adsbOutInUAT?: EquipmentStatus;
    adsbOutVDL4?: EquipmentStatus;
    adsbOutInVDL4?: EquipmentStatus;
    adscFans?: EquipmentStatus;
    adscAtn?: EquipmentStatus;
};
type ModeSCapabilities = {
    aircraftIdentification?: EquipmentStatus;
    pressureAltitude?: EquipmentStatus;
    extendedSquitterADSB?: EquipmentStatus;
    enhancedSurveillance?: EquipmentStatus;
};
type FlightType = 'GENERAL' | 'MILITARY' | 'NOT_SCHEDULED' | 'OTHER' | 'SCHEDULED';
type EnrouteDelay = {
    delay?: DurationHourMinute;
    point?: ICAOPoint;
};
type FlightRules = 'IFR' | 'IFR_THEN_VFR' | 'VFR' | 'VFR_THEN_IFR';
type EstimatedElapsedTimeAtLocation = {
    elapsedTime: DurationHourMinute;
    fir?: FIRICAOId;
    point?: ICAOPoint;
    latitude?: Latitude;
    longitude?: Longitude;
};
interface CDM {
    status: 'ACTUAL_OFFBLOCK' | 'DEPARTING_FROM_CDM_AIRPORT' | 'DEPARTING_FROM_STANDARD_AIRPORT' | 'ESTIMATED' | 'PREDICTED' | 'PRE_SEQUENCED' | 'TARGETED';
    airportType: DepartureAirportType;
    info?: CDMInfo;
}
type DepartureAirportType = 'STANDARD' | 'ADVANCED_ATC_TWR' | 'CDM';
interface CDMInfo {
    turnaroundTargetTakeOffTime?: DateTimeMinute;
    earliestTargetTakeOffTime?: DateTimeMinute;
    consolidatedTargetTakeOffTime?: DateTimeMinute;
    atcTargetTakeOffTime?: DateTimeMinute;
    taxiTime?: DurationHourMinuteSecond;
    offBlockTimeDiscrepancy: boolean;
    flightStatusOutbound?: ATVFlightStatusOutbound;
    departureProc?: TerminalProcedure;
    departureRunway?: RunwayId$1;
    departureTerminal?: TerminalOrApronStandName;
    departureApronStand?: TerminalOrApronStandName;
    aircraftTypeDiscrepancy: boolean;
    aircraftType?: AircraftType;
    aircraftTypeIATA?: AircraftTypeIATAId;
    registrationMark?: AircraftRegistrationMark;
    registrationMarkDiscrepancy?: boolean;
    departureStatus: DepartureStatus;
    targetOffBlockTime?: DateTimeMinute;
    targetStartupApprovalTime?: DateTimeMinute;
    aircraftIdInbound?: AircraftICAOId;
    ifplIdInbound?: IFPLId;
    registrationMarkInbound?: AircraftRegistrationMark;
    cancelReason?: ReasonForDPICancellation;
}
type TerminalOrApronStandName = string;
type AircraftTypeIATAId = string;
type ReasonForDPICancellation = 'FLIGHT_CANCEL_IN_AODB' | 'FLIGHT_PLAN_INVALID' | 'NO_AIRPORT_SLOT' | 'RETURN_TO_STAND' | 'TOBT_UNKNOWN_OR_EXPIRED' | 'TSAT_EXPIRED' | 'UNDEFINED' | 'UNDO_ADPI';
type ATVFlightStatusOutbound = 'BRC' | 'BRD' | 'CNX' | 'DEI' | 'DEP' | 'INI' | 'OBK' | 'RDI' | 'RDY' | 'RET' | 'RPO' | 'RTN' | 'SCH' | 'TXD';
type ATVFlightStatusInbound = 'AIR' | 'CNX' | 'DBC' | 'BDR' | 'DIV' | 'FIR' | 'FNL' | 'GOA' | 'IBK' | 'IDH' | 'INI' | 'SCH' | 'TMA' | 'TXI';
type DepartureStatus = 'OK' | 'DEICING';
interface ExclusionFromRegulations {
    onTrafficVolume?: boolean;
    count?: number;
    all?: boolean;
    hasBeenExcluded: boolean;
}
interface ReroutingReference {
    name?: string;
    validTo?: DateTimeMinute;
}
interface DepartureTolerance {
    toleranceWindow: TimeHourMinutePeriod;
    extended: boolean;
}
interface FlightPoint {
    timeOver: DateTimeSecond;
    flightLevel: FlightLevel;
    entryTrend: FlightTrend;
    exitTrend: FlightTrend;
    associatedRouteOrTerminalProcedure?: RouteOrTerminalProcedure;
    coveredDistance: DistanceNM;
    isVisible: boolean;
    aerodrome?: AerodromeICAOId;
    point?: ICAOPoint;
    flightPlanPoint?: boolean;
}
interface FlightAirspace {
    airspaceId: AirspaceId;
    airspaceType: AirspaceType;
    firstEntryTime: DateTimeSecond;
    firstEntryFlightLevel: FlightLevel;
    lastExitFlightLevel: FlightLevel;
    firstEntryTrend: FlightTrend;
    middleTrend: FlightTrend;
    firstEntryDistance: DistanceNM;
    lastExitTime: DateTimeSecond;
    lastExitTrend: FlightTrend;
    lastExitDistance: DistanceNM;
    occupancyDuration: DurationHourMinuteSecond;
    occupancyDistance: DistanceNM;
    activated: boolean;
}
interface RequestedFlightLevel {
    flightLevel: FlightLevel;
    segmentSequenceNumber: number;
    relativeDistance: number;
}
interface FlightEvent {
    timestamp: DateTimeSecond;
    type: FlightEventType;
    resultingState: FlightState;
    resultingOffBlockTime: DateTimeMinute;
    efdSent: boolean;
    fumSent: boolean;
}
type FlightEventType = string;
interface FlightOperationalLogEntry {
    timestamp?: DateTimeSecond;
    type?: FlightOperationalLogEntryType;
    etfmsId?: number;
    ifplId?: IFPLId;
    issuer?: string;
    message?: string;
    summaryFields?: string[];
}
type FlightOperationalLogEntryType = 'ENVIRONMENT_MESSAGE' | 'ERRONEOUS_INCOMING_MESSAGE' | 'ERROR_MESSAGE' | 'HISTORY' | 'INCOMING_MESSAGE' | 'OUTGOING_MESSAGE' | 'PROCESS_ERROR' | 'TEXT_MESSAGE' | 'UNDEFINED' | 'USER_COMMAND' | 'VIOLATION' | 'WARNING';
interface EquipmentCapabilityAndStatus {
    gbas?: EquipmentStatus;
    lvp?: EquipmentStatus;
    loranC?: EquipmentStatus;
    dme?: EquipmentStatus;
    fmcWprAcars?: EquipmentStatus;
    dFisAcars?: EquipmentStatus;
    pdcAcars?: EquipmentStatus;
    adf?: EquipmentStatus;
    gnss?: EquipmentStatus;
    hfRtf?: EquipmentStatus;
    inertialNavigation?: EquipmentStatus;
    cpdlcAtnVdlMode2?: EquipmentStatus;
    cpdlcFans1AHFDL?: EquipmentStatus;
    cpdlcFans1AVdlModeA?: EquipmentStatus;
    cpdlcFans1AVdlMode2?: EquipmentStatus;
    cpdlcFans1ASatcomInmarsat?: EquipmentStatus;
    cpdlcFans1ASatcomMtsat?: EquipmentStatus;
    cpdlcFans1ASatcomIridium?: EquipmentStatus;
    mls?: EquipmentStatus;
    ils?: EquipmentStatus;
    atcRtfSatcomInmarsat?: EquipmentStatus;
    atcRtfSatcomMtsat?: EquipmentStatus;
    atcRtfSatcomIridium?: EquipmentStatus;
    vor?: EquipmentStatus;
    rcp1?: EquipmentStatus;
    rcp2?: EquipmentStatus;
    rcp3?: EquipmentStatus;
    rcp4?: EquipmentStatus;
    rcp5?: EquipmentStatus;
    rcp6?: EquipmentStatus;
    rcp7?: EquipmentStatus;
    rcp8?: EquipmentStatus;
    rcp9?: EquipmentStatus;
    pbnApproved?: EquipmentStatus;
    standard?: EquipmentStatus;
    tacan?: EquipmentStatus;
    uhfRtf?: EquipmentStatus;
    vhfRtf?: EquipmentStatus;
    rvsm?: EquipmentStatus;
    mnps?: EquipmentStatus;
    khz833?: EquipmentStatus;
    other?: EquipmentStatus;
}
type EquipmentStatus = 'EQUIPPED' | 'NOT_EQUIPPED';
interface FlightRestriction {
    timeOver: DateTimeSecond;
    coveredDistance: DistanceNM;
    flightPlanProcessing: FlightPlanProcessing;
    restrictionId: RestrictionId;
    event: EntryExit;
    position: Position$1;
    flightLevel: FlightLevel;
}
type EntryExit = 'ENTRY' | 'EXIT';
type CfmuFlightType = 
/**
 * Mini-flight created for the usage of CCAMS when the flight is unknown to NM.
 */
'MFD'
/**
 * Flight created from a flight plan filed to IFPS.
 */
 | 'IFPL'
/**
 * Flight is ATC activated.
 */
 | 'ACT'
/**
 * Flight activated by NM.
 */
 | 'TACT_ACTIVATED'
/**
 * Flight is terminated.
 */
 | 'TERMINATED'
/**
 * Predicted flight data.
 */
 | 'PREDICTED_FLIGHT';
type LoadStateAtReferenceLocation = {
    ENTRY: LoadState;
} | {
    OCCUPANCY: OtmvStatus;
};
interface DeltaEntry {
    intruderKind: IntruderKind;
    originOfIntruder?: AirspaceId;
    deltaMinutes: number;
    deltaFlightLevel: number;
    deltaPosition: DistanceNM;
}
type IntruderKind = 'HORIZONTAL_INTRUDER' | 'unknown_INTRUDER' | 'NON_INTRUDER' | 'VERTICAL_INTRUDER';
type CTOTLimitReason = 'FORCED_BY_CHAMAN' | 'FORCED_BY_NMOC' | 'FORCED_BY_STAM_MEASURE' | 'FORCED_BY_TOWER' | 'LIMITED_BY_VIOLATION' | 'LIMITED_BY_VIOLATION_THEN_ZERO_RATE_OR_RVR' | 'SLOT_EXTENSION' | 'SLOT_TIME_NOT_LIMITED' | 'WAS_FORCED_BY_NMOC';
interface ProfileValidity {
    profileValidityKind: ProfileValidityKind;
    lastValidEOBT: DateTimeMinute;
}
type ProfileValidityKind = 'NO_VIOLATIONS' | 'UNKNOWN' | 'VIOLATIONS';
interface TargetTime {
    regulationId: RegulationId;
    targetTime: DateTimeSecond;
    targetLevel: FlightLevel;
    aerodromeICAOId?: AerodromeICAOId;
    point?: ICAOPoint;
    flightPlanPoint?: boolean;
    coveredDistance: DistanceNM;
    actualTimeAtTarget?: ActualTimeAtTarget;
}
interface FourDPosition {
    timeOver: DateTimeSecond;
    position: Position;
    level: FlightLevel;
}
interface Position {
    latitude?: Latitude;
    longitude?: Longitude;
}
type Latitude = number;
type Longitude = number;
interface ActualTimeAtTarget {
    estimatedActualTimeAtTarget: DateTimeSecond;
    targetTimeCompliance: IntervalPosition;
}
type IntervalPosition = 'AFTER' | 'BEFORE' | 'INSIDE';
interface FlightListRequest {
    dataset: Dataset;
    includeProposalFlights: boolean;
    includeForecastFlights: boolean;
    trafficType: TrafficType;
    trafficWindow?: DateTimeMinutePeriod;
    worstLoadStateAtReferenceLocationType?: CountsCalculationType;
    compareWithOtherTrafficType?: TrafficType;
    requestedFlightFields?: FlightField[];
}
interface FlightListByLocationRequest extends FlightListRequest {
    countsInterval?: CountsInterval;
    aircraftOperators?: AircraftOperatorICAOId[];
    includeInvisibleFlights?: boolean;
}
interface FlightListByAirspaceRequest extends FlightListRequest {
    calculationType?: CountsCalculationType;
    airspace: AirspaceId;
}
type FlightOrFlightPlan = {
    flight: Flight;
} | {
    flightPlan: FlightPlanOrInvalidFiling;
};
type FlightPlanOrInvalidFiling = {
    lastValidFlightPlan: FlightPlanSummary;
} | {
    currentInvalid: InvalidFiling;
};
interface FlightPlanSummary {
    id: FlightIdentificationOutput;
    status: FlightPlanStatus;
}
type FlightPlanStatus = 'AIRBORNE' | 'BACKUP' | 'CLOSED' | 'FILED' | 'OFFBLOCKS' | 'SUSPENDED' | 'TACT_DELETED' | 'TERMINATED';
type FlightPlanMessageType = 'ACH' | 'AFP' | 'APL' | 'ARR' | 'CHG' | 'CNL' | 'DEP' | 'DLA' | 'FNM' | 'FPL' | 'MFS' | 'RQP' | 'RQS';
type FlightPlanMessageStatus = 'DELETED' | 'DISCARD' | 'INVALID' | 'MULTIPLE' | 'REFERRED' | 'REJECTED';
interface InvalidFiling {
    filingTime: DateTimeSecond;
    invalidMessageType: FlightPlanMessageType;
    invalidMessageStatus: FlightPlanMessageStatus;
    keys?: FlightKeys;
}
interface FlightListReplyData {
    flights?: Array<FlightOrFlightPlan>;
}
interface FlightListByLocationReplyData extends FlightListReplyData {
    effectiveTrafficWindow: DateTimeMinutePeriod;
}
type FlightListByAirspaceReply = ReplyWithData<FlightListByAirspaceReplyData>;
interface FlightListByAirspaceReplyData extends FlightListByLocationReplyData {
}
interface FlightPlanListRequest {
    aircraftId?: string;
    aerodromeOfDeparture?: string;
    nonICAOAerodromeOfDeparture: boolean;
    airFiled: boolean;
    aerodromeOfDestination?: string;
    nonICAOAerodromeOfDestination: boolean;
    estimatedOffBlockTime: DateTimeMinutePeriod;
}
type FlightPlanListReply = ReplyWithData<FlightPlanListReplyData>;
type FlightPlanListReplyData = {
    summaries: FlightPlanOrInvalidFiling[];
};
interface FlightRetrievalRequest {
    dataset: Dataset;
    includeProposalFlights: boolean;
    flightId: FlightIdentificationInput;
    requestedFlightDatasets: FlightDataset[];
    requestedFlightFields?: FlightField[];
}
type FlightRetrievalReply = ReplyWithData<FlightRetrievalReplyData>;
type FlightRetrievalReplyData = {
    latestFlightPlan?: FlightPlanOutput;
    flightPlanHistory?: FlightPlanHistory;
    flight?: Flight;
    structuredFlightPlan?: StructuredFlightPlan;
};
interface FlightListByTrafficVolumeRequest extends FlightListByLocationRequest {
    calculationType?: CountsCalculationType;
    trafficVolume: TrafficVolumeId;
    flow?: FlowId;
}
type FlightListByTrafficVolumeReply = ReplyWithData<FlightListByTrafficVolumeReplyData>;
interface FlightListByTrafficVolumeReplyData extends FlightListByLocationReplyData {
}
interface FlightListByMeasureRequest extends FlightListByLocationRequest {
    measure: MeasureId;
    mode: FlightListByMeasureMode;
}
type FlightListByMeasureMode = 'ACTIVATED_BY_MEASURE' | 'CONCERNED_BY_MEASURE';
type FlightListByMeasureReply = ReplyWithData<FlightListByMeasureReplyData>;
interface FlightListByMeasureReplyData extends FlightListByLocationReplyData {
}
interface FlightListByAerodromeRequest extends FlightListByLocationRequest {
    aerodrome: AerodromeICAOId;
    aerodromeRole: AerodromeRole;
}
type AerodromeRole = 
/**
 * The aerodrome is meant as of departure.
 */
'DEPARTURE'
/**
 * The aerodrome is meat as of arrival.
 */
 | 'ARRIVAL'
/**
 * The aerodrome is meat as of departure or arrival.
 */
 | 'GLOBAL'
/**
 * The aerodrome is meat as of alternate.
 */
 | 'ALTERNATE';
type FlightListByAerodromeReply = ReplyWithData<FlightListByAerodromeReplyData>;
interface FlightListByAerodromeReplyData extends FlightListByLocationReplyData {
}
interface FlightListByAerodromeSetRequest extends FlightListByLocationRequest {
    aerodromeSet: AerodromeSetId;
    aerodromeRole: AerodromeRole;
}
type FlightListByAerodromeSetReply = ReplyWithData<FlightListByAerodromeSetReplyData>;
interface FlightListByAerodromeSetReplyData extends FlightListByLocationReplyData {
}
interface FlightListByAircraftOperatorRequest extends FlightListByLocationRequest {
    calculationType?: CountsCalculationType;
}
type FlightListByAircraftOperatorReply = ReplyWithData<FlightListByAircraftOperatorReplyData>;
interface FlightListByAircraftOperatorReplyData extends FlightListByLocationReplyData {
}

export type { RegulationReason as $, CapacityPlanUpdateReply as A, OTMVPlanUpdateRequest as B, CapacityPlanRetrievalRequest as C, OTMVPlanUpdateReply as D, ReroutingId as E, FlightRetrievalRequest as F, RegulationId as G, HotspotListRequest as H, FlowId as I, ScenarioId as J, SectorConfigurationId as K, RegulationIdWildcard as L, MeasureId as M, FlightRegulationLocation as N, OTMVPlanRetrievalRequest as O, PlanDataSource as P, FlightAtfcmMeasureLocationCommon as Q, RegulationListRequest as R, SectorConfigurationPlanRetrievalRequest as S, TrafficCountsByAirspaceRequest as T, FlightAtfcmRegulationLocation as U, FlightAtfcmReroutingLocation as V, ReroutingApplyKind as W, ReroutingPurpose as X, FlightAtfcmMeasureLocation as Y, RegulationCause as Z, RegulationLocationCategory as _, FlightRetrievalReply as a, RegulationExceptionalConstraint as a$, FlightHotspotLocation as a0, Hotspot as a1, HotspotSeverity as a2, HotspotStatus as a3, HotspotId as a4, FlightMCDMInfo as a5, MCDMState as a6, OtmvStatus as a7, CountsCalculationType as a8, CountsInterval as a9, MeasureListRequest as aA, Regulation as aB, TrafficVolumeScenarios as aC, ScenarioTrafficVolumeMatchingKind as aD, IRegulationOrMCDMOnly as aE, RegulationOrMCDMOnly as aF, Measure as aG, MeasureSubType as aH, MeasureFromScenarioRepository as aI, LifeCycleEvent as aJ, MCDMMeasureTopic as aK, MCDMStatefulTopic as aL, MCDMTopic as aM, MCDMTopicId as aN, MCDMRoleUserCategory as aO, MCDMDeadlines as aP, MCDMFlightTopic as aQ, EhelpDeskTicketChoice as aR, MCDMUserAndRole as aS, MCDMCoordinationLevel as aT, MCDMUserCategory as aU, MCDMUserRoleAndApprovalState as aV, MCDMRole as aW, MCDMApprovalState as aX, LifeCycleEventType as aY, TrafficVolumeLocation as aZ, RegulationInitialConstraint as a_, RegulationField as aa, TacticalConfigurationRetrievalRequest as ab, SectorConfigurationPlanRetrievalReplyData as ac, KnownConfigurations as ad, SectorConfigurationPlan as ae, CapacityPlans as af, PlannedSectorConfigurationActivation as ag, TacticalConfigurationPlan as ah, TrafficCountsRequest as ai, CountSubTotalComputeMode as aj, TrafficCountsReplyData as ak, Flow as al, ScenarioImpact as am, FlowType as an, FlowRoleSelection as ao, Counts as ap, CountsValue as aq, OTMVThresholds as ar, SubTotalsTrafficCountsType as as, SubTotalsRegulationDetailedType as at, OtmvAlert as au, RegulationState as av, RegulationListReplyData as aw, RegulationOrMCDMOnlyListReplyData as ax, MeasureListReplyData as ay, RegulationOrMCDMOnlyListRequest as az, FlightListByAirspaceRequest as b, ACDMAlertCode as b$, RegulationSupplementaryConstraint as b0, RegulationOccupancyConstraint as b1, HotspotKind as b2, HotspotListReplyData as b3, HotspotPlans as b4, OTMVWithDuration as b5, OTMVPlans as b6, OTMVPlanForDuration as b7, PlannedOTMV as b8, OTMV as b9, AircraftTypeICAOId as bA, OtherAircraftTypeDesignation_DataType as bB, AircraftOperatorICAOId as bC, AircraftIATAId as bD, FlightTrend as bE, FlightState as bF, ATFMMessageType as bG, FlightKeys as bH, IATAFlightKeys as bI, TimeAndModel as bJ, TrafficType as bK, FlightField as bL, FlightPlanOutput as bM, BasicTrajectoryData as bN, DistanceAtLocation as bO, PointDAL as bP, AerodromeDAL as bQ, Relative4DPoint as bR, DepartureData as bS, FIXMFlight as bT, StructuredFlightPlan as bU, FlightPlanHistory as bV, FlightPlanHistoryInfo as bW, Flight as bX, ReroutingFeedbackKind as bY, ReroutingFeedbackReason as bZ, ReroutingFeedback as b_, OTMVPeak as ba, OTMVSustained as bb, OTMVThreshold as bc, OTMVPlanRetrievalReplyData as bd, OTMVPlanUpdateReplyData as be, CapacityPlanRetrievalReplyData as bf, PlannedCapacities as bg, PlannedCapacity as bh, Capacity as bi, CapacityPlanUpdateReplyData as bj, RunwayConfigurationPlanRetrievalData as bk, RunwayConfigurationPlan as bl, RunwayId as bm, RunwayConfigurationPlanSchedule as bn, RunwayConfiguration as bo, RunwayUsage as bp, IFPLId as bq, FlightDataset as br, FlightIdentificationInput as bs, FlightIdentificationOutput as bt, AircraftICAOId as bu, ExtendedAircraftICAOId as bv, AircraftRegistrationMark as bw, ICAOAircraftAddress as bx, SSRCode as by, SSRMode as bz, FlightListByAirspaceReply as c, CDM as c$, ACDMAlertSeverity as c0, ACDMAlertData as c1, AircraftIATAIdFromDataSource as c2, AircraftIdDataSource as c3, FlightTrafficVolume as c4, FlightVisibility as c5, APISubmissionRules as c6, WakeTurbulenceCategory as c7, FlightCriticalityIndicator as c8, GroupReroutingSummary as c9, AlternateAerodrome as cA, AerodromesOfDestination as cB, AlternateAerodrome_DataType as cC, SSRInfo as cD, AircraftIdentification as cE, AircraftType as cF, FlightPlan as cG, SupplementaryInformation as cH, FrequencyOnAircraft as cI, SurvivalEquipment as cJ, LifeJacketEquipment as cK, Dinghies as cL, OtherInformation as cM, ReclearanceInFlight as cN, PerformanceBasedNavigationCode as cO, DatalinkCapabilities as cP, AircraftPerformanceCategory as cQ, SpecialHandlingIndicators as cR, ICAOSTSIndicator as cS, EURSTSIndicator as cT, AircraftOperatorName_DataType as cU, SurveillanceEquipment as cV, ModeSCapabilities as cW, FlightType as cX, EnrouteDelay as cY, FlightRules as cZ, EstimatedElapsedTimeAtLocation as c_, GroupReroutingIndicator as ca, FlightCriticalityKind as cb, TurnFlightForLocation as cc, TurnFlightForLocationKind as cd, YoYoFlightForLocation as ce, YoYoFlightForLocationKind as cf, ArrivalInformation as cg, ImpactSeverityIndicator as ch, ProposalInformation as ci, ReroutingRouteId as cj, StandardRouteId as ck, ReroutingRouteType as cl, ProposalKind as cm, MessageOriginator as cn, TaxiTimeAndProcedure as co, TaxiTimeSource as cp, SuspensionStatus as cq, FAMStatus as cr, ReadyStatus as cs, ReroutingIndicator as ct, ReroutingReason as cu, ReroutingState as cv, OtherAerodromeDesignation as cw, Aerodrome as cx, AirFiledData as cy, AtsUnitId_DataType as cz, FlightPlanListRequest as d, DepartureAirportType as d0, CDMInfo as d1, TerminalOrApronStandName as d2, AircraftTypeIATAId as d3, ReasonForDPICancellation as d4, ATVFlightStatusOutbound as d5, ATVFlightStatusInbound as d6, DepartureStatus as d7, ExclusionFromRegulations as d8, ReroutingReference as d9, IntervalPosition as dA, FlightListRequest as dB, FlightListByLocationRequest as dC, FlightOrFlightPlan as dD, FlightPlanOrInvalidFiling as dE, FlightPlanSummary as dF, FlightPlanStatus as dG, FlightPlanMessageType as dH, FlightPlanMessageStatus as dI, InvalidFiling as dJ, FlightListReplyData as dK, FlightListByLocationReplyData as dL, FlightListByAirspaceReplyData as dM, FlightPlanListReplyData as dN, FlightRetrievalReplyData as dO, FlightListByTrafficVolumeReplyData as dP, FlightListByMeasureMode as dQ, FlightListByMeasureReplyData as dR, AerodromeRole as dS, FlightListByAerodromeReplyData as dT, FlightListByAerodromeSetReplyData as dU, FlightListByAircraftOperatorReplyData as dV, DepartureTolerance as da, FlightPoint as db, FlightAirspace as dc, RequestedFlightLevel as dd, FlightEvent as de, FlightEventType as df, FlightOperationalLogEntry as dg, FlightOperationalLogEntryType as dh, EquipmentCapabilityAndStatus as di, EquipmentStatus as dj, FlightRestriction as dk, EntryExit as dl, CfmuFlightType as dm, LoadStateAtReferenceLocation as dn, DeltaEntry as dp, IntruderKind as dq, CTOTLimitReason as dr, ProfileValidity as ds, ProfileValidityKind as dt, TargetTime as du, FourDPosition as dv, Position as dw, Latitude as dx, Longitude as dy, ActualTimeAtTarget as dz, FlightPlanListReply as e, FlightListByTrafficVolumeRequest as f, FlightListByTrafficVolumeReply as g, FlightListByMeasureRequest as h, FlightListByMeasureReply as i, FlightListByAerodromeRequest as j, FlightListByAerodromeReply as k, FlightListByAerodromeSetRequest as l, FlightListByAerodromeSetReply as m, FlightListByAircraftOperatorRequest as n, FlightListByAircraftOperatorReply as o, HotspotListReply as p, RegulationListReply as q, TrafficCountsByAirspaceReply as r, TrafficCountsByTrafficVolumeRequest as s, TrafficCountsByTrafficVolumeReply as t, CapacityPlanRetrievalReply as u, OTMVPlanRetrievalReply as v, RunwayConfigurationPlanRetrievalRequest as w, RunwayConfigurationPlanRetrievalReply as x, SectorConfigurationPlanRetrievalReply as y, CapacityPlanUpdateRequest as z };