import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import { SeverityLevel } from "./Severity";
import { LocationFix } from "./foxglove/LocationFix";
/**
 * Observed precipitation type. Published on the precipitation_type subject.
 * Intensity is intentionally not modelled here: it is derivable from
 * precipitation_rate_mmph and is therefore a consumer-side mapping.
 */
export interface PrecipitationType {
    $type: "keelson.PrecipitationType";
    timestamp: Date | undefined;
    type: PrecipitationType_Type;
}
export declare enum PrecipitationType_Type {
    TYPE_UNSPECIFIED = 0,
    /** NONE - observed dry */
    NONE = 1,
    RAIN = 2,
    DRIZZLE = 3,
    SNOW = 4,
    SLEET = 5,
    HAIL = 6,
    FREEZING_RAIN = 7,
    MIXED = 8,
    UNRECOGNIZED = -1
}
export declare function precipitationType_TypeFromJSON(object: any): PrecipitationType_Type;
export declare function precipitationType_TypeToJSON(object: PrecipitationType_Type): string;
/** Observed ice type (WMO sea-ice nomenclature). Published on the ice_type subject. */
export interface IceType {
    $type: "keelson.IceType";
    timestamp: Date | undefined;
    type: IceType_Type;
}
export declare enum IceType_Type {
    TYPE_UNSPECIFIED = 0,
    FRAZIL = 1,
    GREASE = 2,
    SLUSH = 3,
    SHUGA = 4,
    NILAS = 5,
    PANCAKE = 6,
    FIRST_YEAR = 7,
    MULTI_YEAR = 8,
    GLACIER = 9,
    ICEBERG = 10,
    UNRECOGNIZED = -1
}
export declare function iceType_TypeFromJSON(object: any): IceType_Type;
export declare function iceType_TypeToJSON(object: IceType_Type): string;
/**
 * A weather warning issued by an external authority (SMHI, NOAA, ...).
 * Quarantined external product: free-form pass-through fields, provenance, and
 * a validity window. Not assembled from live measurement subjects.
 */
export interface WeatherAlert {
    $type: "keelson.WeatherAlert";
    /** Stable, issuer-scoped identifier. */
    id: string;
    /** Shared severity vocabulary (Severity.proto) -- no per-domain scale. */
    severity: SeverityLevel;
    /**
     * Free-form category as issued, e.g. "gale", "tropical-cyclone", "ice".
     * A pass-through label, intentionally not an enum keelson maintains.
     */
    category: string;
    headline: string;
    description: string;
    /** Validity window. */
    effectiveAt: Date | undefined;
    expiresAt: Date | undefined;
    /** Provenance. */
    issuer: string;
    affectedAreas: string[];
}
/**
 * A weather forecast for a location, as issued by an external model / source.
 * Quarantined external product with confined scope: it enumerates exactly the
 * quantities the contract predicts and does NOT embed live measurement types.
 */
export interface WeatherForecast {
    $type: "keelson.WeatherForecast";
    /** Location the forecast applies to. */
    location: LocationFix | undefined;
    /** Provenance. */
    issuedAt: Date | undefined;
    /** e.g. "ECMWF", "GFS", model-run name */
    source: string;
    /** Ordered series of predicted valid-times. */
    steps: WeatherForecast_Step[];
    /** Alerts attached to this forecast. */
    alerts: WeatherAlert[];
}
/**
 * One predicted valid-time. Nested on purpose: this type is confined to the
 * forecast contract -- it cannot acquire its own subject and cannot be reused
 * by live-domain code. Field NAMES mirror the live atomic subjects so a
 * consumer reads them without translation, but the TYPES are local floats:
 * the external contract stays self-contained and drags no live enums across.
 *
 * `optional` gives explicit presence -- a model that does not predict a field
 * omits it, which is distinct from a real 0.0.
 */
export interface WeatherForecast_Step {
    $type: "keelson.WeatherForecast.Step";
    validAt: Date | undefined;
    trueWindSpeedMps?: number | undefined;
    trueWindDirectionDeg?: number | undefined;
    trueWindGustMps?: number | undefined;
    waveHeightSignificantM?: number | undefined;
    wavePeriodS?: number | undefined;
    waveTrueDirectionDeg?: number | undefined;
    precipitationRateMmph?: number | undefined;
    /** PoP -- a forecast concept, [0, 100] */
    precipitationProbabilityPct?: number | undefined;
    visibilityRangeM?: number | undefined;
    airTemperatureCelsius?: number | undefined;
    /**
     * Deliberately limited to the marine-relevant core. Extend when a real
     * producer needs more -- provisional until then.
     */
    airPressurePa?: number | undefined;
}
export declare const PrecipitationType: MessageFns<PrecipitationType, "keelson.PrecipitationType">;
export declare const IceType: MessageFns<IceType, "keelson.IceType">;
export declare const WeatherAlert: MessageFns<WeatherAlert, "keelson.WeatherAlert">;
export declare const WeatherForecast: MessageFns<WeatherForecast, "keelson.WeatherForecast">;
export declare const WeatherForecast_Step: MessageFns<WeatherForecast_Step, "keelson.WeatherForecast.Step">;
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in Exclude<keyof T, "$type">]?: DeepPartial<T[K]>;
} : Partial<T>;
type KeysOfUnion<T> = T extends T ? keyof T : never;
type Exact<P, I extends P> = P extends Builtin ? P : P & {
    [K in keyof P]: Exact<P[K], I[K]>;
} & {
    [K in Exclude<keyof I, KeysOfUnion<P> | "$type">]: never;
};
interface MessageFns<T, V extends string> {
    readonly $type: V;
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}
export {};