@almaobservatory/model 1.0.0

package/index.d.ts

@@ -0,0 +1,1777 @@
+import * as rxjs_dist_types from 'rxjs/dist/types';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { RxStomp } from '@stomp/rx-stomp';
+
+interface EntityRef {
+    entityId: string;
+    partId: string;
+    entityTypeName: string;
+    documentVersion: string;
+}
+
+type SchedBlockRef = EntityRef;
+
+interface AbstractBaseBandConfig {
+    baseBandSpecificationRef: SchedBlockRef;
+    dataProducts: string;
+}
+
+interface DoubleWithUnit {
+    value?: number;
+    unit?: string;
+}
+
+type Time = DoubleWithUnit;
+
+interface AbstractCorrelatorConfiguration {
+    integrationDuration: Time;
+    channelAverageDuration: Time;
+    enable180DegreeWalshFunction: boolean;
+    enable90DegreeWalshFunction: boolean;
+    cam: string;
+    apcdataSets: string;
+    looffsettingMode: string;
+}
+
+interface AbstractInstrumentSpec {
+    name: string;
+    entityPartId: string;
+    almatype: string;
+}
+
+type ObsProjectRef = EntityRef;
+
+interface AbstractScienceGoal {
+    name?: string;
+    note?: string;
+    obsUnitSetRef?: ObsProjectRef;
+}
+
+type Frequency = DoubleWithUnit;
+
+interface AbstractSpectralLine {
+    restFrequency: Frequency;
+    transition: string;
+    spatalogId: string;
+    description: string;
+}
+
+type ExpectedSpectralLine = AbstractSpectralLine;
+
+interface BaseBandSpecification {
+    centerFrequency: Frequency;
+    frequencySwitching: boolean;
+    lo2Frequency: Frequency;
+    weighting: number;
+    useUSB: boolean;
+    use12GHzFilter: boolean;
+    imageCenterFrequency: Frequency;
+    imageWeighting: number;
+    entityPartId: string;
+    almatype: string;
+    baseBandName: string;
+    sideBandPreference: string;
+}
+
+interface FrequencySetup {
+    restFrequency: Frequency;
+    transitionName: string;
+    lo1Frequency: Frequency;
+    isUserSpecifiedLO1: boolean;
+    hasHardwareSetup: boolean;
+    floog: Frequency;
+    tuneHigh: boolean;
+    baseBandSpecifications: BaseBandSpecification[];
+    receiverBand: string;
+    dopplerReference: string;
+}
+
+interface AdvancedWindowSetup {
+    addedSensitivity?: boolean;
+    displayImage?: boolean;
+    imageCentreFrequency?: FrequencySetup;
+    oversampling?: boolean;
+    smoothingFactor?: number;
+    smoothingFunction?: string;
+    useImage?: boolean;
+    useThis?: boolean;
+}
+
+interface AbstractScienceSpectralWindow {
+    '@type'?: string;
+    index?: number;
+    advancedWindowSetup?: AdvancedWindowSetup;
+    expectedSpectralLines?: ExpectedSpectralLine[];
+}
+
+interface SpectralLine {
+    restFrequency: Frequency;
+    transition: string;
+    spatalogId: string;
+}
+
+interface AbstractSpectralWindow {
+    centerFrequency: Frequency;
+    spectralAveragingFactor: number;
+    name: string;
+    effectiveBandwidth: Frequency;
+    effectiveNumberOfChannels: number;
+    associatedSpectralWindowNumberInPair: number;
+    useThisSpectralWindow: boolean;
+    desiredCenterFrequency: Frequency;
+    representativeWindow: boolean;
+    spectralLines: SpectralLine[];
+    sideBand: string;
+    windowFunction: string;
+    polnProducts: string;
+}
+
+interface AbstractSwitchingCycle {
+    numberOfPositions: number;
+    dwellTime: Time;
+}
+
+interface AbstractSwitchingState {
+    dwellTime: Time;
+    bin: number;
+}
+
+type Longitude = DoubleWithUnit;
+
+type Latitude = DoubleWithUnit;
+
+interface SkyCoordinates {
+    longitude?: Longitude;
+    latitude?: Latitude;
+    fieldName?: string;
+    system?: string;
+    type?: string;
+}
+
+type AngularVelocity = DoubleWithUnit;
+
+type Angle = DoubleWithUnit;
+
+type Speed = DoubleWithUnit;
+
+interface Velocity {
+    centerVelocity?: Speed;
+    referenceSystem?: string;
+    dopplerCalcType?: string;
+}
+
+type ObsAttachmentRef = EntityRef;
+
+type Flux = DoubleWithUnit;
+
+interface UserFrequency extends Frequency {
+    userUnit: string;
+}
+
+interface ExpectedProperties {
+    expectedPeakFluxDensity?: Flux;
+    desiredPolarizationPercentage?: number;
+    expectedLineWidth?: UserFrequency;
+    referenceFrequency?: Frequency;
+    expectedPeakLineFluxDensity?: Flux;
+    expectedSpectralDynamicRange?: number;
+    expectedImageDynamicRange?: number;
+    desiredLinePolarizationPercentage?: number;
+    desiredLineCircularPolarizationPercentage?: number;
+    desiredCircularPolarizationPercentage?: number;
+    isPassivePhasing?: boolean;
+    solarActivityLevel?: string;
+}
+
+interface AbstractTargetParameters {
+    sourceName?: string;
+    sourceCoordinates?: SkyCoordinates;
+    pmRA?: AngularVelocity;
+    pmDec?: AngularVelocity;
+    parallax?: Angle;
+    nonSiderealMotion?: boolean;
+    sourceEphemeris?: string;
+    sourceVelocity?: Velocity;
+    ephemerisFileName?: string;
+    index?: number;
+    sdReferencePositions?: SkyCoordinates[];
+    solarMappingDiameter?: Angle;
+    expectedProperties?: ExpectedProperties;
+    imageRef?: ObsAttachmentRef;
+    solarSystemObject?: string;
+    solarMapping?: string;
+    solarMappingPattern?: string;
+    '@type'?: string;
+}
+
+interface AbstractTimingConstraints {
+    startTime: string;
+    endTime: string;
+    allowedMargin: Time;
+    repeats: number;
+    note: string;
+    isAvoidConstraint: boolean;
+    priority: number;
+    isFixedStart: boolean;
+    lstmin: string;
+    lstmax: string;
+}
+
+interface ChannelAverageRegion {
+    startChannel: number;
+    numberChannels: number;
+}
+
+interface ACASpectralWindow extends AbstractSpectralWindow {
+    frqChProfReproduction: boolean;
+    channelAverageRegions: ChannelAverageRegion[];
+    synthProf: string;
+}
+
+interface AcaBaseBandConfig extends AbstractBaseBandConfig {
+    centerFreqOfResidualDelay: Frequency;
+    acaspectralWindows: ACASpectralWindow[];
+}
+
+interface AcaPhaseSwitchingConfiguration {
+    doD180Modulation: boolean;
+    doD180Demodulation: boolean;
+}
+
+interface AcaCorrelatorConfiguration extends AbstractCorrelatorConfiguration {
+    acabaseBandConfigs: AcaBaseBandConfig[];
+    acaphaseSwitchingConfiguration: AcaPhaseSwitchingConfiguration;
+}
+
+interface AcaSpectrometerCorrelatorConfiguration extends AbstractCorrelatorConfiguration {
+    acabaseBandConfigs: AcaBaseBandConfig[];
+    acaphaseSwitchingConfiguration: AcaPhaseSwitchingConfiguration;
+}
+
+interface AdvancedSpectralSetup {
+    sideBandSeparation?: boolean;
+    fastMode?: boolean;
+}
+
+type DataRate = DoubleWithUnit;
+
+type StorageVolume = DoubleWithUnit;
+
+interface ArrayDataRates {
+    estimatedAverageDataRate: DataRate;
+    estimatedMaximumDataRate: DataRate;
+    estimatedDataVolume: StorageVolume;
+    arrayName: string;
+}
+
+interface ArrayTime {
+    estimatedTime: Time;
+    arrayName: string;
+}
+
+interface ArrayTimeBreakdown {
+    arrayTimes: ArrayTime[];
+}
+
+interface BeamSwitchingState extends AbstractSwitchingState {
+    position: Angle;
+    transition: Time;
+}
+
+interface BeamSwitchingCycle extends AbstractSwitchingCycle {
+    beamSwitchingStates: BeamSwitchingState[];
+    mode: string;
+}
+
+interface BlSpectralWindow extends AbstractSpectralWindow {
+    correlationNyquistOversampling: boolean;
+    quantizationCorrection: boolean;
+    channelAverageRegions: ChannelAverageRegion[];
+    correlationBits: string;
+}
+
+interface BlBaseBandConfig extends AbstractBaseBandConfig {
+    blspectralWindows: BlSpectralWindow[];
+}
+
+interface BlCorrelatorConfiguration extends AbstractCorrelatorConfiguration {
+    dumpDuration: Time;
+    blbaseBandConfigs: BlBaseBandConfig[];
+}
+
+interface CalibrationRequirements {
+    pointingAccuracy: Angle;
+    bandpassAccuracy?: number;
+    polarizationAccuracy?: number;
+}
+
+interface CalibrationTargetProperties {
+    frequency: Frequency;
+    flux: Flux;
+    dateOfMeasurement: string;
+}
+
+interface CalibrationTargetParameters {
+    sourceName: string;
+    sourceCoordinates: SkyCoordinates;
+    sourceVelocity: Velocity;
+    index: number;
+    nonSiderealMotion: boolean;
+    calibrationTargetProperties: CalibrationTargetProperties[];
+    intendedUse: string;
+    solarSystemObject: string;
+}
+
+interface QuerySource {
+    queryCenter: SkyCoordinates;
+    searchRadius: Angle;
+    minFrequency: Frequency;
+    maxFrequency: Frequency;
+    minFlux: Flux;
+    maxFlux: Flux;
+    minTimeSinceObserved: Time;
+    maxTimeSinceObserved: Time;
+    use: string;
+    maxSources: number;
+    index: number;
+    intendedUse: string;
+}
+
+interface CalibrationSetupParameters {
+    isDGCOverride?: boolean;
+    calibrationTargetParameters?: CalibrationTargetParameters[];
+    querySources?: QuerySource[];
+    selection?: string;
+    positionalAccuracy?: string;
+    forcedDGCStrategy?: string;
+}
+declare const buildCalibrationTargetParameter: (intendedUse: any, longitude: any, latitude: any, system?: string) => {
+    sourceName: string;
+    sourceCoordinates: {
+        longitude: {
+            value: any;
+            unit: string;
+        };
+        latitude: {
+            value: any;
+            unit: string;
+        };
+        fieldName: string;
+        system: string;
+        type: string;
+    };
+    sourceVelocity: {
+        centerVelocity: {
+            value: number;
+            unit: string;
+        };
+        referenceSystem: string;
+        dopplerCalcType: string;
+    };
+    index: number;
+    nonSiderealMotion: boolean;
+    calibrationTargetProperties: any[];
+    intendedUse: any;
+    solarSystemObject: string;
+};
+
+interface KeywordValue {
+    keyword: string;
+    value: string;
+}
+
+interface ObservingParameters {
+    name: string;
+    expertParameters: KeywordValue[];
+    entityPartId: string;
+    almatype: string;
+}
+
+interface CalibratorParameters extends ObservingParameters {
+    cycleTime: Time;
+    defaultIntegrationTime: Time;
+    subScanDuration: Time;
+    forceAtmCal: boolean;
+    forceExecution: boolean;
+    dataOrigin: string;
+}
+
+interface UserAngle extends Angle {
+    userUnit: string;
+    userValue?: number;
+}
+
+interface Field {
+    name?: string;
+    centre?: SkyCoordinates;
+    '@type'?: string;
+}
+declare const buildField: (system?: string) => Field;
+
+interface Circle extends Field {
+    radius: Angle;
+    spacing: UserAngle;
+}
+
+interface Cloneable {
+}
+
+interface ControlBlock {
+    maximumTime: Time;
+    userPriority: number;
+    estimatedExecutionTime: Time;
+    tacPriority: number;
+    aggregatedExecutionCount: number;
+    arrayRequested: string;
+}
+
+interface FieldPattern {
+    type: string;
+}
+
+interface CrossPattern extends FieldPattern {
+    patternCenterCoordinates: SkyCoordinates;
+    longitudeLength: Angle;
+    latitudeLength: Angle;
+    scanVelocity: AngularVelocity;
+    orientation: Angle;
+    initialScanDirection: string;
+}
+
+type Sensitivity = DoubleWithUnit;
+
+type Temperature = DoubleWithUnit;
+
+interface DataProcessingParameters {
+    angularResolution: Angle;
+    velocityResolution: Velocity;
+    projectType: string;
+    tbsensitivityGoal: Temperature;
+    rmsgoal: Sensitivity;
+}
+
+interface DataRateBreakdown {
+    arrayDataRates: ArrayDataRates[];
+}
+
+interface DocumentLink {
+    fileName: string;
+    href: string;
+    fileSize: StorageVolume;
+    fileType: string;
+    documentClass: string;
+}
+
+interface Ellipse extends Field {
+    semiMajor: Angle;
+    semiMinor: Angle;
+    spacing: UserAngle;
+    pamajor: Angle;
+}
+
+interface Entity {
+    entityId: string;
+    entityIdEncrypted: string;
+    entityTypeName: string;
+    schemaVersion: string;
+    documentVersion: string;
+    timestamp?: string;
+    datamodelVersion: string;
+}
+
+interface ExecBlockRef {
+    execBlockId: string;
+}
+
+interface ExecutiveFraction {
+    timeFraction: number;
+    name: string;
+}
+
+interface ExtendedScienceSpectralWindow extends AbstractScienceSpectralWindow {
+    '@type': 'ExtendedScienceSpectralWindowT';
+    windowDescription: string;
+    transitionName: string;
+    centerFrequency: Frequency;
+    bandWidth: UserFrequency;
+    spectralResolution: UserFrequency;
+    groupIndex: number;
+    isSkyFrequency: boolean;
+    splatalogId: number;
+    representativeWindow: boolean;
+    groupResourceUse: string;
+}
+
+interface RectanglePattern extends FieldPattern {
+    patternCenterCoordinates: SkyCoordinates;
+    longitudeLength: Angle;
+    latitudeLength: Angle;
+    orthogonalStep: Angle;
+    orientation: Angle;
+    uniDirectionalScan: boolean;
+    scanDirection: string;
+    scanningCoordinateSystem: string;
+}
+
+interface PointingPattern extends FieldPattern {
+    phaseCenterCoordinates: SkyCoordinates[];
+    isMosaic: boolean;
+}
+
+interface FillPattern extends FieldPattern {
+    patternCenterCoordinates: SkyCoordinates;
+    longitudeLength: Angle;
+    latitudeLength: Angle;
+    samplingLength: Angle;
+    orientation: Angle;
+    patternType: string;
+    patternSubtype: string;
+    scanningCoordinateSystem: string;
+}
+
+interface Magnitude {
+    value: number;
+}
+
+interface SourceProperty {
+    sourceFrequency: Frequency;
+    sourceFluxI: Flux;
+    sourceDiameter: Angle;
+    sourceFluxQ: Flux;
+    sourceFluxU: Flux;
+    sourceFluxV: Flux;
+    visibleMagnitude: Magnitude;
+    dateOfMeasurement: string;
+}
+
+interface Reference {
+    referenceCoordinates: SkyCoordinates;
+    integrationTime: Time;
+    cycleTime: Time;
+    subScanDuration: Time;
+}
+
+interface FieldSource {
+    sourceCoordinates: SkyCoordinates;
+    sourceName: string;
+    sourceVelocity: Velocity;
+    sourceEphemeris: string;
+    pmra: AngularVelocity;
+    nonSiderealMotion: boolean;
+    parallax: Angle;
+    name: string;
+    isQuery: boolean;
+    ephemerisFileName: string;
+    rectanglePattern: RectanglePattern;
+    pointingPattern: PointingPattern;
+    fillPattern: FillPattern;
+    crossPattern: CrossPattern;
+    querySource: QuerySource;
+    references: Reference[];
+    sourceProperties: SourceProperty[];
+    imageRef: ObsAttachmentRef;
+    entityPartId: string;
+    almatype: string;
+    solarSystemObject: string;
+    pmdec: AngularVelocity;
+}
+
+interface FlowControl {
+    controlScript: string;
+}
+
+interface FrequencySwitchingState extends AbstractSwitchingState {
+    offset: Frequency;
+}
+
+interface FrequencySwitchingCycle extends AbstractSwitchingCycle {
+    frequencySwitchingStates: FrequencySwitchingState[];
+}
+
+interface HolographyParameters extends ObservingParameters {
+    frequency: Frequency;
+    startFraction: number;
+    speed: AngularVelocity;
+    rowsCal: number;
+    calTime: Time;
+    rowSize: Angle;
+    uniDirectionalScan: boolean;
+    towerName: string;
+    scanDirection: string;
+    calMode: string;
+    nrows: number;
+}
+
+type IntTimeReference = DoubleWithUnit;
+
+type IntTimeSource = DoubleWithUnit;
+
+interface Investigator {
+    fullName: string;
+    organisation: string;
+    verfiedUser: boolean;
+    userId: string;
+    telephone: string;
+    mobile: string;
+    index: number;
+    organisationId: string;
+    firstName: string;
+    surName: string;
+    hasPhD: boolean;
+    allowedExec: string;
+    associatedExec: string;
+    email: string;
+}
+
+type Length = DoubleWithUnit;
+
+interface MonitoringConstraint extends AbstractTimingConstraints {
+    monitoringLength: Time;
+    cycleTime: Time;
+    requiredDelay: Time;
+}
+
+type ObsAttachmentEntity = Entity;
+
+interface ObsAttachment {
+    obsAttachmentEntity: ObsAttachmentEntity;
+    associatedBulkStoreUid: string;
+    documentLinks: DocumentLink[];
+    schemaVersion: string;
+    revision: string;
+    almatype: string;
+}
+
+interface OrderedTarget {
+    index: number;
+    targetRef: SchedBlockRef;
+}
+
+interface ObservingGroup {
+    index: number;
+    name: string;
+    orderedTargets: OrderedTarget[];
+    mainTargetRef: SchedBlockRef;
+}
+
+interface ObsUnitControl extends ControlBlock {
+    calibrationRequirements: CalibrationRequirements;
+}
+
+interface UnitDependencies {
+    executionCount: number;
+    delay: Time;
+    expression: string;
+    dependencyLists: string[];
+    margin: Time;
+}
+
+interface ObsUnit {
+    name: string;
+    note: string;
+    obsUnitControl: ObsUnitControl;
+    unitDependencies: UnitDependencies;
+    obsProjectRef?: ObsProjectRef;
+    status: string;
+}
+
+type OusStatusRef = EntityRef;
+
+interface ObsUnitSet extends ObsUnit {
+    scienceProcessingScript: string;
+    runSciencePipeline: boolean;
+    dataProcessingParameters: DataProcessingParameters;
+    flowControl: FlowControl;
+    schedBlockReves: SchedBlockRef[];
+    obsUnitSets: ObsUnitSet[];
+    entityPartId: string;
+    almatype: string;
+    ousstatusRef?: OusStatusRef;
+}
+
+interface UserSensitivity extends Sensitivity {
+    userUnit: string;
+}
+
+interface VisitConstraint extends AbstractTimingConstraints {
+    visitId: number;
+    previousVisitId: number;
+    requiredDelay: Time;
+}
+declare const buildVisitConstraint: (visitId: number) => {
+    allowedMargin: {
+        value: number;
+        unit: string;
+    };
+    isAvoidConstraint: boolean;
+    priority: number;
+    isFixedStart: boolean;
+    visitId: number;
+    previousVisitId: number;
+    requiredDelay: {
+        value: number;
+        unit: string;
+    };
+};
+
+type TemporalParameters = AbstractTimingConstraints;
+declare const buildTemporalParameters: () => TemporalParameters;
+
+interface PerformanceParameters {
+    desiredAngularResolution?: UserAngle;
+    desiredLargestScale?: Angle;
+    desiredSensitivity?: UserSensitivity;
+    desiredDynamicRange?: number;
+    representativeFrequency?: Frequency;
+    useACA?: boolean;
+    isTimeConstrained?: boolean;
+    useTP?: boolean;
+    desiredSDSensitivity?: UserSensitivity;
+    isPointSource?: boolean;
+    desiredSensitivityReferenceFrequencyWidth?: UserFrequency;
+    needsMoreTime?: boolean;
+    desiredACASensitivity?: UserSensitivity;
+    desiredTPSensitivity?: UserSensitivity;
+    isScheduleConstrained?: boolean;
+    desiredTime?: Time;
+    acceptableAngularResolution?: UserAngle;
+    isSimultaneous12And7?: boolean;
+    visitConstraints?: VisitConstraint[];
+    temporalParameters?: TemporalParameters[];
+    monitoringConstraints?: MonitoringConstraint[];
+    desiredSensitivityFrequencyMeasure?: string;
+    timingConstraintsType?: string;
+    resolutionOption?: string;
+}
+
+type OverlaidSpectralLine = AbstractSpectralLine;
+
+interface SpectralSetupParameters {
+    representativeFrequency?: Frequency;
+    userRepresentativeFrequency?: boolean;
+    singleContinuumFrequency?: Frequency;
+    scienceSpectralWindowsAndSpectralScen?: any[];
+    advancedSpectralSetup?: AdvancedSpectralSetup;
+    overlaidSpectralLines?: OverlaidSpectralLine[];
+    polarisation?: string;
+    type?: string;
+    singleContinuumCorrelatorMode?: string;
+}
+declare const buildSpectralSetupParameters: () => SpectralSetupParameters;
+
+interface Rectangle extends Field {
+    spacing: UserAngle;
+    referenceFrequency: Frequency;
+    short: Angle;
+    long: Angle;
+    palong: Angle;
+}
+declare const buildRectangle: (referenceFrequency?: Frequency, system?: string) => Rectangle;
+
+interface TargetParameters extends AbstractTargetParameters {
+    isMosaic?: boolean;
+    circlesAndEllipsesAndPolygons?: Field[] | Rectangle[];
+    type?: string;
+}
+declare const buildTargetParameters: (circlesAndEllipsesAndPolygons?: Field[] | Rectangle[], index?: number) => TargetParameters;
+
+interface TechnicalJustification {
+    justificationText: string;
+    justificationKey: string;
+}
+declare const buildTechnicalJustifications: () => TechnicalJustification[];
+
+interface ScienceGoal extends AbstractScienceGoal {
+    id?: number;
+    estimatedTotalTime?: Time;
+    userPriority?: number;
+    requiredReceiverBands?: string[];
+    estimated12MTime?: Time;
+    estimated7MTime?: Time;
+    estimatedTPTime?: Time;
+    estimatedACATime?: Time;
+    isDescoped?: boolean;
+    isResubmission?: boolean;
+    resubmissionOfOusStatusUid?: string;
+    resubmissionOfName?: string;
+    expertParameters?: KeywordValue[];
+    calibrationSetupParameters?: CalibrationSetupParameters;
+    performanceParameters?: PerformanceParameters;
+    spectralSetupParameters?: SpectralSetupParameters;
+    targetParameters?: TargetParameters[];
+    technicalJustifications?: TechnicalJustification[];
+    mode?: string;
+    '@type'?: string;
+}
+declare const buildScienceGoal: () => ScienceGoal;
+
+interface ObsPhase {
+    observatoryGoalsAndOpticalPointingScienceGoalsAndScienceGoals?: ScienceGoal[];
+    obsPlan?: ObsUnitSet;
+}
+
+interface ObsProcedure {
+    obsProcScript: string;
+}
+
+type ObsProgram = ObsPhase;
+
+type ObsProjectEntity = Entity;
+
+type ObsProposalRef = EntityRef;
+
+type ObsReviewRef = EntityRef;
+
+type ProjectStatusRef = EntityRef;
+
+interface SubmissionRecord {
+    submitter: string;
+    submissionTime: string;
+}
+
+interface ObsProject {
+    obsProjectEntity?: ObsProjectEntity;
+    obsProposalRef?: ObsProposalRef;
+    obsReviewRef?: ObsReviewRef;
+    projectStatusRef?: ProjectStatusRef;
+    projectName?: string;
+    pi?: string;
+    version?: string;
+    code?: string;
+    assignedPriority?: number;
+    timeOfCreation?: string;
+    manualMode?: boolean;
+    simulationMode?: boolean;
+    isCommissioning?: boolean;
+    isCalibration?: boolean;
+    letterGrade?: string;
+    scientificRank?: number;
+    scientificScore?: number;
+    staffProjectNote?: string;
+    taPhase2Comments?: string;
+    taMainComments?: string;
+    consensusReport?: string;
+    isDDT?: boolean;
+    p2GAttention?: boolean;
+    p2GAttentionReasons?: string;
+    obsProgram?: ObsProgram;
+    submissionRecords?: SubmissionRecord[];
+    schemaVersion?: string;
+    revision?: string;
+    almatype?: string;
+    status?: string;
+}
+
+type XmlGregorianCalendar = Cloneable;
+
+interface ReceiverTime {
+    time: Time;
+    receiverBand: string;
+}
+
+interface ReceiverTimeBreakdown {
+    receiverTimes: ReceiverTime[];
+}
+
+interface TimeAllocationBreakdown {
+    executiveFractions: ExecutiveFraction[];
+}
+
+interface ProposalFeedback {
+    estimatedTotalIntegrationTime: Time;
+    arrayTimeBreakdown?: ArrayTimeBreakdown;
+    dataRateBreakdown?: DataRateBreakdown;
+    receiverTimeBreakdown?: ReceiverTimeBreakdown;
+    timeAllocationBreakdown: TimeAllocationBreakdown;
+}
+
+type ObsProposalEntity = Entity;
+
+interface ObsProposal extends ObsPhase {
+    obsProposalEntity?: ObsProposalEntity;
+    documentsRef?: ObsAttachmentRef;
+    obsProjectRef?: ObsProjectRef;
+    title?: string;
+    code?: string;
+    relatedProposals?: string;
+    previousProposals?: string;
+    dateReceived?: XmlGregorianCalendar;
+    cycle?: string;
+    studentProject?: boolean;
+    continuation?: boolean;
+    recentPublications?: string;
+    scientificCategoryCode?: string;
+    proposalTypeCode?: string;
+    scientificCategoryString?: string;
+    proposalTypeString?: string;
+    keywords?: string[];
+    keywordCodes?: string[];
+    resubmittedProjectCode?: string;
+    isResubmission?: boolean;
+    duplicateObservationsJustification?: string;
+    attentionFlag?: boolean;
+    attentionReasons?: string[];
+    principalInvestigator?: Investigator;
+    coInvestigators?: Investigator[];
+    coPrincipalInvestigators?: Investigator[];
+    reviewer?: Investigator;
+    mentor?: Investigator;
+    proposalFeedback?: ProposalFeedback;
+    schemaVersion?: string;
+    revision?: string;
+    almatype?: string;
+    abstract?: string;
+    jointProposal?: any;
+    schedulingFeasibility?: boolean;
+}
+
+interface OpticalCameraSpec extends AbstractInstrumentSpec {
+    minIntegrationTime: Time;
+    filter: string;
+}
+
+interface OpticalPointingParameters extends ObservingParameters {
+    antennaPositionTolerance: Angle;
+    elevationLimit: Angle;
+    maxMagnitude: Magnitude;
+    minMagnitude: Magnitude;
+    randomizeOrder: boolean;
+}
+
+interface Polygon extends Field {
+    points: SkyCoordinates[];
+}
+
+interface WeatherConstraints {
+    maxPWVC: Length;
+    seeing: Angle;
+    phaseStability: Angle;
+    maxWindVelocity: Speed;
+}
+
+interface Preconditions {
+    baselineCalValid: boolean;
+    polarizationCalValid: boolean;
+    minAllowedHA: UserAngle;
+    maxAllowedHA: UserAngle;
+    weatherConstraints: WeatherConstraints;
+}
+
+interface RadiometricPointingParameters extends ObservingParameters {
+    antennaPositionTolerance: Angle;
+    elevationLimit: Angle;
+    maxFlux: Flux;
+    minFlux: Flux;
+    randomizeOrder: boolean;
+}
+
+interface ReservationParameters extends ObservingParameters {
+    calendarId: string;
+    reqId: string;
+    staffMember: string;
+    resourceLists: string[];
+    description: string;
+    summary: string;
+    reason: string;
+}
+
+type SbStatusRef = EntityRef;
+
+type SchedBlockEntity = Entity;
+
+interface SchedBlockControl {
+    indefiniteRepeat: boolean;
+    executionCount: number;
+    runQuicklook: boolean;
+    sbmaximumTime: Time;
+}
+
+interface SchedulingConstraints {
+    representativeFrequency: Frequency;
+    minAcceptableAngResolution: Angle;
+    maxAcceptableAngResolution: Angle;
+    dynamicRange: number;
+    representativeCoordinates: SkyCoordinates;
+    requiredReceiverBands: string[];
+    nominalConfigurations: string[];
+    scienceGoalDesiredResolution: Angle;
+    scienceGoalLargestAngularScale: Angle;
+    isSimultaneous: boolean;
+    simultaneousSbUids: string[];
+    maxAllowedBeamAxialRatio: number;
+    spectralDynamicRange: number;
+    spectralDynamicRangeBandwidth: Frequency;
+    representativeTargetRef: SchedBlockRef;
+    representativeReceiverBand: string;
+}
+
+interface TemporalConstraints {
+    startTime: string;
+    endTime: string;
+    allowedMargin: Time;
+}
+
+interface Target {
+    abstractInstrumentSpecRef: SchedBlockRef;
+    fieldSourceRef: SchedBlockRef;
+    observingParametersReves: SchedBlockRef[];
+    entityPartId: string;
+    almatype: string;
+}
+
+interface SquareLawSetup {
+    integrationDuration: Time;
+}
+
+interface SpectralSpec extends AbstractInstrumentSpec {
+    frequencySwitchingCycle: FrequencySwitchingCycle;
+    beamSwitchingCycle: BeamSwitchingCycle;
+    frequencySetup: FrequencySetup;
+    squareLawSetup: SquareLawSetup;
+    switchingType: string;
+    receiverType: string;
+    blcorrelatorConfiguration: BlCorrelatorConfiguration;
+    acaspectrometerCorrelatorConfiguration: AcaSpectrometerCorrelatorConfiguration;
+    acacorrelatorConfiguration: AcaCorrelatorConfiguration;
+}
+
+interface SchedBlock extends ObsUnit {
+    schedBlockEntity: SchedBlockEntity;
+    obsUnitSetRef: ObsProjectRef;
+    standardMode: boolean;
+    modeName: string;
+    expertParameters: KeywordValue[];
+    qa0Notes: string;
+    spectralSpecs: SpectralSpec[];
+    opticalCameraSpecs: OpticalCameraSpec[];
+    fieldSources: FieldSource[];
+    observingGroups: ObservingGroup[];
+    amplitudeCalParametersAndAtmosphericCalParametersAndBandpassCalParameters: ObservingParameters[];
+    obsProcedure: ObsProcedure;
+    preconditions: Preconditions;
+    schedBlockControl: SchedBlockControl;
+    schedulingConstraints: SchedulingConstraints;
+    targets: Target[];
+    temporalConstraints: TemporalConstraints[];
+    timeAllocationBreakdown: TimeAllocationBreakdown;
+    schemaVersion: string;
+    revision: string;
+    almatype: string;
+    modeType: string;
+    sbstatusRef: SbStatusRef;
+    piname: string;
+}
+
+interface ScienceParameters extends ObservingParameters {
+    representativeBandwidth: Frequency;
+    representativeFrequency: Frequency;
+    sensitivityGoal: Sensitivity;
+    integrationTime: IntTimeSource;
+    subScanDuration: Time;
+    forceAtmCal: boolean;
+}
+
+interface ScienceSpectralWindow extends AbstractScienceSpectralWindow {
+    transitionName?: string;
+    centerFrequency?: Frequency;
+    bandWidth?: UserFrequency;
+    effectiveBandWidth?: UserFrequency;
+    spectralResolution?: UserFrequency;
+    groupIndex?: number;
+    isSkyFrequency?: boolean;
+    splatalogId?: number;
+    representativeWindow?: boolean;
+    groupResourceUse?: string;
+}
+declare const buildScienceSpectralWindow: () => any;
+declare const buildScienceSpectralWindowForSolar: () => any;
+declare const buildScienceSpectralWindowForVLBIOrPhasedArray: () => any;
+declare const buildScienceSpectralWindowForDefaultVLBIBand: (band: any) => any;
+
+type SinglePoint = Field;
+
+type SmallAngle = DoubleWithUnit;
+
+interface SpectralScan extends AbstractScienceSpectralWindow {
+    startFrequency: Frequency;
+    endFrequency: Frequency;
+    bandWidth: UserFrequency;
+    spectralResolution: Frequency;
+    isSkyFrequency: boolean;
+}
+declare const buildSpectralScanScienceSpectralWindow: () => any;
+
+interface Status {
+    readyTime: string;
+    startTime: string;
+    endTime: string;
+    state: string;
+}
+
+declare enum ApplicationStatus {
+    CREATE_PROJECT = "createProject",
+    CREATE_PROJECT_SUCCESS = "createProjectSuccess",
+    CREATE_PROJECT_FAILURE = "createProjectFailure",
+    CREATE_DDT_PROJECT = "createDDTProject",
+    CREATE_DDT_PROJECT_SUCCESS = "createDDTProjectSuccess",
+    CREATE_DDT_PROJECT_FAILURE = "createDDTProjectFailure",
+    CLONE_PROJECT = "cloneProject",
+    CLONE_PROJECT_SUCCESS = "cloneProjectSuccess",
+    CLONE_PROJECT_FAILURE = "cloneProjectFailure",
+    LOAD_PROJECT = "loadProject",
+    LOAD_PROJECT_SUCCESS = "loadProjectSuccess",
+    LOAD_PROJECT_FAILURE = "loadProjectFailure",
+    LOAD_PROJECT_FILE = "loadProjectFile",
+    LOAD_PROJECT_FILE_SUCCESS = "loadProjectFileSuccess",
+    LOAD_PROJECT_FILE_FAILURE = "loadProjectFileFailure",
+    SAVE_PROJECT_TO_DISK = "saveProjectToDisk",
+    SAVE_PROJECT_TO_DISK_SUCCESS = "saveProjectToDiskSuccess",
+    SAVE_PROJECT_TO_DISK_FAILURE = "saveProjectToDiskFailure",
+    REVERT_TO_LAST_SUBMITTED = "revertToLastSubmitted",
+    REVERT_TO_LAST_SUBMITTED_SUCCESS = "revertToLastSubmittedSuccess",
+    REVERT_TO_LAST_SUBMITTED_FAILURE = "revertToLastSubmittedFailure",
+    RELOAD_PROJECT_FAILURE = "reloadProjectFailure"
+}
+
+declare enum AuthenticationStatus {
+    LOGIN_SUCCESS = "loginSuccess",
+    LOGIN_FAILURE = "loginFailure"
+}
+
+interface Error {
+    message?: string;
+    code?: number;
+}
+
+interface ExportSources {
+    scienceGoalId: number;
+    options: ExportSourcesOptions;
+}
+interface ExportSourcesOptions {
+    type: 'Full' | 'OnlyPositions';
+    includeTargetName: boolean;
+    units: 'sexagesimal' | 'deg' | 'rad';
+}
+
+interface ImportSources {
+    file: File;
+    scienceGoalId: number;
+    options: ImportSourcesOptions;
+}
+interface ImportSourcesOptions {
+    type: 'Append' | 'Replace';
+}
+
+declare enum ListItemStatus {
+    LOAD_LIST_ITEM = "loadListItem",
+    LOAD_LIST_ITEM_SUCCESS = "loadListItemSuccess",
+    LOAD_LIST_ITEM_FAILURE = "loadListItemFailure"
+}
+
+declare enum ProjectStatus {
+    LOAD_PROJECT = "loadProject",
+    LOAD_PROJECT_SUCCESS = "loadProjectSuccess",
+    LOAD_PROJECT_FAILURE = "loadProjectFailure",
+    SAVE_PROJECT = "saveProject",
+    SAVE_PROJECT_SUCCESS = "saveProjectSuccess",
+    SAVE_PROJECT_FAILURE = "saveProjectFailure"
+}
+
+declare enum ProjectTypeCode {
+    REGULAR = "S",
+    TARGET_OF_OPPORTUNITY = "T",
+    VLBI = "V",
+    LARGE_PROGRAM = "L",
+    PHASED_ARRAY_MODE = "P"
+}
+
+declare enum ProposalStatus {
+    LOAD_PROPOSAL = "loadProposal",
+    LOAD_PROPOSAL_SUCCESS = "loadProposalSuccess",
+    LOAD_PROPOSAL_FAILURE = "loadProposalFailure",
+    SAVE_PROPOSAL = "saveProposal",
+    SAVE_PROPOSAL_SUCCESS = "saveProposalSuccess",
+    SAVE_PROPOSAL_FAILURE = "saveProposalFailure",
+    IMPORT_INVESTIGATORS = "importInvestigators",
+    IMPORT_INVESTIGATORS_SUCCESS = "importInvestigatorsSuccess",
+    IMPORT_INVESTIGATORS_FAILURE = "importInvestigatorsFailure",
+    GENERATE_PROPOSAL_SUMMARY = "generateProposalSummary",
+    GENERATE_PROPOSAL_SUMMARY_SUCCESS = "generateProposalSummarySuccess",
+    GENERATE_PROPOSAL_SUMMARY_FAILURE = "generateProposalSummaryFailure"
+}
+
+type ProposalSubmissionStatus = 'draft' | 'submitted' | 'modified';
+
+declare enum AttachmentStatus {
+    LOAD_SCIENCE_CASE = "loadScienceCase",
+    LOAD_SCIENCE_CASE_SUCCESS = "loadScienceCaseSuccess",
+    LOAD_SCIENCE_CASE_FAILURE = "loadScienceCaseFailure",
+    VALIDATE_SCIENCE_CASE = "validateScienceCase",
+    VALIDATE_SCIENCE_CASE_SUCCESS = "validateScienceCaseSuccess",
+    VALIDATE_SCIENCE_CASE_FAILURE = "validateScienceCaseFailure",
+    REMOVE_SCIENCE_CASE = "removeScienceCase",
+    REMOVE_SCIENCE_CASE_SUCCESS = "removeScienceCaseSuccess",
+    REMOVE_SCIENCE_CASE_FAILURE = "removeScienceCaseFailure",
+    LOAD_TEAM_EXPERTISE = "loadTeamExpertise",
+    LOAD_TEAM_EXPERTISE_SUCCESS = "loadTeamExpertiseSuccess",
+    LOAD_TEAM_EXPERTISE_FAILURE = "loadTeamExpertiseFailure",
+    VALIDATE_TEAM_EXPERTISE = "validateTeamExpertise",
+    VALIDATE_TEAM_EXPERTISE_SUCCESS = "validateTeamExpertiseSuccess",
+    VALIDATE_TEAM_EXPERTISE_FAILURE = "validateTeamExpertiseFailure",
+    REMOVE_TEAM_EXPERTISE = "removeTeamExpertise",
+    REMOVE_TEAM_EXPERTISE_SUCCESS = "removeTeamExpertiseSuccess",
+    REMOVE_TEAM_EXPERTISE_FAILURE = "removeTeamExpertiseFailure"
+}
+
+declare enum ScienceGoalsStatus {
+    LOAD_SCIENCE_GOALS = "loadScienceGoals",
+    LOAD_SCIENCE_GOALS_SUCCESS = "loadScienceGoalsSuccess",
+    LOAD_SCIENCE_GOALS_FAILURE = "loadScienceGoalsFailure",
+    SAVE_SCIENCE_GOALS = "saveScienceGoals",
+    SAVE_SCIENCE_GOALS_SUCCESS = "saveScienceGoalsSuccess",
+    SAVE_SCIENCE_GOALS_FAILURE = "saveScienceGoalsFailure",
+    IMPORT_SOURCES = "importSources",
+    IMPORT_SOURCES_SUCCESS = "importSourcesSuccess",
+    IMPORT_SOURCES_FAILURE = "importSourcesFailure",
+    EXPORT_SOURCES = "exportSources",
+    EXPORT_SOURCES_SUCCESS = "exportSourcesSuccess",
+    EXPORT_SOURCES_FAILURE = "exportSourcesFailure",
+    EXPORT_SOURCES_COORDINATES_NOT_SUPPORTED = "exportSourcesCoordinatesNotSupported",
+    UPDATE_REST_FREQUENCIES = "updateRestFrequencies",
+    UPDATE_REST_FREQUENCIES_SUCCESS = "updateRestFrequenciesSuccess",
+    UPDATE_REST_FREQUENCIES_FAILURE = "updateRestFrequenciesFailure",
+    IMPORT_SINGLE_VISITS = "importSingleVisits",
+    IMPORT_SINGLE_VISITS_SUCCESS = "importSingleVisitsSuccess",
+    IMPORT_SINGLE_VISITS_FAILURE = "importSingleVisitsFailure",
+    IMPORT_EPHEMERIS_FILE = "importEphemerisFile",
+    IMPORT_EPHEMERIS_FILE_SUCCESS = "importEphemerisFileSuccess",
+    IMPORT_EPHEMERIS_FILE_FAILURE = "importEphemerisFileFailure"
+}
+
+declare enum SubmissionStatus {
+    SUBMIT_PROJECT = "submitProject",
+    SUBMIT_PROJECT_SUCCESS = "submitProjectSuccess",
+    SUBMIT_PROJECT_FAILURE = "submitProjectFailure"
+}
+
+declare enum ValidationStatus {
+    VALIDATE = "validate",
+    VALIDATE_SUCCESS = "validateSuccess",
+    VALIDATE_FAILURE = "validateFailure"
+}
+
+interface ReceiverBand {
+    number: number;
+    rfmin: number;
+    rfmax: number;
+    polarisationFrequency: number;
+    continuumFrequency: number;
+    continuumSolarFrequency?: number;
+    continuumVlbiFrequency?: number;
+    name: string;
+    type: string;
+    ifmin: number;
+    ifmax: number;
+    sidebandGainRatio: number;
+    rangeDescription: string;
+}
+
+declare const ReceiverBands: ReceiverBand[];
+
+declare enum TimeEstimatesStatus {
+    FETCH_TIME_ESTIMATES = "fetchTimeEstimates",
+    FETCH_TIME_ESTIMATES_SUCCESS = "fetchTimeEstimatesSuccess",
+    FETCH_TIME_ESTIMATES_FAILURE = "fetchTimeEstimatesFailure"
+}
+
+declare enum ControlAndPerformanceDataStatus {
+    FETCH_CONTROL_AND_PERFORMANCE = "fetchControlAndPerformance",
+    FETCH_CONTROL_AND_PERFORMANCE_SUCCESS = "fetchControlAndPerformanceSuccess",
+    FETCH_CONTROL_AND_PERFORMANCE_FAILURE = "fetchControlAndPerformanceFailure"
+}
+
+declare enum CalibrationDataStatus {
+    FETCH_CALIBRATION = "fetchCalibration",
+    FETCH_CALIBRATION_SUCCESS = "fetchCalibrationSuccess",
+    FETCH_CALIBRATION_FAILURE = "fetchCalibrationFailure"
+}
+
+declare enum SensitivityEquivalenceValuesStatus {
+    FETCH_SENSITIVITY_EQUIVALENCE_VALUES = "fetchSensitivityEquivalenceValues",
+    FETCH_SENSITIVITY_EQUIVALENCE_VALUES_SUCCESS = "fetchSensitivityEquivalenceValuesSuccess",
+    FETCH_SENSITIVITY_EQUIVALENCE_VALUES_FAILURE = "fetchSensitivityEquivalenceValuesFailure"
+}
+
+declare enum SensitivityFrequencyMeasuresStatus {
+    FETCH_SENSITIVITY_FREQUENCY_MEASURES = "fetchSensitivityFrequencyMeasures",
+    FETCH_SENSITIVITY_FREQUENCY_MEASURES_SUCCESS = "fetchSensitivityFrequencyMeasuresSuccess",
+    FETCH_SENSITIVITY_FREQUENCY_MEASURES_FAILURE = "fetchSensitivityFrequencyMeasuresFailure"
+}
+
+declare enum SpectralScanTuningsStatus {
+    FETCH_SPECTRAL_SCAN_TUNINGS = "fetchSpectralScanTunings",
+    FETCH_SPECTRAL_SCAN_TUNINGS_SUCCESS = "fetchSpectralScanTuningsSuccess",
+    FETCH_SPECTRAL_SCAN_TUNINGS_FAILURE = "fetchSpectralScanTuningsFailure"
+}
+
+declare enum UserPreferencesStatus {
+    LOAD_USER_PREFERENCES = "loadUserPreferences",
+    LOAD_USER_PREFERENCES_SUCCESS = "loadUserPreferencesSuccess",
+    LOAD_USER_PREFERENCES_FAILURE = "loadUserPreferencesFailure",
+    SAVE_USER_PREFERENCES = "saveUserPreferences",
+    SAVE_USER_PREFERENCES_SUCCESS = "saveUserPreferencesSuccess",
+    SAVE_USER_PREFERENCES_FAILURE = "saveUserPreferencesFailure"
+}
+
+declare enum PointingsStatus {
+    FETCH_POINTINGS = "fetchPointings",
+    FETCH_POINTINGS_SUCCESS = "fetchPointingsSuccess",
+    FETCH_POINTINGS_FAILURE = "fetchPointingsFailure",
+    EXPORT_POINTINGS_TO_CSV = "exportPointingsToCsv",
+    EXPORT_POINTINGS_TO_CSV_SUCCESS = "exportPointingsToCsvSuccess",
+    EXPORT_POINTINGS_TO_CSV_FAILURE = "exportPointingsToCsvFailure",
+    IMPORT_POINTINGS_FROM_CSV = "importPointingsFromCsv",
+    IMPORT_POINTINGS_FROM_CSV_SUCCESS = "importPointingsFromCsvSuccess",
+    IMPORT_POINTINGS_FROM_CSV_SUCCESS_WITH_WARNINGS = "importPointingsFromCsvSuccessWithWarnings",
+    IMPORT_POINTINGS_FROM_CSV_FAILURE = "importPointingsFromCsvFailure"
+}
+
+interface Pointings {
+    pointings7m?: number;
+    pointings12m?: number;
+    maxNumberTotalPointingsAllowed: number;
+}
+
+type ArrayTypes = '12m' | '7m';
+
+declare enum SpectralViewerStatus {
+    FETCH_OCTILE = "fetchOctile",
+    FETCH_OCTILE_SUCCESS = "fetchOctileSuccess",
+    FETCH_OCTILE_FAILURE = "fetchOctileFailure"
+}
+
+declare enum CycleInfoStatus {
+    LOAD_CYCLE_INFO = "cycleInfo",
+    LOAD_CYCLE_INFO_SUCCESS = "cycleInfoSuccess",
+    LOAD_CYCLE_INFO_FAILURE = "cycleInfoFailure"
+}
+
+declare enum ConfigurationTablesStatus {
+    LOAD_CONFIGURATION_TABLES = "loadConfigurationTables",
+    LOAD_CONFIGURATION_TABLES_SUCCESS = "loadConfigurationTablesSuccess",
+    LOAD_CONFIGURATION_TABLES_FAILURE = "loadConfigurationTablesFailure"
+}
+
+declare enum ProposalTypeString {
+    Regular = "Regular",//
+    TargetOfOpportunity = "Target Of Opportunity",
+    VLBI = "VLBI",
+    LargeProgram = "Large Program",
+    PhasedArray = "Phased Array"
+}
+declare const ProposalTypes: string[];
+declare const ProposalTypesMap: {
+    Regular: string;
+    'Target Of Opportunity': string;
+    VLBI: string;
+    'Large Program': string;
+    'Phased Array': string;
+};
+
+declare enum TechnicalJustificationStatus {
+    FETCH_TECHNICAL_JUSTIFICATION = "fetchTechnicalJustification",
+    FETCH_TECHNICAL_JUSTIFICATION_SUCCESS = "fetchTechnicalJustificationSuccess",
+    FETCH_TECHNICAL_JUSTIFICATION_FAILURE = "fetchTechnicalJustificationFailure"
+}
+
+interface User {
+    name: string;
+    preferred_username: string;
+    roles: string[];
+}
+declare const includesPrivilegedRoles: (roles: string[]) => boolean;
+declare const includesProtrackRole: (roles: string[]) => boolean;
+
+interface ListItem {
+    aotId?: string;
+    code?: string;
+    latestSubmissionTime?: string;
+    latestModificationTime?: string;
+    obsAttachmentEntityId?: string;
+    obsProjectEntityId?: string;
+    obsProposalEntityId?: string;
+    pi?: string;
+    piFullName?: string;
+    projectName?: string;
+    timeOfCreation?: string;
+    projectSource?: string;
+    originalProjectSource?: 'Disk' | 'ProjectStore' | 'Archive';
+    coIBecomesPI: boolean;
+    containsTaiwanese?: boolean;
+}
+declare function getProjectStatus(item: ListItem): ProposalSubmissionStatus;
+declare function getSourceFromToClone(item: ListItem): string;
+
+interface UserPreferences {
+    referenceSystemPopupShouldOccur?: boolean;
+    systemCoordinateConversionPopUpShouldOccur?: boolean;
+    addConfirm?: boolean;
+    deleteConfirm?: boolean;
+    iAULookupsNotAdvised?: boolean;
+    basebandsReordered?: boolean;
+    repairConfirm?: boolean;
+    representativeTargetConfirm?: boolean;
+    confirmPatternChange?: boolean;
+    visitConstraintsImpossibleOrder?: boolean;
+    canUserSaveToDisk?: boolean;
+}
+
+interface TechnicalJustificationEditor {
+    label: string;
+    justificationKey: string;
+    justificationText: string;
+}
+
+interface TechnicalJustificationItem {
+    [key: string]: string;
+}
+
+interface TechnicalJustifications {
+    ED_SENSITIVITY: TechnicalJustificationEditor;
+    ED_ANGULAR_RESOLUTION: TechnicalJustificationEditor;
+    ED_CORRELATOR: TechnicalJustificationEditor;
+    ED_ADDITIONAL_TIME: TechnicalJustificationEditor;
+}
+
+interface TechnicalJustificationSection {
+    messages: TechnicalJustificationItem;
+    warnings: TechnicalJustificationItem;
+    justifications: TechnicalJustifications;
+}
+
+interface TechnicalJustificationsResult {
+    Sensitivity: TechnicalJustificationSection;
+    Imaging: TechnicalJustificationSection;
+    'Correlator configuration': TechnicalJustificationSection;
+    'Choices to be justified': TechnicalJustificationSection;
+}
+
+interface Calibration {
+    calibration12m1: DoubleWithUnit;
+    calibration12m1And2: DoubleWithUnit;
+    calibration12m2: DoubleWithUnit;
+    calibrationACA7m: DoubleWithUnit;
+    calibrationACATotalPower: DoubleWithUnit;
+    calibrationTotal: DoubleWithUnit;
+    total12m1: DoubleWithUnit;
+    total12m1And2: DoubleWithUnit;
+    total12m2: DoubleWithUnit;
+    totalACA7m: DoubleWithUnit;
+    totalACATotalPower: DoubleWithUnit;
+    totalOverall: DoubleWithUnit;
+}
+
+interface Param {
+    content: string;
+    name: string;
+}
+
+interface Group {
+    title: string;
+    params: Param[];
+}
+
+interface Configuration {
+    maxExpectedAxialRatio: string;
+    nominalBeam: string;
+    sevenM: string;
+    totalPower: string;
+    twelveM1: string;
+    twelveM2: string;
+}
+
+interface Source {
+    dec: string;
+    ra: string;
+    sourceName: string;
+    velocity: DoubleWithUnit;
+}
+
+interface ClusterData {
+    configurations: Configuration[];
+    groups: Group[];
+    sources: Source[];
+    calibration: Calibration;
+    estimatedTotalTime: any;
+}
+
+interface DataVolumeAndRates {
+    volume12m1And2: DoubleWithUnit;
+    volumeACA7m: DoubleWithUnit;
+    volumeACATP: DoubleWithUnit;
+    rate12m1And2: DoubleWithUnit;
+    rateACA7m: DoubleWithUnit;
+    rateACATP: DoubleWithUnit;
+}
+
+interface HeaderParameter {
+    title: string;
+    params: Param[];
+}
+
+interface TimeEstimate {
+    totalCalibrationTimes: Calibration;
+    dataVolumeAndRates: DataVolumeAndRates;
+    clustersData: ClusterData[];
+    headerParameters: HeaderParameter[];
+    receiverBand: number;
+    errorData: string;
+}
+
+interface TimeEstimates {
+    index: {
+        [key: string]: TimeEstimate;
+    };
+}
+
+interface Environment {
+    appVersion?: string;
+    gitBranch?: string;
+    gitCommitHash?: string;
+    buildTime?: string;
+}
+
+declare const JointProposalsTypes: string[];
+
+interface AntennasConfiguration {
+    longestBaseline: Length;
+    maximumRecoverableScale: Angle;
+    shortestBaseline: Length;
+    synthesizedBeamsize: Angle;
+}
+
+interface ControlAndPerformanceConfiguration {
+    aca7mConfiguration: AntennasConfiguration;
+    antennaBeamsize7m: Angle;
+    antennaBeamsize12m: Angle;
+    antennas12m: number;
+    antennas7m: number;
+    antennasTP: number;
+    compact12mConfiguration: AntennasConfiguration;
+    extended12mConfiguration: AntennasConfiguration;
+    isSimultaneous12and7Observation: boolean;
+    isSimultaneous12And7Possible: boolean;
+    errorMessage: string;
+}
+
+interface SensitivityEquivalenceValues {
+    equivalentSensitivityResults: EquivalentSensitivityResults;
+    acaAndTPResult: AcaAndTpResult;
+}
+interface EquivalentSensitivityResults {
+    sensitivityEquivalent1: SensitivityEquivalent;
+    sensitivityEquivalent2: SensitivityEquivalent;
+}
+interface SensitivityEquivalent {
+    value: number;
+    altUnit: string;
+    beamsize: string;
+}
+interface AcaAndTpResult {
+    useACA: boolean;
+    useTP: boolean;
+    desiredACASensitivity: DesiredSensitivity;
+    desiredTPSensitivity: DesiredSensitivity;
+}
+interface DesiredSensitivity {
+    value: number;
+    unit: string;
+    userUnit: string;
+}
+
+interface SensitivityFrequencyMeasures {
+    RepresentativeWindowResolution: UserFrequency;
+    LargestWindowBandWidth: UserFrequency;
+    RepresentativeWindowBandWidth: UserFrequency;
+    User: UserFrequency;
+    FinestResolution: UserFrequency;
+    AggregateBandWidth: UserFrequency;
+}
+
+type DGCTypeEnum = 'None' | 'DGCBandwidthSwitching' | 'DGCBandToBand';
+interface CalibrationConfiguration {
+    dgcObservingStrategyScheduled: DGCTypeEnum[];
+    errorMessage: string;
+}
+
+type ValidationIssueType = 'Error' | 'Warning' | 'Info' | 'Success' | 'Submission error' | '<Unknown Severity>';
+
+interface ValidationIssue {
+    type?: ValidationIssueType;
+    message?: string;
+    suggestion?: string;
+    scienceGoalId?: number;
+    sourceIndex?: number;
+    index?: number;
+    path?: string[];
+}
+
+interface SpectralLines {
+    line_id: number;
+    species_id: number;
+    s_name_noparens: string;
+    chemical_name: string;
+    restFreq: number;
+    skyFreq: number;
+    sijmu2: number;
+    lovas_int: string;
+    planet: boolean;
+    ism_hotcore: boolean;
+    ism_diffusecloud: boolean;
+    comet: boolean;
+    ism_darkcloud: boolean;
+    extragalactic: boolean;
+    agb_ppn_pn: boolean;
+    top20: boolean;
+    e_up_K: number;
+}
+
+interface SpectralScanTunings {
+    tunings: Frequency[][];
+    imageTunings: Frequency[][];
+    achievedStartFrequency: Frequency;
+    achievedEndFrequency: Frequency;
+    tuningError: boolean;
+    tuningWarning: boolean;
+    tuningMessage: string;
+    imageSideBand: boolean;
+}
+
+type SpectralType = 'full' | 'continuum' | 'scan';
+
+interface EphemerisInformation {
+    fileContents: string;
+    sourceName: string;
+    sourceCoordinates: SkyCoordinates;
+}
+
+/**
+ * Editor token and associated info -- for NGOT-907
+ * @author amchavan, 11-Oct-2024
+ */
+/**
+ * Reasons why a token expired.
+ *
+ * NOTE -- We set the enum values to be strings, so we can use them in a switch/case statement
+ *         without casting them to numbers.
+ *         See https://stackoverflow.com/a/59217944
+ */
+declare enum ExpirationReason {
+    /** Author was inactive (that is, did not edit the proposal) for some predefined time */
+    INACTIVE = "INACTIVE",
+    /** Author completed an editing session and released the token */
+    RELEASED = "RELEASED",
+    /** PI overrode current author and claimed the token for himself */
+    GRAB = "GRAB"
+}
+/**
+ * An editor token: a proposal author (PI, Co-PIs and Co-Is) who 'owns'
+ * one of these tokens is allowed to edit the proposal, while all
+ * other authors are in read-only mode
+ *
+ * @param expirationTime When the token will expire or has expired (msec since the epoch)
+ *
+ * @author amchavan, 30-Sep-2024
+ */
+interface Token {
+    /** ObsProject UID for the proposal being edited */
+    obsProjectUID?: string;
+    /**
+     * Identifier of the session (browser or browser tab)
+     * requiring this token -- allows concurrent access
+     * checks across multiple tabs on the same browser
+     */
+    sessionId?: string;
+    /** Username of the author */
+    author?: string;
+    /** When the token will expire or has expired (msec since the epoch) */
+    expirationTime?: number;
+    /** If falsy, this token hasn't expired yet */
+    expirationReason?: ExpirationReason;
+}
+
+/**
+ * The client for alma.obsprep.ngot.backend.ngotprojectarchive.concedit.TokenController
+ * in ngot-project-archive.
+ *
+ * All requests are fire-and-forget (no action on the response) because the front-end
+ * takes its concurrent editing input from websocket subscriptions.
+ *
+ * @author amchavan, 11-Oct-2024
+ */
+declare class TokenService {
+    private http;
+    readonly baseUrl = "/ngotGateway/concurrent-editing/v1";
+    constructor(http: HttpClient);
+    claimToken(obsProjectUid: string, username: string, sessionId: string, grab?: boolean): rxjs_dist_types.Subscription;
+    releaseToken(obsProjectUid: string, username: string, sessionId: string): rxjs_dist_types.Subscription;
+    /** Ask the back-end to broadcast the current editing token for the given project, if any */
+    broadcastToken(obsProjectUid: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TokenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TokenService>;
+}
+
+/**
+ * Simple-minded session management: a session is a user on browser, or browser tab
+ * @author amchavan, 11-Oct-2024
+ */
+declare class SessionService {
+    /** A self-generated session identifier for the tab we are running in */
+    sessionID: string;
+    constructor();
+    getSessionId(): string;
+    /** Compute a random string of the given length */
+    private randomString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionService>;
+}
+
+/**
+ * @author amchavan, 10-Oct-2024
+ */
+declare class RxStompService extends RxStomp {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RxStompService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RxStompService>;
+}
+
+/**
+ * See https://stomp-js.github.io/guide/rx-stomp/rx-stomp-with-angular.html
+ *
+ * @author amchavan, 10-Oct-2024
+ */
+declare function rxStompServiceFactory(): RxStompService;
+
+interface CycleInfo {
+    cycleYear: string;
+    isMainCall: boolean;
+    phase1StartDate: string;
+    phase1EndDate: string;
+    phase2StartDate: string;
+    phase2EndDate: string;
+    ddtStartDate: string;
+    ddtEndDate: string;
+    telescope: string;
+}
+
+interface ConfigurationTableRow {
+    dec: string | number;
+    finestAR: string | number;
+    coarsestAR: string | number;
+    LAS: string | number;
+}
+type ConfigurationTables = Record<string, ConfigurationTableRow[]>;
+
+export { ApplicationStatus, AttachmentStatus, AuthenticationStatus, CalibrationDataStatus, ConfigurationTablesStatus, ControlAndPerformanceDataStatus, CycleInfoStatus, ExpirationReason, JointProposalsTypes, ListItemStatus, PointingsStatus, ProjectStatus, ProjectTypeCode, ProposalStatus, ProposalTypeString, ProposalTypes, ProposalTypesMap, ReceiverBands, RxStompService, ScienceGoalsStatus, SensitivityEquivalenceValuesStatus, SensitivityFrequencyMeasuresStatus, SessionService, SpectralScanTuningsStatus, SpectralViewerStatus, SubmissionStatus, TechnicalJustificationStatus, TimeEstimatesStatus, TokenService, UserPreferencesStatus, ValidationStatus, buildCalibrationTargetParameter, buildField, buildRectangle, buildScienceGoal, buildScienceSpectralWindow, buildScienceSpectralWindowForDefaultVLBIBand, buildScienceSpectralWindowForSolar, buildScienceSpectralWindowForVLBIOrPhasedArray, buildSpectralScanScienceSpectralWindow, buildSpectralSetupParameters, buildTargetParameters, buildTechnicalJustifications, buildTemporalParameters, buildVisitConstraint, getProjectStatus, getSourceFromToClone, includesPrivilegedRoles, includesProtrackRole, rxStompServiceFactory };
+export type { ACASpectralWindow, AbstractBaseBandConfig, AbstractCorrelatorConfiguration, AbstractInstrumentSpec, AbstractScienceGoal, AbstractScienceSpectralWindow, AbstractSpectralLine, AbstractSpectralWindow, AbstractSwitchingCycle, AbstractSwitchingState, AbstractTargetParameters, AbstractTimingConstraints, AcaAndTpResult, AcaBaseBandConfig, AcaCorrelatorConfiguration, AcaPhaseSwitchingConfiguration, AcaSpectrometerCorrelatorConfiguration, AdvancedSpectralSetup, AdvancedWindowSetup, Angle, AngularVelocity, AntennasConfiguration, ArrayDataRates, ArrayTime, ArrayTimeBreakdown, ArrayTypes, BaseBandSpecification, BeamSwitchingCycle, BeamSwitchingState, BlBaseBandConfig, BlCorrelatorConfiguration, BlSpectralWindow, Calibration, CalibrationConfiguration, CalibrationRequirements, CalibrationSetupParameters, CalibrationTargetParameters, CalibrationTargetProperties, CalibratorParameters, ChannelAverageRegion, Circle, Cloneable, ClusterData, Configuration, ConfigurationTableRow, ConfigurationTables, ControlAndPerformanceConfiguration, ControlBlock, CrossPattern, CycleInfo, DGCTypeEnum, DataProcessingParameters, DataRate, DataRateBreakdown, DataVolumeAndRates, DesiredSensitivity, DocumentLink, DoubleWithUnit, Ellipse, Entity, EntityRef, Environment, EphemerisInformation, EquivalentSensitivityResults, Error, ExecBlockRef, ExecutiveFraction, ExpectedProperties, ExpectedSpectralLine, ExportSources, ExportSourcesOptions, ExtendedScienceSpectralWindow, Field, FieldPattern, FieldSource, FillPattern, FlowControl, Flux, Frequency, FrequencySetup, FrequencySwitchingCycle, FrequencySwitchingState, Group, HeaderParameter, HolographyParameters, ImportSources, ImportSourcesOptions, IntTimeReference, IntTimeSource, Investigator, KeywordValue, Latitude, Length, ListItem, Longitude, Magnitude, MonitoringConstraint, ObsAttachment, ObsAttachmentEntity, ObsAttachmentRef, ObsPhase, ObsProcedure, ObsProgram, ObsProject, ObsProjectEntity, ObsProjectRef, ObsProposal, ObsProposalEntity, ObsProposalRef, ObsReviewRef, ObsUnit, ObsUnitControl, ObsUnitSet, ObservingGroup, ObservingParameters, OpticalCameraSpec, OpticalPointingParameters, OrderedTarget, OusStatusRef, OverlaidSpectralLine, Param, PerformanceParameters, PointingPattern, Pointings, Polygon, Preconditions, ProjectStatusRef, ProposalFeedback, ProposalSubmissionStatus, QuerySource, RadiometricPointingParameters, ReceiverBand, ReceiverTime, ReceiverTimeBreakdown, Rectangle, RectanglePattern, Reference, ReservationParameters, SbStatusRef, SchedBlock, SchedBlockControl, SchedBlockEntity, SchedBlockRef, SchedulingConstraints, ScienceGoal, ScienceParameters, ScienceSpectralWindow, Sensitivity, SensitivityEquivalenceValues, SensitivityEquivalent, SensitivityFrequencyMeasures, SinglePoint, SkyCoordinates, SmallAngle, Source, SourceProperty, SpectralLine, SpectralLines, SpectralScan, SpectralScanTunings, SpectralSetupParameters, SpectralSpec, SpectralType, Speed, SquareLawSetup, Status, StorageVolume, SubmissionRecord, Target, TargetParameters, TechnicalJustification, TechnicalJustificationEditor, TechnicalJustificationItem, TechnicalJustificationSection, TechnicalJustifications, TechnicalJustificationsResult, TemporalConstraints, TemporalParameters, Time, TimeAllocationBreakdown, TimeEstimate, TimeEstimates, Token, UnitDependencies, User, UserAngle, UserFrequency, UserPreferences, UserSensitivity, ValidationIssue, ValidationIssueType, Velocity, VisitConstraint, WeatherConstraints, XmlGregorianCalendar };