@dgac/nmb2b-client/dist/types-D7FL-6Eb.d.cts

EUROCONTROL Network Manager B2B SOAP client

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;
    rc