import { PowerChartData, AttitudeChartData, WaterfallDataPoint, DopplerTrackPoint, SatellitePassInfo, SpectrumDataPoint, ContactWindowData, EclipseTimelineData, HeliocentricOrbitData } from './types';
export interface PowerGeneratorConfig {
    /** Orbit period in seconds (default: 5400 = 90 min LEO) */
    orbitPeriod?: number;
    /** Eclipse duration in seconds (default: 2100 = 35 min) */
    eclipseDuration?: number;
    /** Solar array power output at optimal pointing (W) */
    solarArrayPower?: number;
    /** Average load power (W) */
    loadPower?: number;
    /** Battery capacity (Wh) */
    batteryCapacity?: number;
    /** Initial state of charge (%) */
    initialSoC?: number;
    /** Load reduction factor during eclipse (0-1) */
    eclipseLoadReduction?: number;
    /** Simulation duration in orbits */
    orbits?: number;
    /** Time resolution in seconds */
    resolution?: number;
}
/**
 * Generate realistic LEO satellite power system telemetry
 *
 * Models:
 * - Solar array power variation with orbit phase (cosine pointing loss)
 * - Eclipse periods with zero solar input
 * - Battery charge/discharge with 90% round-trip efficiency
 * - Load shedding during eclipse
 */
export declare function generatePowerData(config?: PowerGeneratorConfig): PowerChartData[];
export interface AttitudeGeneratorConfig {
    /** Initial attitude [roll, pitch, yaw] in degrees */
    initialAttitude?: [number, number, number];
    /** Target attitude [roll, pitch, yaw] in degrees */
    targetAttitude?: [number, number, number];
    /** Slew rate in deg/s */
    slewRate?: number;
    /** Settling time in seconds */
    settleTime?: number;
    /** Pointing jitter RMS in degrees */
    jitter?: number;
    /** Sampling rate in Hz */
    samplingRate?: number;
    /** Duration in seconds */
    duration?: number;
}
/**
 * Generate realistic spacecraft attitude telemetry
 *
 * Models:
 * - Slew maneuver with trapezoidal velocity profile
 * - Fine pointing settling with exponential decay
 * - Random jitter (Gaussian distribution)
 * - Angular velocity from finite differences
 */
export declare function generateAttitudeData(config?: AttitudeGeneratorConfig): AttitudeChartData[];
export interface DopplerGeneratorConfig {
    /** Carrier frequency in Hz */
    carrierFrequency?: number;
    /** Satellite altitude in km */
    altitude?: number;
    /** Maximum elevation angle in degrees */
    maxElevation?: number;
    /** Pass duration in seconds */
    passDuration?: number;
    /** Time resolution in seconds */
    resolution?: number;
    /** Add measurement noise (Hz RMS) */
    measurementNoise?: number;
    /** Satellite name */
    satelliteName?: string;
    /** Ground station name */
    groundStation?: string;
}
/**
 * Generate realistic Doppler tracking data for a satellite pass
 *
 * Uses simplified orbital mechanics:
 * - Circular orbit at specified altitude
 * - Pass geometry from maximum elevation
 * - Doppler shift from velocity projection
 */
export declare function generateDopplerData(config?: DopplerGeneratorConfig): {
    predicted: DopplerTrackPoint[];
    measured: DopplerTrackPoint[];
    passInfo: SatellitePassInfo;
};
export interface WaterfallGeneratorConfig {
    /** Center frequency in Hz */
    centerFrequency?: number;
    /** Bandwidth in Hz */
    bandwidth?: number;
    /** Number of FFT bins */
    fftBins?: number;
    /** Noise floor in dBm */
    noiseFloor?: number;
    /** Number of time samples */
    timeSamples?: number;
    /** Signals to include */
    signals?: Array<{
        /** Offset from center frequency (Hz) */
        offset: number;
        /** Signal power (dBm) */
        power: number;
        /** Signal bandwidth (Hz) */
        bandwidth: number;
        /** Signal type */
        type: "cw" | "ssb" | "digital" | "beacon";
        /** Doppler drift (Hz/s) - for moving signals */
        dopplerDrift?: number;
    }>;
}
/**
 * Generate realistic RF waterfall data
 *
 * Models:
 * - Gaussian noise floor
 * - CW signals (narrow spikes)
 * - SSB signals (offset sideband with modulation)
 * - Digital signals (wider, flatter spectrum)
 * - Time-varying Doppler drift
 */
