type WeatherType = 'sunny' | 'cloudy' | 'overcast' | 'rainy' | 'snowy' | 'haze' | 'foggy' | 'thunderstorm' | string;
type TimeMode = 'day' | 'night';
type RenderingContext2D = CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
/**
 * Weather intensity levels
 */
type WeatherIntensity = 'light' | 'moderate' | 'heavy';
interface RenderOptions {
    width?: number;
    height?: number;
    fps?: number;
    wind?: number;
}
interface WeatherConfig {
    type: WeatherType;
    mode: TimeMode;
    intensity?: WeatherIntensity;
}
interface Particle {
    x: number;
    y: number;
    vx: number;
    vy: number;
    life: number;
    maxLife: number;
    size?: number;
    opacity?: number;
    gravity?: number;
}
interface IntensityConfig {
    opacity: number;
    speed: number;
    particleCount: number;
    description: string;
}
type CloudStyle = 'rounded' | 'elliptical';
interface CloudConfig {
    count: number;
    widthRange: [number, number];
    heightRange: [number, number];
    speedRange: [number, number];
    opacityRange: [number, number];
    yRange: [number, number];
    style?: CloudStyle;
}
interface RainConfig {
    count: number;
    speed: number;
    opacity: number;
}
interface SnowConfig {
    count: number;
    speed: number;
    opacity: number;
}
interface FogConfig {
    count: number;
    color: string;
}
interface LightningConfig {
    color?: string;
}
interface MoonConfig {
    date?: Date;
}
interface StarsConfig {
    count?: number;
}
interface ShootingStarsConfig {
    frequency?: number;
    speed?: number;
    color?: string;
    spawnInterval?: {
        min: number;
        max: number;
    };
    life?: {
        min: number;
        max: number;
    };
}
interface BackgroundConfig {
    topColor: string;
    bottomColor: string;
}
type ElementConfig = {
    type: 'sun';
    options?: undefined;
} | {
    type: 'moon';
    options?: MoonConfig;
} | {
    type: 'stars';
    options?: StarsConfig;
} | {
    type: 'shooting-stars';
    options?: ShootingStarsConfig;
} | {
    type: 'cloud';
    options: CloudConfig;
} | {
    type: 'rain';
    options: RainConfig;
} | {
    type: 'snow';
    options: SnowConfig;
} | {
    type: 'fog';
    options: FogConfig;
} | {
    type: 'lightning';
    options?: LightningConfig;
} | {
    type: 'background';
    options: BackgroundConfig;
};
interface CustomWeatherConfig {
    background: {
        day: [string, string];
        night: [string, string];
    };
    elements: Array<ElementConfig & {
        modes?: TimeMode[];
    }>;
}
declare const INTENSITY_CONFIG: {
    light: {
        opacity: number;
        speed: number;
        particleCount: number;
        description: string;
    };
    moderate: {
        opacity: number;
        speed: number;
        particleCount: number;
        description: string;
    };
    heavy: {
        opacity: number;
        speed: number;
        particleCount: number;
        description: string;
    };
};
/**
 * Get intensity configuration
 */
declare function getIntensityConfig(intensity: WeatherIntensity): {
    opacity: number;
    speed: number;
    particleCount: number;
    description: string;
} | {
    opacity: number;
    speed: number;
    particleCount: number;
    description: string;
} | {
    opacity: number;
    speed: number;
    particleCount: number;
    description: string;
};

/**
 * Main weather Canvas renderer class
 */
declare class WeatherCanvasRenderer {
    private canvas;
    private ctx;
    private width;
    private height;
    private fps;
    private frameInterval;
    private animationId;
    private lastFrameTime;
    private currentWeather;
    private currentMode;
    private currentIntensity;
    private currentEffect;
    private currentWind;
    private effectMap;
    private customWeatherMap;
    /**
     * Constructor
     * @param canvas Canvas DOM element
     * @param options Configuration options
     */
    constructor(canvas: HTMLCanvasElement | OffscreenCanvas, options?: RenderOptions);
    /**
     * Initialize all weather effects
     */
    private initializeEffects;
    /**
     * Create effect instance for specified weather, time mode and intensity
     */
    private createEffect;
    /**
     * Register a custom weather effect configuration
     * @param name Unique name for the weather effect
     * @param config Configuration object defining the elements and background
     */
    registerWeather(name: string, config: CustomWeatherConfig): void;
    /**
     * Render specified weather, time mode and intensity
     */
    render(weatherType: WeatherType, mode: TimeMode, intensity?: WeatherIntensity): void;
    /**
     * Start animation loop
     */
    start(): void;
    /**
     * Stop animation loop
     */
    stop(): void;
    /**
     * Main animation loop
     */
    private animate;
    /**
     * Update animation state
     */
    private update;
    /**
     * Draw frame
     */
    private draw;
    /**
     * Set Canvas size
     */
    setSize(width: number, height: number): void;
    /**
     * Change weather type
     */
    setWeatherType(weatherType: WeatherType): void;
    /**
     * Change time mode
     */
    setMode(mode: TimeMode): void;
    /**
     * Change weather intensity
     */
    setIntensity(intensity: WeatherIntensity): void;
    /**
     * Change wind speed
     */
    setWind(wind: number): void;
    /**
     * Clear Canvas
     */
    clear(): void;
    /**
     * Destroy instance
     */
    destroy(): void;
    getWeatherType(): WeatherType;
    getMode(): TimeMode;
    getIntensity(): WeatherIntensity;
    getWind(): number;
    getCanvas(): HTMLCanvasElement | OffscreenCanvas;
    getWidth(): number;
    getHeight(): number;
}