export declare function generateWaterfallData(config?: WaterfallGeneratorConfig): WaterfallDataPoint[];
export interface ContactGeneratorConfig {
    /** Ground stations */
    groundStations?: Array<{
        name: string;
        latitude: number;
        longitude: number;
    }>;
    /** Satellite altitude (km) */
    altitude?: number;
    /** Orbit inclination (degrees) */
    inclination?: number;
    /** Simulation duration (hours) */
    duration?: number;
    /** Minimum elevation (degrees) */
    minElevation?: number;
}
/**
 * Generate realistic ground station contact windows
 *
 * Uses simplified visibility calculation based on:
 * - Orbital period from altitude
 * - Swath width from elevation angle
 * - Ground track precession
 */
export declare function generateContactWindows(config?: ContactGeneratorConfig): ContactWindowData[];
export interface HeliocentricGeneratorConfig {
    /** Bodies to include */
    bodies?: Array<{
        name: string;
        type: "planet" | "spacecraft" | "asteroid" | "comet";
        semiMajorAxis: number;
        eccentricity: number;
        inclination: number;
        argumentOfPerihelion: number;
        trueAnomaly: number;
        color?: string;
    }>;
    /** Number of points per orbit */
    orbitPoints?: number;
}
/**
 * Generate heliocentric orbit visualization data
 */
export declare function generateHeliocentricOrbits(config?: HeliocentricGeneratorConfig): HeliocentricOrbitData[];
export interface SpectrumGeneratorConfig {
    /** Center frequency (Hz) */
    centerFrequency?: number;
    /** Bandwidth (Hz) */
    bandwidth?: number;
    /** Number of points */
    points?: number;
    /** Noise floor (dBm) */
    noiseFloor?: number;
    /** Signals */
    signals?: Array<{
        frequency: number;
        power: number;
        bandwidth: number;
    }>;
}
/**
 * Generate a single RF spectrum snapshot
 */
export declare function generateSpectrum(config?: SpectrumGeneratorConfig): SpectrumDataPoint[];
export interface EclipseGeneratorConfig {
    /** Orbit period (seconds) */
    orbitPeriod?: number;
    /** Eclipse fraction (0-1) */
    eclipseFraction?: number;
    /** Number of orbits */
    orbits?: number;
    /** Include penumbra */
    includePenumbra?: boolean;
}
/**
 * Generate eclipse timeline data
 */
export declare function generateEclipseTimeline(config?: EclipseGeneratorConfig): EclipseTimelineData[];
export interface CoverageGeneratorConfig {
    /** Latitude resolution (degrees) */
    latResolution?: number;
    /** Longitude resolution (degrees) */
    lonResolution?: number;
    /** Number of orbital planes */
    planes?: number;
    /** Satellites per plane */
    satsPerPlane?: number;
    /** Orbit altitude (km) */
    altitude?: number;
    /** Orbit inclination (degrees) */
    inclination?: number;
    /** Metric to compute: 'visibility' | 'revisitTime' | 'latency' */
    metric?: "visibility" | "revisitTime" | "latency";
}
/**
 * Generate constellation coverage grid data
 *
 * Models simplified visibility based on satellite altitude
 * and ground footprint overlap from Walker constellation geometry.
 */
export declare function generateConstellationCoverage(config?: CoverageGeneratorConfig): {
    latitudes: number[];
    longitudes: number[];
    coverage: number[][];
    unit: string;
};
export interface ConjunctionGeneratorConfig {
    /** Primary object name */
    primaryName?: string;
    /** Number of events to generate */
    eventCount?: number;
    /** Time range in hours */
    timeRangeHours?: number;
    /** Include high-risk events */
    includeHighRisk?: boolean;
}
/**
 * Generate realistic conjunction/close approach events
 */
export declare function generateConjunctionEvents(config?: ConjunctionGeneratorConfig): Array<{
    id: string;
    primary: string;
    secondary: string;
    tca: number;
    missDistance: number;
    probability: number;
    relativeVelocity: number;
    position: {
        x: number;
        y: number;
        z: number;
    };
    uncertainty?: {
        rx: number;
        ry: number;
        rz: number;
    };
}>;
declare const _default: {
    generatePowerData: typeof generatePowerData;
    generateAttitudeData: typeof generateAttitudeData;
    generateDopplerData: typeof generateDopplerData;
    generateWaterfallData: typeof generateWaterfallData;
    generateContactWindows: typeof generateContactWindows;
    generateHeliocentricOrbits: typeof generateHeliocentricOrbits;
    generateSpectrum: typeof generateSpectrum;
    generateEclipseTimeline: typeof generateEclipseTimeline;
    generateConstellationCoverage: typeof generateConstellationCoverage;
    generateConjunctionEvents: typeof generateConjunctionEvents;
};
export default _default;