interface WeatherElement {
    update(time?: number): void;
    render(time?: number): void;
    resize(width: number, height: number): void;
    setWind?(wind: number): void;
    destroy?(): void;
}

declare abstract class WeatherEffect {
    protected ctx: RenderingContext2D;
    protected width: number;
    protected height: number;
    protected time: number;
    protected intensity: WeatherIntensity;
    protected intensityConfig: IntensityConfig;
    protected wind: number;
    protected elements: WeatherElement[];
    constructor(ctx: RenderingContext2D, width: number, height: number, intensity?: WeatherIntensity, wind?: number);
    abstract render(time: number): void;
    protected renderElements(time: number): void;
    update(): void;
    setWind(wind: number): void;
    resize(width: number, height: number): void;
    protected getParticleCount(baseCount: number): number;
    protected getSpeed(baseSpeed: number): number;
    protected getOpacity(baseOpacity: number): number;
    protected drawGradient(x1: number, y1: number, x2: number, y2: number, stops: Array<[number, string]>): CanvasGradient;
    protected drawRadialGradient(x: number, y: number, r1: number, r2: number, stops: Array<[number, string]>): CanvasGradient;
}

declare class SunnyEffect extends WeatherEffect {
    private mode;
    constructor(ctx: RenderingContext2D, width: number, height: number, mode?: TimeMode, intensity?: WeatherIntensity, wind?: number);
    render(time: number): void;
}

declare class CloudyEffect extends WeatherEffect {
    private mode;
    constructor(ctx: RenderingContext2D, width: number, height: number, mode?: TimeMode, intensity?: WeatherIntensity, wind?: number);
    render(time: number): void;
}

declare class OvercastEffect extends WeatherEffect {
    private mode;
    constructor(ctx: RenderingContext2D, width: number, height: number, mode?: TimeMode, intensity?: WeatherIntensity, wind?: number);
    render(time: number): void;
}

declare class RainyEffect extends WeatherEffect {
    private mode;
    constructor(ctx: RenderingContext2D, width: number, height: number, mode?: TimeMode, intensity?: WeatherIntensity, wind?: number);
    render(time: number): void;
}

declare class SnowyEffect extends WeatherEffect {
    private mode;
    constructor(ctx: RenderingContext2D, width: number, height: number, mode?: TimeMode, intensity?: WeatherIntensity, wind?: number);
    render(time: number): void;
}

declare class HazeEffect extends WeatherEffect {
    private mode;
    constructor(ctx: RenderingContext2D, width: number, height: number, mode?: TimeMode, intensity?: WeatherIntensity, wind?: number);
    render(time: number): void;
}

declare class FoggyEffect extends WeatherEffect {
    private mode;
    constructor(ctx: RenderingContext2D, width: number, height: number, mode?: TimeMode, intensity?: WeatherIntensity, wind?: number);
    render(time: number): void;
}

declare class ThunderstormEffect extends WeatherEffect {
    private mode;
    constructor(ctx: RenderingContext2D, width: number, height: number, mode?: TimeMode, intensity?: WeatherIntensity, wind?: number);
    render(time: number): void;
}

declare class CustomEffect extends WeatherEffect {
    private config;
    private mode;
    constructor(ctx: RenderingContext2D, width: number, height: number, config: CustomWeatherConfig, mode?: TimeMode, intensity?: WeatherIntensity, wind?: number);
    private initializeElements;
    private addElement;
    render(time: number): void;
}

declare class ParticlePool {
    private pool;
    private active;
    constructor(initialSize?: number);
    private createParticle;
    get(x: number, y: number, vx: number, vy: number, life: number, gravity?: number): Particle;
    update(): void;
    getActive(): Particle[];
    clear(): void;
}

declare function randomBetween(min: number, max: number): number;
declare function clamp(value: number, min: number, max: number): number;
declare function easeInOutQuad(t: number): number;
declare function easeInOutCubic(t: number): number;

declare class WeatherCanvas extends HTMLElement {
    private renderer;
    private canvas;
    private shadow;
    constructor();
    connectedCallback(): void;
    disconnectedCallback(): void;
    static get observedAttributes(): string[];
    attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
    start(): void;
    stop(): void;
    registerCustomWeather(name: string, config: CustomWeatherConfig): void;
}

export { CloudyEffect, CustomEffect, FoggyEffect, HazeEffect, INTENSITY_CONFIG, OvercastEffect, ParticlePool, RainyEffect, type RenderOptions, SnowyEffect, SunnyEffect, ThunderstormEffect, type TimeMode, WeatherCanvas, WeatherCanvasRenderer, type WeatherConfig, WeatherEffect, type WeatherIntensity, type WeatherType, clamp, easeInOutCubic, easeInOutQuad, getIntensityConfig, randomBetween };