@sierragridteam/sdk 0.0.0-stage → 0.1.1

package/dist/generated/types.gen.d.ts

@@ -0,0 +1,3474 @@
+export type ClientOptions = {
+    baseUrl: 'https://data.sierragridteam.org' | (string & {});
+};
+export type BurnLineReading = {
+    cleaned_transcription?: string;
+    confidence?: number;
+    /**
+     * A configured line id (grid.burn.lines); unknown ids are warnings.
+     */
+    line_id: string;
+    message?: string;
+    /**
+     * When the line was called. Required; future stamps are clamped.
+     */
+    observed_at: string;
+    /**
+     * green = permissive burn day.
+     */
+    status: 'green' | 'red' | 'orange';
+};
+/**
+ * `burn.line` (schema_version 1): readings of the county burn-day phone
+ * recordings, sent as ONE batched report per run (the per-reporter rate
+ * limit would 429 a second push). Each reading is staged durably.
+ *
+ */
+export type BurnLineReport = {
+    generated_at?: string;
+    readings: Array<BurnLineReading>;
+    schema_version: 1;
+};
+/**
+ * An RFC 7946 geometry object, the same shape as a map feature's
+ * `geometry` (MapGeometry) but never `null`: an event's or place's
+ * `geometry.object` when the request passes `geometryFormat=OBJECT`.
+ * A position is `[longitude, latitude]`, longitude first.
+ *
+ */
+export type GeoJsonGeometry = MapGeometry;
+/**
+ * The 202 body. Validated and queued, not yet stored; it lands on the next ingest cycle (about a minute).
+ */
+export type IngestAccepted = {
+    /**
+     * mesh.repeater: nodes accepted. mesh.packet: ADVERTs applied (not packets received). burn.line: readings staged.
+     */
+    accepted: number;
+    receivedAt: string;
+    /**
+     * The reporter the token belongs to.
+     */
+    reporterId: string;
+    stream: string;
+    /**
+     * Entries skipped without failing the report (bad id, duplicate, unknown line, bad signature). Fix your output if present. mesh.packet lists at most 25, then a count.
+     */
+    warnings?: Array<string>;
+};
+/**
+ * A JSON-RPC 2.0 request. Omit `id` for a notification (answered 202, no body).
+ */
+export type JsonRpcRequest = {
+    /**
+     * Request id (string or number), echoed in the response.
+     */
+    id?: unknown;
+    jsonrpc: '2.0';
+    method: 'initialize' | 'ping' | 'tools/list' | 'tools/call' | 'resources/list' | 'resources/read' | 'prompts/list' | 'prompts/get' | 'notifications/initialized';
+    params?: {
+        [key: string]: unknown;
+    };
+};
+export type JsonRpcResponse = {
+    /**
+     * Present on failure. -32700 parse error, -32601 method not found, -32602 invalid params, -32603 internal error.
+     */
+    error?: {
+        code: number;
+        message: string;
+    };
+    /**
+     * The request's id; null when the request could not be parsed.
+     */
+    id?: unknown;
+    jsonrpc: '2.0';
+    /**
+     * Present on success.
+     */
+    result?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * camera block - a Caltrans CCTV camera, same data as GET /api/v1/cameras?place=. Load the image and stream directly from Caltrans; they are not proxied.
+ */
+export type MapCameraProps = {
+    county?: string;
+    direction?: string;
+    /**
+     * Distance from the requested place; 0 = inside it.
+     */
+    distanceMeters: number;
+    elevationFeet?: number;
+    /**
+     * How often Caltrans refreshes the snapshot. Absent = not reported.
+     */
+    imageRefreshMinutes?: number;
+    /**
+     * Snapshot JPEG.
+     */
+    imageUrl: string;
+    route?: string;
+    /**
+     * HLS .m3u8 live stream. Absent = image only.
+     */
+    streamUrl?: string;
+};
+/**
+ * chain_control block. Severity follows the level (R1 MINOR, R2 MODERATE, R3 SEVERE); a seasonal pass closure (`category` closed) is MINOR.
+ */
+export type MapChainControlProps = {
+    direction?: string;
+    highway?: string;
+    /**
+     * Absent on a closure.
+     */
+    level?: 'R1' | 'R2' | 'R3';
+};
+/**
+ * Set on Caltrans planned lane closures (category `closure`) only. One
+ * feature per work window. `plannedEnd` is an estimate crews overrun: an
+ * ACTIVE closure past it is still on the road until Caltrans records it
+ * picked up.
+ *
+ */
+export type MapClosureProps = {
+    closureType?: string;
+    estimatedDelayMinutes?: number;
+    /**
+     * Caltrans's lane list, verbatim., example: "1, 2, LShoulder, RShoulder"
+     */
+    lanesClosed?: string;
+    plannedEnd?: string;
+    plannedStart?: string;
+    /**
+     * When the crew reported the closure set up. Absent while SCHEDULED.
+     */
+    setUpAt?: string;
+    totalLanes?: number;
+    windowId: string;
+    workType?: string;
+};
+/**
+ * earthquake block (USGS).
+ */
+export type MapEarthquakeProps = {
+    depthKm: number;
+    /**
+     * USGS "Did You Feel It?" reports.
+     */
+    felt?: number;
+    magnitude: number;
+};
+/**
+ * evacuation block (Cal OES / Genasys zones). Life-safety; reference only, link `source.url`.
+ */
+export type MapEvacuationProps = {
+    county?: string;
+    eventType?: string;
+    level: 'ORDER' | 'WARNING' | 'ADVISORY' | 'SHELTER_IN_PLACE';
+    zoneId?: string;
+};
+/**
+ * An RFC 7946 Feature.
+ */
+export type MapFeature = {
+    geometry: MapGeometry;
+    properties: MapFeatureProperties;
+    type: 'Feature';
+};
+/**
+ * An RFC 7946 FeatureCollection for one place and one layer. `metadata` is
+ * an RFC 7946 §6.1 foreign member that map libraries ignore; read it for
+ * source health and attribution before drawing.
+ *
+ */
+export type MapFeatureCollection = {
+    /**
+     * Possibly empty. Empty with `sourceStatus` OK means confirmed-empty; empty with UNAVAILABLE means unknown.
+     */
+    features: Array<MapFeature>;
+    metadata: MapLayerMetadata;
+    type: 'FeatureCollection';
+};
+/**
+ * The envelope shared by every feature of every layer, plus exactly one
+ * per-kind block named after the layer (`incident`, `road`,
+ * `chainControl`, `messageSign`, `weather`, `fireWeather`, `earthquake`,
+ * `wildfire`, `evacuation`, `power`, `mesh`, `meshLink`, `camera`).
+ * Optional members are omitted, never `""` or `0`, when they have no value.
+ *
+ */
+export type MapFeatureProperties = {
+    /**
+     * Where, in words ("SR 4 at Country Club Drive", "Murphys, CA").
+     */
+    areaLabel?: string;
+    camera?: MapCameraProps;
+    /**
+     * Sub-type within the layer. Values by layer:
+     * road_incident `incident` (CHP) | `closure` (Caltrans planned lane closure);
+     * chain_control `r1` | `r2` | `r3` | `closed`;
+     * message_sign `message` | `blank` | `unknown`;
+     * weather_alert the NWS event name (`Heat Advisory`, `Red Flag Warning`);
+     * fire_weather banner `normal` | `elevated` | `red-flag` (absent on forecast points);
+     * wildfire `wildfire`; evacuation the lowercase level (`order`, `warning`, …);
+     * power `unplanned` | `planned` | `psps`;
+     * mesh_node the node type `repeater` | `companion` | `room_server` | `sensor`.
+     * Absent on road_segment, camera and mesh_link edges.
+     *
+     */
+    category?: string;
+    chainControl?: MapChainControlProps;
+    /**
+     * Longer text. road_incident: the readable narrative (AI-enhanced for
+     * CHP, composed from Caltrans fields for closures). evacuation: Cal OES
+     * public info, verbatim, never paraphrase. weather_alert: the NWS text,
+     * verbatim. road_segment: why a road is not OPEN.
+     *
+     */
+    description?: string;
+    earthquake?: MapEarthquakeProps;
+    /**
+     * When it began or takes effect (a SCHEDULED feature's start).
+     */
+    effective?: string;
+    evacuation?: MapEvacuationProps;
+    /**
+     * Upstream expiry (weather alerts, fire-weather products). Not set from PG&E restoration estimates.
+     */
+    expires?: string;
+    fireWeather?: MapFireWeatherProps;
+    /**
+     * One-line label for a popup or list row.
+     */
+    headline: string;
+    /**
+     * Stable feature id. On event-backed layers it IS the event id, so
+     * `GET /api/v1/events/{id}` returns the full record and its history
+     * (`wildfire`, `evacuation`, `weather_alert`, `earthquake`,
+     * `road_incident`, `power`, `mesh_node`). Condition layers use their
+     * own ids (`road:…`, `cc:…`, `cms:…`, `fw:…`, `mesh_link:…`, `d10-…`).
+     *
+     */
+    id: string;
+    incident?: MapIncidentProps;
+    /**
+     * Human label for the feature type.
+     */
+    kind: 'Road incident' | 'Chain control' | 'Road segment' | 'Message sign' | 'Weather alert' | 'Fire weather' | 'Fire-weather forecast' | 'Earthquake' | 'Wildfire' | 'Evacuation' | 'Power outage' | 'Public Safety Power Shutoff' | 'Mesh node' | 'Relay link' | 'Traffic camera';
+    /**
+     * UPPERCASE layer of THIS feature. Usually the URL layer upper-cased,
+     * except that the `mesh_link` layer mixes `MESH_LINK` edges and
+     * `MESH_NODE` points. Only some values equal an Event `layer` enum
+     * (`v1Layer`): WILDFIRE, EVACUATION, WEATHER_ALERT, EARTHQUAKE,
+     * ROAD_INCIDENT and POWER do. MESH_NODE is the Event layer `MESH`.
+     * ROAD_SEGMENT, CHAIN_CONTROL, MESSAGE_SIGN, MESH_LINK and CAMERA are
+     * map-only. FIRE_WEATHER exists in the enum but these features are
+     * conditions, not events.
+     *
+     */
+    layer: 'ROAD_INCIDENT' | 'CHAIN_CONTROL' | 'ROAD_SEGMENT' | 'MESSAGE_SIGN' | 'WEATHER_ALERT' | 'FIRE_WEATHER' | 'EARTHQUAKE' | 'WILDFIRE' | 'EVACUATION' | 'POWER' | 'MESH_NODE' | 'MESH_LINK' | 'CAMERA';
+    mesh?: MapMeshProps;
+    meshLink?: MapMeshLinkProps;
+    messageSign?: MapMessageSignProps;
+    power?: MapPowerProps;
+    road?: MapRoadProps;
+    /**
+     * Unified severity. `message_sign`, `camera`, `mesh_node`, `mesh_link`
+     * and fire-weather forecast points are always `INFO` (context, not
+     * hazards). Most power outages are INFO too: the median outage affects
+     * one customer.
+     *
+     */
+    severity: 'INFO' | 'MINOR' | 'MODERATE' | 'SEVERE' | 'EXTREME';
+    /**
+     * Numeric severity for sorting and styling: INFO 0, MINOR 1, MODERATE 2, SEVERE 3, EXTREME 4.
+     */
+    severityRank: number;
+    source: MapFeatureSource;
+    /**
+     * Meaning depends on the layer, and it is NOT always the Event
+     * `EventStatus`:
+     * - wildfire, weather_alert, earthquake, road_incident, power,
+     * mesh_node: the lifecycle `ACTIVE` or `SCHEDULED` (an advance watch,
+     * a planned closure window not yet set up, a planned shutoff). Map
+     * layers never carry RESOLVED or EXPIRED features; those are in
+     * `/api/v1/history`.
+     * - evacuation: the evacuation LEVEL `ORDER` | `WARNING` | `ADVISORY` |
+     * `SHELTER_IN_PLACE`.
+     * - road_segment: the road status `OPEN` | `CLOSED` | `RESTRICTED` |
+     * `MAINTENANCE` (absent until the road has been measured).
+     * - absent on chain_control, message_sign, fire_weather, camera and
+     * mesh_link edges.
+     *
+     */
+    status?: 'ACTIVE' | 'SCHEDULED' | 'ORDER' | 'WARNING' | 'ADVISORY' | 'SHELTER_IN_PLACE' | 'OPEN' | 'CLOSED' | 'RESTRICTED' | 'MAINTENANCE' | 'UNSPECIFIED';
+    /**
+     * AI-written plain-language summary (same as Event.summary). Absent when the event has none; fall back to `description`.
+     */
+    summary?: string;
+    /**
+     * Present with `summary` when a model wrote it, so a UI can label it as machine-written.
+     */
+    summaryEnhanced?: {
+        enhancedAt?: string;
+    };
+    /**
+     * Last content revision. For mesh nodes this is NOT liveness; use mesh.lastHeardAt / lastRelayedAt.
+     */
+    updatedAt?: string;
+    weather?: MapWeatherProps;
+    wildfire?: MapWildfireProps;
+};
+/**
+ * The upstream feed this feature came from. Render `attribution` with the feature.
+ */
+export type MapFeatureSource = {
+    attribution?: string;
+    fetchedAt?: string;
+    /**
+     * The upstream's id. Values today: `calfire`, `firis`, `caloes`,
+     * `nws`, `usgs`, `chp`, `caltrans`, `google`, `pge`, `psps`,
+     * `meshcore`. On the event-backed layers (`wildfire`,
+     * `evacuation`, `weather_alert`, `earthquake`, `road_incident`,
+     * `power`, `mesh_node`) it is the event's `provenance.sourceId` and
+     * has a row in `GET /api/v1/sources` whose `status` is that feed's
+     * health.
+     *
+     * The condition layers (`road_segment`, `chain_control`,
+     * `message_sign`, `fire_weather`), and `camera` and `mesh_link`, are
+     * fetched or computed on request, outside the ingest scheduler that
+     * writes the registry. `google` (on `road_segment`) has no registry
+     * row at all. `caltrans` and `nws` do have rows, but those track the
+     * scheduled lane-closure and alert polls, not the live fetch behind
+     * these layers. For these layers judge health by the layer's
+     * `metadata.sourceStatus` (the summary's `roads` and `fire` domains
+     * fold the same statuses in), never by a missing or unrelated
+     * registry row.
+     *
+     */
+    id: string;
+    name: string;
+    /**
+     * Deep link to the upstream record or viewer, when there is one.
+     */
+    url?: string;
+};
+/**
+ * fire_weather block. The region banner (id `fw:region`, null geometry)
+ * carries the ISSUED `state`; only NWS products set it (Fire Weather Watch
+ * -> elevated, Red Flag Warning -> red-flag). Forecast points (id
+ * `fw:forecast:<location>`) carry `forecast` instead, are always INFO and
+ * never imply a warning.
+ *
+ */
+export type MapFireWeatherProps = {
+    forecast?: {
+        horizonHours?: number;
+        issuedAt?: string;
+        minHumidityPercent?: number;
+        peakWindGustAt?: string;
+        peakWindGustKmh?: number;
+        source?: string;
+    };
+    /**
+     * The NWS product behind the state, e.g. Red Flag Warning.
+     */
+    sourceEvent?: string;
+    state?: 'normal' | 'elevated' | 'red-flag';
+    zones?: Array<string>;
+};
+/**
+ * An RFC 7946 geometry, or `null` for a feature with no location (NWS zone
+ * alerts and the fire-weather region banner): render those as a banner
+ * or list row, not a shape.
+ *
+ * A position is `[longitude, latitude]`, longitude FIRST (RFC 7946
+ * §3.1.1), the reverse of the `{lat, lng}` objects on the JSON RPCs.
+ * Store-derived positions are trimmed to 5 decimals (~1 m).
+ *
+ * Which types appear: Point (most layers: incidents, signs, cameras,
+ * chain controls, quakes, mesh nodes, forecast points, unmapped fires);
+ * LineString (road_segment routes, mesh_link edges); Polygon or
+ * MultiPolygon (power outage areas, evacuation zones, fire perimeters).
+ * Geometry passed through from an upstream ArcGIS feed may be any RFC 7946
+ * type except GeometryCollection.
+ *
+ */
+export type MapGeometry = {
+    /**
+     * Nesting depends on `type`:
+     * Point `[lng, lat]`;
+     * MultiPoint and LineString `[[lng, lat], ...]` (a LineString has 2+);
+     * MultiLineString and Polygon `[[[lng, lat], ...], ...]` (a Polygon's
+     * first ring is the exterior; every ring closes on its first position);
+     * MultiPolygon `[[[[lng, lat], ...], ...], ...]`.
+     *
+     */
+    coordinates: Array<unknown>;
+    type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon';
+} | null;
+/**
+ * road_incident block.
+ */
+export type MapIncidentProps = {
+    closure?: MapClosureProps;
+    /**
+     * CHP log number, or the Caltrans closure id.
+     */
+    logNumber?: string;
+};
+/**
+ * Provenance and freshness of the whole layer.
+ */
+export type MapLayerMetadata = {
+    /**
+     * Slug of the requested place (even when it was requested by id).
+     */
+    area: string;
+    /**
+     * Credit line to render with the layer whenever it is drawn. Parts are joined with " · ".
+     */
+    attribution?: string;
+    /**
+     * When this body was rendered. Not part of the ETag.
+     */
+    generatedAt: string;
+    /**
+     * Last successful upstream fetch. Present only when `sourceStatus` is not OK and a success is on record.
+     */
+    lastSourceUpdate?: string;
+    /**
+     * The lowercase layer slug from the URL (not the UPPERCASE `properties.layer`).
+     */
+    layer: 'road_incident' | 'chain_control' | 'road_segment' | 'message_sign' | 'weather_alert' | 'fire_weather' | 'earthquake' | 'wildfire' | 'evacuation' | 'power' | 'mesh_node' | 'mesh_link' | 'camera';
+    /**
+     * Envelope schema version; bumps only on a breaking envelope change.
+     */
+    schemaVersion: 1;
+    /**
+     * Health of the feeds behind this layer, the fail-loud contract:
+     * `OK` - current and complete. `STALE` - upstream is failing (or one
+     * of two feeds is); these features are the last good data, as of
+     * `lastSourceUpdate`. Show them with a caveat. `UNAVAILABLE` - nothing
+     * trustworthy to show; `features` is always empty and the layer's
+     * state is UNKNOWN. Never render it as "no hazards".
+     *
+     */
+    sourceStatus: 'OK' | 'STALE' | 'UNAVAILABLE';
+    /**
+     * The authoritative viewer for the layer, where one exists. Always set on `evacuation` (Genasys Protect), in every state.
+     */
+    sourceUrl?: string;
+};
+/**
+ * The last sample an operator monitor read off the node itself. Gauges the device did not report are absent, never 0.
+ */
+export type MapMeshAdminProps = {
+    airtimeMs?: number;
+    batteryPercent?: number;
+    batteryPercentSource?: string;
+    batteryVolts?: number;
+    lastSuccessAt?: string;
+    noiseFloorDbm?: number;
+    packetsReceived?: number;
+    packetsSent?: number;
+    recvErrors?: number;
+    reportedAt?: string;
+    reporterId: string;
+    rxAirtimeMs?: number;
+    temperatureC?: number;
+    txQueueLen?: number;
+    uptimeSeconds?: number;
+};
+/**
+ * mesh_link edge block - one undirected relay link between two located nodes. Weight by `daysActive`/`observations`, fade by `lastSeen`.
+ */
+export type MapMeshLinkProps = {
+    /**
+     * Public key of one end (a < b).
+     */
+    a: string;
+    /**
+     * Public key of the other end.
+     */
+    b: string;
+    /**
+     * Peak SNR of an advert over the link. Absent when 0.
+     */
+    bestSnr?: number;
+    /**
+     * Distinct days the link was observed.
+     */
+    daysActive: number;
+    firstSeen?: string;
+    lastSeen?: string;
+    /**
+     * Packets seen traversing the link in the window.
+     */
+    observations: number;
+};
+/**
+ * mesh_node block (MeshCore node presence; also on the MESH_NODE points of
+ * the mesh_link layer). Signal readings are absent when no bridge heard the
+ * node; a present 0 is a reading. A node's freshness is the later of
+ * `lastHeardAt` and `lastRelayedAt`, never the feature's `updatedAt`.
+ *
+ */
+export type MapMeshProps = {
+    admin?: MapMeshAdminProps;
+    /**
+     * Public keys of the observers that heard the node.
+     */
+    gateways?: Array<string>;
+    /**
+     * Hops on the last heard path. 0 = heard direct.
+     */
+    hopCount?: number;
+    /**
+     * mesh_link layer only: true = inside the requested place, false = a neighbour outside it, included because it links in.
+     */
+    inRegion?: boolean;
+    /**
+     * When the node's own signed advert last reached the Grid.
+     */
+    lastHeardAt?: string;
+    /**
+     * When a packet this node relayed last reached the Grid.
+     */
+    lastRelayedAt?: string;
+    name?: string;
+    nodeType?: 'companion' | 'repeater' | 'room_server' | 'sensor';
+    /**
+     * 64-hex Ed25519 public key; joins to MeshLink a/b.
+     */
+    publicKey: string;
+    /**
+     * An operator monitor's verdict on the node's admin interface. Absent when no monitor watches it.
+     */
+    reachability?: 'REACHABLE' | 'UNREACHABLE';
+    /**
+     * Last-heard RSSI, dBm.
+     */
+    rssi?: number;
+    /**
+     * Last-heard SNR, dB.
+     */
+    snr?: number;
+};
+/**
+ * message_sign block - what a Caltrans changeable message sign is showing, verbatim. Context, not a hazard.
+ */
+export type MapMessageSignProps = {
+    direction?: string;
+    district: number;
+    inService: boolean;
+    /**
+     * One or two pages of exactly three lines; a blank line is "". Absent when the sign is blank or unreadable.
+     */
+    pages?: Array<[
+        string,
+        string,
+        string
+    ]>;
+    route?: string;
+    signId: string;
+};
+/**
+ * power block, both PG&E feeds. `category` unplanned|planned sets the
+ * outage fields; `psps` (Public Safety Power Shutoff) sets the PSPS fields.
+ * `estimatedRestoration`, `deEnergizationEnd` and `allClear` are PG&E
+ * ESTIMATES that are routinely overrun; label them as estimates.
+ *
+ */
+export type MapPowerProps = {
+    /**
+     * PG&E's PLANNED all-clear, not proof the shutoff ended.
+     */
+    allClear?: string;
+    /**
+     * Raw PG&E cause code, often blank.
+     */
+    cause?: string;
+    crewStatus?: string;
+    customersAffected?: number;
+    deEnergizationEnd?: string;
+    deEnergizationStart?: string;
+    estimatedRestoration?: string;
+    eventName?: string;
+    /**
+     * Customers whose medical equipment depends on grid power.
+     */
+    medicalBaselineAffected?: number;
+    outageId?: string;
+    stage?: 'Watch' | 'Warning';
+};
+/**
+ * road_segment block (Google Routes travel time over a configured route). The numbers are absent, not 0, until the route has been measured.
+ */
+export type MapRoadProps = {
+    congestion?: 'CLEAR' | 'LIGHT' | 'MODERATE' | 'HEAVY' | 'SEVERE' | 'UNSPECIFIED';
+    /**
+     * Minutes over free-flow. 0 is a real reading.
+     */
+    delayMinutes?: number;
+    distanceKm?: number;
+    durationMinutes?: number;
+    roadId: string;
+};
+/**
+ * weather_alert block. The NWS CAP fields are verbatim; `nwsSeverity` is NWS's own scale, distinct from the unified `severity`.
+ */
+export type MapWeatherProps = {
+    certainty?: string;
+    event?: string;
+    /**
+     * NWS instruction text. Never paraphrase.
+     */
+    instruction?: string;
+    nwsSeverity?: 'Extreme' | 'Severe' | 'Moderate' | 'Minor' | 'Unknown';
+    source?: 'NWS';
+    urgency?: string;
+    zones?: Array<string>;
+};
+/**
+ * wildfire block (CAL FIRE incidents and FIRIS perimeters).
+ */
+export type MapWildfireProps = {
+    acres?: number;
+    cause?: string;
+    /**
+     * Percent contained.
+     */
+    containment: number;
+    county?: string;
+    /**
+     * True when the geometry is a mapped perimeter rather than a point.
+     */
+    hasPerimeter: boolean;
+};
+/**
+ * One undirected relay link. Every member is always present.
+ */
+export type MeshLink = {
+    /**
+     * Public key (64 hex) of one end; a < b.
+     */
+    a: string;
+    /**
+     * Public key of the other end.
+     */
+    b: string;
+    /**
+     * Peak SNR (dB) of an advert seen traversing it; 0 when none was measured.
+     */
+    bestSnr: number;
+    /**
+     * Distinct days observed; a reliability weight.
+     */
+    daysActive: number;
+    firstSeen: string;
+    /**
+     * Drive recency fade from this.
+     */
+    lastSeen: string;
+    /**
+     * Packets seen traversing the link in the window.
+     */
+    observations: number;
+};
+export type MeshLinkList = {
+    generatedAt: string;
+    links: Array<MeshLink>;
+    /**
+     * The window applied, e.g. 72h., example: 72h
+     */
+    window: string;
+};
+/**
+ * One reception. Extra bridge fields are accepted and ignored.
+ */
+export type MeshPacket = {
+    /**
+     * Reception RSSI in dBm (number or numeric string).
+     */
+    RSSI?: unknown;
+    /**
+     * Reception SNR in dB (number or numeric string).
+     */
+    SNR?: unknown;
+    /**
+     * Receiving radio's public key, if different from `observer`.
+     */
+    origin_id?: string;
+    /**
+     * MeshCore payload type; only 4 (ADVERT) updates a node.
+     */
+    packet_type: number;
+    /**
+     * The full over-the-air frame as hex (header, path, payload), or a meshcore://<hex> link.
+     */
+    raw: string;
+    /**
+     * Ignored; the server stamps its own receive time.
+     */
+    timestamp?: string;
+};
+/**
+ * `mesh.packet` (schema_version 1): raw MeshCore frames a companion radio
+ * heard, in the per-packet envelope the MQTT bridges publish. ADVERTs
+ * (packet_type 4) update a node after its Ed25519 signature verifies;
+ * other flood-routed packets credit relays. Answers 400 when MeshCore
+ * ingest is off on the server.
+ *
+ */
+export type MeshPacketReport = {
+    generated_at?: string;
+    /**
+     * Public key (or 4+ byte prefix) of the receiving radio. Defaults to the reporter id.
+     */
+    observer?: string;
+    packets: Array<MeshPacket>;
+    schema_version: 1;
+};
+export type MeshRepeaterReading = {
+    airtime_ms?: number | null;
+    battery_percent?: number | null;
+    battery_percent_source?: string;
+    battery_voltage?: number | null;
+    direct_dups?: number | null;
+    flood_dups?: number | null;
+    full_evts?: number | null;
+    humidity?: number | null;
+    /**
+     * Node public key or a prefix of it (8-64 hex). A bad id is a warning; the rest of the report still lands.
+     */
+    id: string;
+    /**
+     * Unix seconds of the monitor's last attempt on this node.
+     */
+    last_attempt?: number | null;
+    last_rssi_dbm?: number | null;
+    last_snr_db?: number | null;
+    /**
+     * Unix seconds of the last successful read; null if never. Reachability is derived from its age.
+     */
+    last_success?: number | null;
+    name?: string;
+    nb_recv?: number | null;
+    nb_sent?: number | null;
+    noise_floor_dbm?: number | null;
+    /**
+     * Accepted and logged, but not used; reachability comes from last_success.
+     */
+    online?: boolean | null;
+    pressure?: number | null;
+    recv_direct?: number | null;
+    recv_errors?: number | null;
+    recv_flood?: number | null;
+    rx_airtime_ms?: number | null;
+    sent_direct?: number | null;
+    sent_flood?: number | null;
+    temperature_c?: number | null;
+    tx_queue_len?: number | null;
+    uptime_s?: number | null;
+};
+/**
+ * `mesh.repeater` (schema_version 1): an operator monitor's COMPLETE
+ * current set of MeshCore repeaters it logged into. A report replaces the
+ * reporter's previous set; a node left out is no longer monitored. Request
+ * bodies are snake_case. Unknown fields are ignored. Unread values are
+ * `null`, never `0`.
+ *
+ */
+export type MeshRepeaterReport = {
+    /**
+     * When the report was built. Clamped to the server's clock.
+     */
+    generated_at?: string;
+    repeaters: Array<MeshRepeaterReading>;
+    schema_version: 1;
+};
+export type ProtobufAny = {
+    '@type'?: string;
+    [key: string]: unknown;
+};
+/**
+ * The error body of every JSON route: the RPCs (gRPC-Gateway rendering of
+ * google.rpc.Status) and the hand-built GeoJSON, mesh-links and ingest
+ * routes alike. Served with the HTTP status mapped from `code`
+ * (3 INVALID_ARGUMENT -> 400, 5 NOT_FOUND -> 404, 13 INTERNAL -> 500,
+ * 14 UNAVAILABLE -> 503, ...). All four members are always present.
+ *
+ */
+export type RpcStatus = {
+    /**
+     * Numeric gRPC status code (5 = NOT_FOUND).
+     */
+    code?: number;
+    /**
+     * Canonical gRPC code name for `code`, e.g. `NOT_FOUND`,
+     * `INVALID_ARGUMENT`, `INTERNAL`. Branch on this rather than the
+     * message.
+     *
+     */
+    codeName?: 'OK' | 'CANCELLED' | 'UNKNOWN' | 'INVALID_ARGUMENT' | 'DEADLINE_EXCEEDED' | 'NOT_FOUND' | 'ALREADY_EXISTS' | 'PERMISSION_DENIED' | 'RESOURCE_EXHAUSTED' | 'FAILED_PRECONDITION' | 'ABORTED' | 'OUT_OF_RANGE' | 'UNIMPLEMENTED' | 'INTERNAL' | 'UNAVAILABLE' | 'DATA_LOSS' | 'UNAUTHENTICATED';
+    /**
+     * Structured error details. Usually empty.
+     */
+    details?: Array<ProtobufAny>;
+    /**
+     * Human-readable explanation. Not stable; do not parse.
+     */
+    message?: string;
+};
+/**
+ * BoundingBox is a WGS 84 bounding box in decimal degrees.
+ */
+export type V1BoundingBox = {
+    /**
+     * Northern edge, degrees latitude.
+     */
+    maxLat: number;
+    /**
+     * Eastern edge, degrees longitude.
+     */
+    maxLng: number;
+    /**
+     * Southern edge, degrees latitude.
+     */
+    minLat: number;
+    /**
+     * Western edge, degrees longitude (negative in California).
+     */
+    minLng: number;
+};
+/**
+ * BurnDay is the county air district's call for today.
+ *
+ * - BURN_DAY_UNKNOWN: Not read, unreadable, or older than 36 hours. Never treat as permissive.
+ * - BURN_DAY_YES: Permissive burn day: burning allowed (subject to CAL FIRE's status).
+ * - BURN_DAY_NO: No-burn day: burning prohibited.
+ * - BURN_DAY_MARGINAL: Restricted or partial day (for example elevation limits). Treated as a
+ * restriction, not a yes.
+ */
+export type V1BurnDay = 'BURN_DAY_UNKNOWN' | 'BURN_DAY_YES' | 'BURN_DAY_NO' | 'BURN_DAY_MARGINAL';
+/**
+ * BurnLineReading is one recorded phone line's answer for today.
+ */
+export type V1BurnLineReading = {
+    /**
+     * This line's own answer. BURN_DAY_UNKNOWN if not read or stale. A change
+     * writes a revision.
+     */
+    burnDay: V1BurnDay;
+    /**
+     * Stable line id.
+     */
+    id: string;
+    /**
+     * Display name of the line.
+     */
+    name: string;
+    /**
+     * The latest call: message, transcript, confidence and time. `null` when the
+     * line has never been read. Changes daily without writing a revision.
+     *
+     */
+    observation: V1BurnObservation | null;
+    /**
+     * The number a resident can call, E.164.
+     */
+    phone: string;
+};
+/**
+ * BurnObservation is the latest reading of one burn line. The line's message
+ * names the date, so it changes every day even when the answer does not; that
+ * is why it writes no revision.
+ *
+ */
+export type V1BurnObservation = {
+    /**
+     * The model's confidence in the reading, 0-100. Shown rather than
+     * thresholded: this is an AI reading of phone audio, so show it when it is low.
+     */
+    confidence: number;
+    /**
+     * The line's answer in plain language, extracted by a model from the
+     * transcript.
+     */
+    message: string;
+    /**
+     * When the line was called.
+     */
+    observedAt: string;
+    /**
+     * Cleaned machine transcript of the recording.
+     */
+    transcript: string;
+};
+/**
+ * BurnPermission is the combined answer, deliberately pessimistic.
+ *
+ * - BURN_PERMISSION_UNKNOWN: At least one facet is unknown or stale and none prohibits: assume nothing.
+ * - BURN_PERMISSION_ALLOWED: Both facets are known and permit burning today.
+ * - BURN_PERMISSION_PROHIBITED: At least one facet prohibits burning today.
+ */
+export type V1BurnPermission = 'BURN_PERMISSION_UNKNOWN' | 'BURN_PERMISSION_ALLOWED' | 'BURN_PERMISSION_PROHIBITED';
+/**
+ * BurnStatusDetail is the BURN_STATUS detail block: whether residential/outdoor
+ * burning is allowed today in one county.
+ *
+ * Two independent authorities must BOTH permit a burn, and each is a separate
+ * facet because they fail independently: `burnDay`, the county air district's
+ * daily permissive-burn-day call (read from its recorded phone line), and
+ * `calfireStatus`, CAL FIRE's seasonal suspension of burn permits on State
+ * Responsibility Area land (changes about twice a year). `permission` combines
+ * them pessimistically.
+ *
+ * The event exists for each tracked county at all times, is always INFO and
+ * ACTIVE, and is left out of the summary's hazard rollup (it has its own `burn`
+ * domain). `GET /api/v1/events/burn:{county slug}/history` shows when it changed.
+ */
+export type V1BurnStatusDetail = {
+    /**
+     * The county line's answer for today, merged across `burnLines` taking the
+     * most restrictive (any NO wins, then any MARGINAL; YES needs every dialed
+     * line to answer). BURN_DAY_UNKNOWN when unread or the reading is older than
+     * 36 hours.
+     */
+    burnDay: V1BurnDay;
+    /**
+     * --- county facet (source `burnline`) ---
+     * Every recorded phone line that speaks for this county, each with its own
+     * reading. One line can serve several counties, and a county can have several
+     * lines. A line we could not read still appears, with `burnDay`
+     * BURN_DAY_UNKNOWN and its phone number, so a reader can call it.
+     */
+    burnLines: Array<V1BurnLineReading>;
+    /**
+     * Land classes CAL FIRE's status covers.
+     */
+    calfireArea: string;
+    /**
+     * --- CAL FIRE facet (source `calfire-burn`) ---
+     * When CAL FIRE's current status took effect (the county line only ever says
+     * "until further notice"). `null` when CAL FIRE gives no date.
+     */
+    calfireEffective: string | null;
+    /**
+     * When CAL FIRE's page was last read successfully. The only way to tell that
+     * `calfireStatus` is being carried forward rather than freshly confirmed. Can
+     * be `null`.
+     *
+     */
+    calfireObservedAt: string | null;
+    /**
+     * CAL FIRE's permit status for the county's SRA land. Carried forward from the
+     * last good read while CAL FIRE's page is unreachable; check
+     * `calfireObservedAt`.
+     */
+    calfireStatus: V1CalfireBurnStatus;
+    /**
+     * The answer to "may I burn today?": PROHIBITED if either facet prohibits
+     * burning (no-burn day, marginal day, or CAL FIRE suspension); ALLOWED only
+     * when both facets are known and permissive; otherwise UNKNOWN. A missing
+     * answer never reads as ALLOWED.
+     */
+    permission: V1BurnPermission;
+};
+/**
+ * CalfireBurnStatus is CAL FIRE's permit status for State Responsibility Area
+ * land in the county.
+ *
+ * - CALFIRE_BURN_STATUS_UNKNOWN: Unknown: CAL FIRE's page has not been read.
+ * - CALFIRE_BURNING_SUSPENDED: Permits suspended: no residential burning.
+ * - CALFIRE_PERMIT_REQUIRED: Burning allowed with a valid CAL FIRE permit.
+ * - CALFIRE_NO_PERMIT_REQUIRED: Off-season: no permit needed.
+ */
+export type V1CalfireBurnStatus = 'CALFIRE_BURN_STATUS_UNKNOWN' | 'CALFIRE_BURNING_SUSPENDED' | 'CALFIRE_PERMIT_REQUIRED' | 'CALFIRE_NO_PERMIT_REQUIRED';
+/**
+ * Camera is one Caltrans CCTV camera. Every listed camera is in service and has
+ * an image; an out-of-service camera is dropped, not flagged.
+ */
+export type V1Camera = {
+    /**
+     * County, per Caltrans.
+     */
+    county: string;
+    /**
+     * Caltrans's note on the view, e.g. "Looking South". Usually an empty string.
+     */
+    description: string;
+    /**
+     * Direction the camera faces along the route. Empty string when not given.
+     */
+    direction: '' | 'North' | 'South' | 'East' | 'West';
+    /**
+     * Metres from the requested place, or, without `place`, from the nearest
+     * coverage area. 0 means inside it.
+     */
+    distanceMeters: number;
+    /**
+     * Elevation in feet.
+     */
+    elevationFeet: number;
+    /**
+     * Camera id, `d{district}-{index}`.
+     */
+    id: string;
+    /**
+     * How often Caltrans replaces the snapshot, in minutes. 0 when not reported.
+     */
+    imageRefreshMinutes: number;
+    /**
+     * Current snapshot JPEG, hosted by Caltrans (cwwp2.dot.ca.gov).
+     */
+    imageUrl: string;
+    /**
+     * Camera position.
+     */
+    location: V1LatLng;
+    /**
+     * Caltrans's camera name.
+     */
+    name: string;
+    /**
+     * Nearest community, per Caltrans.
+     */
+    nearbyPlace: string;
+    /**
+     * Route, e.g. "SR-108", "US-395".
+     */
+    route: string;
+    /**
+     * HLS playlist (.m3u8) for live video. Empty string for an image-only camera.
+     */
+    streamUrl: string;
+};
+/**
+ * CameraList is the camera directory.
+ */
+export type V1CameraList = {
+    /**
+     * Attribution to display.
+     */
+    attribution: string;
+    /**
+     * Cameras, nearest first, then by id. Empty when none is nearby.
+     */
+    cameras: Array<V1Camera>;
+    /**
+     * When the served list was fetched. `null` when `sourceStatus` is OK.
+     */
+    lastSourceUpdate: string | null;
+    /**
+     * Health of the camera list. STALE: served from an older fetch, or a
+     * configured district is missing. UNAVAILABLE: no list fetched yet, or no
+     * camera districts configured.
+     */
+    sourceStatus: 'OK' | 'STALE' | 'UNAVAILABLE';
+};
+/**
+ * Conditions is current, non-event state.
+ */
+export type V1Conditions = {
+    /**
+     * The region's fire-weather state. Region-wide, whatever `place` was asked.
+     * Can be `null` when the weather service has no fire-weather reading.
+     */
+    fireWeather: V1FireWeatherConditions | null;
+    /**
+     * Per-location forecasts, joined to `weather` by `locationId`. A location
+     * whose forecast could not be fetched is simply missing here.
+     */
+    forecast: Array<V1WeatherForecast>;
+    /**
+     * When the weather data was last refreshed.
+     */
+    lastUpdated: string | null;
+    /**
+     * Current weather per location.
+     */
+    weather: Array<V1WeatherConditions>;
+};
+/**
+ * EarthquakeDetail is the EARTHQUAKE detail block. The USGS event page is the
+ * envelope `canonicalUrl`.
+ */
+export type V1EarthquakeDetail = {
+    /**
+     * Hypocentre depth in kilometres.
+     */
+    depthKm: number;
+    /**
+     * Number of USGS "Did You Feel It?" reports. 0 when none.
+     */
+    felt: number;
+    /**
+     * Magnitude.
+     */
+    magnitude: number;
+};
+/**
+ * Enhancement marks AI-generated text so a client can badge it. The model
+ * translates and summarizes the upstream text; it never asserts new facts, and
+ * the original stays in `description`.
+ */
+export type V1Enhancement = {
+    /**
+     * When the text was generated.
+     */
+    enhancedAt: string | null;
+    /**
+     * Which Event fields the model wrote, by JSON name: any of `headline`,
+     * `summary`, `severity`.
+     */
+    fields: Array<string>;
+    /**
+     * Model that produced the text, e.g. "gpt-5-mini".
+     */
+    model: string;
+    /**
+     * The incident-specific prompt sent to the model (the static system prompt is
+     * not included). Empty string unless the request set `enhancementIo=true`.
+     *
+     */
+    request: string;
+    /**
+     * The raw structured JSON the model returned. Empty string unless the request
+     * set `enhancementIo=true`.
+     */
+    response: string;
+};
+/**
+ * EvacuationDetail is the EVACUATION detail block, one Cal OES / Genasys zone.
+ */
+export type V1EvacuationDetail = {
+    /**
+     * County as Cal OES spells it (uppercase).
+     */
+    county: string;
+    /**
+     * Upstream event type, often an empty string.
+     */
+    eventType: string;
+    /**
+     * Coded level. An unrecognized upstream status is coded WARNING, never
+     * dropped. ORDER and WARNING and SHELTER_IN_PLACE put the place summary in
+     * ACTIVE mode; ADVISORY puts it in WATCH.
+     */
+    level: 'ORDER' | 'WARNING' | 'ADVISORY' | 'SHELTER_IN_PLACE';
+    /**
+     * Genasys zone id. `provenance.sourceUrl` links the zone's Genasys page.
+     */
+    zoneId: string;
+};
+/**
+ * Event is one item from one upstream source: a hazard, or a piece of ambient
+ * state such as a mesh node or a county's burn status.
+ *
+ * The envelope fields are the same for every layer, so a client can render a
+ * card from `headline`, `severity`, `status` and `provenance` without knowing the
+ * layer. Layer-specific fields are in exactly one detail block (`wildfire`,
+ * `evacuation`, `weatherAlert`, `earthquake`, `roadIncident`, `mesh`, `power` or
+ * `burnStatus`), chosen by `layer`; the other blocks are absent. `fireWeather`
+ * is never populated on an event.
+ */
+export type V1Event = {
+    /**
+     * Human-readable location ("SR 4 at Country Club Drive", "Calaveras County").
+     * Empty string when the source gives none.
+     */
+    areaLabel: string;
+    /**
+     * BURN_STATUS detail (one county's residential burning status).
+     */
+    burnStatus?: V1BurnStatusDetail;
+    /**
+     * Link to the authoritative page for THIS item: a USGS event page, a CAL FIRE
+     * incident page, a mesh node's CoreScope page, PG&E's outage or PSPS page, the
+     * CAL FIRE burn-permit page for burn status. Always http(s) when set. Empty
+     * string when the source has no per-item page, which today means CHP
+     * incidents, Caltrans lane closures, FIRIS perimeters, NWS alerts and
+     * evacuation zones. Fall back to `provenance.sourceUrl`, then to the source's
+     * `homepageUrl` (`GET /api/v1/sources`, joined on `provenance.sourceId`).
+     */
+    canonicalUrl: string;
+    /**
+     * Source sub-type, lowercase except for weather alerts. By layer: WILDFIRE
+     * `wildfire`; EVACUATION `order` | `warning` | `advisory` | `shelter_in_place`;
+     * WEATHER_ALERT the NWS event name verbatim (`Red Flag Warning`, `Winter Storm
+     * Watch`, ...); EARTHQUAKE `earthquake`; ROAD_INCIDENT `incident` | `closure` |
+     * `construction` | `weather` (CHP types) or `closure` (Caltrans windows);
+     * POWER `unplanned` | `planned` | `psps`; MESH the node type (`repeater`,
+     * `companion`, `room_server`, `sensor`); BURN_STATUS `burn_status`.
+     */
+    category: string;
+    /**
+     * Long-form original text from the upstream (CHP log, NWS product body,
+     * evacuation instructions, closure description). May contain newlines. Empty
+     * string when the source has none, or when it would only repeat the headline.
+     */
+    description: string;
+    /**
+     * EARTHQUAKE detail.
+     */
+    earthquake?: V1EarthquakeDetail;
+    /**
+     * When the event took or takes effect: alert onset, incident start, outage
+     * start, closure set-up time. `null` when the source does not say.
+     */
+    effective: string | null;
+    /**
+     * Present when an AI model generated some of this event's text; lists which
+     * fields. `null` for events with no AI involvement.
+     */
+    enhancement: V1Enhancement | null;
+    /**
+     * EVACUATION detail.
+     */
+    evacuation?: V1EvacuationDetail;
+    /**
+     * The upstream's declared end, such as an NWS alert's expiry. `null` for most
+     * layers. Restoration estimates and planned closure ends are never put here
+     * (they are routinely overrun); they live in the detail blocks.
+     */
+    expires: string | null;
+    /**
+     * Never populated on an event: fire weather is a condition
+     * (`GET /api/v1/conditions`, the `fire_weather` map layer).
+     */
+    fireWeather?: V1FireWeatherDetail;
+    /**
+     * Where the event is. `null` for events with no footprint of their own: NWS
+     * zone alerts (they attach to places by zone instead) and burn status (a fact
+     * about a county).
+     */
+    geometry: V1Geometry | null;
+    /**
+     * One-line, card-ready title. Present on every event. For CHP incidents it
+     * may be AI-written (see `enhancement.fields`); for NWS alerts it is composed
+     * from the product, never by AI.
+     */
+    headline: string;
+    /**
+     * Stable event id, `{source}:{native id}`. It never changes over the event's
+     * life, so it is safe as a client key. Namespaces: `calfire:`, `firis:`
+     * (wildfire), `evac:` (evacuation zone), `wx:` (NWS alert), `usgs:`
+     * (earthquake), `chp:` (CHP incident), `caltrans:` (Caltrans lane-closure
+     * window), `pge:` (outage), `psps:` (power shutoff), `meshcore:` (mesh node),
+     * `burn:` (county burn status). Ids can contain colons; URL-encode them in a
+     * path.
+     */
+    id: string;
+    /**
+     * When the Grid stored this revision.
+     */
+    ingestedAt: string;
+    /**
+     * Which layer this event belongs to. It decides which detail block is
+     * populated.
+     */
+    layer: V1Layer;
+    /**
+     * MESH detail (one MeshCore radio node).
+     */
+    mesh?: V1MeshDetail;
+    /**
+     * When the upstream last changed this event's content. It moves only when a
+     * new revision is written, so it is NOT "last seen". For a mesh node's
+     * liveness use `mesh.telemetry.lastHeardAt` / `lastRelayedAt`; for burn
+     * status it follows each new phone-line reading.
+     */
+    observedAt: string | null;
+    /**
+     * Ids of every place this event attaches to, e.g. `["county:calaveras-county",
+     * "town:arnold"]`. Point events attach to the polygon places that contain them
+     * and to corridors within about 1.5 km. Polygon events attach to places they
+     * overlap. Wildfires also attach to AREA and TOWN places within 20 km. Empty
+     * when the event is outside every place (common for mesh nodes).
+     */
+    placeIds: Array<string>;
+    /**
+     * POWER detail (PG&E outage or Public Safety Power Shutoff).
+     */
+    power?: V1PowerDetail;
+    /**
+     * Which source published it, with attribution text to display.
+     */
+    provenance: V1Provenance;
+    /**
+     * Revision number, starting at 1. It increases by one on every content change
+     * or status transition. `/api/v1/events/{id}/history` lists every revision.
+     */
+    revision: number;
+    /**
+     * ROAD_INCIDENT detail (CHP incidents and Caltrans lane closures).
+     */
+    roadIncident?: V1RoadIncidentDetail;
+    /**
+     * Unified severity, INFO..EXTREME. Response urgency, not magnitude. See the
+     * Severity enum for how each layer is graded. `enhancement.fields` lists
+     * `severity` when an AI model assessed it (CHP incidents).
+     */
+    severity: V1Severity;
+    /**
+     * Lifecycle status. `/api/v1/events` returns ACTIVE and SCHEDULED unless you
+     * ask for others.
+     */
+    status: V1EventStatus;
+    /**
+     * AI-written plain-language summary of two or three sentences, for CHP
+     * incidents and NWS alerts. Empty string when none was generated. The original
+     * text is always kept in `description`.
+     */
+    summary: string;
+    /**
+     * WEATHER_ALERT detail.
+     */
+    weatherAlert?: V1WeatherAlertDetail;
+    /**
+     * WILDFIRE detail.
+     */
+    wildfire?: V1WildfireDetail;
+};
+/**
+ * EventList is one page of events.
+ */
+export type V1EventList = {
+    /**
+     * Events on this page, ordered by severity (highest first), then
+     * `observedAt` (newest first), then id.
+     */
+    events: Array<V1Event>;
+    /**
+     * Token for the next page; pass it as `pageToken` with the same filters.
+     * Empty string on the last page.
+     */
+    nextPageToken: string;
+};
+/**
+ * EventRevision is one stored snapshot of an event.
+ */
+export type V1EventRevision = {
+    /**
+     * The full event as it was at this revision. Mesh activity clocks
+     * (`lastHeardAt`, `lastRelayedAt`) are not filled on history snapshots.
+     */
+    event: V1Event;
+    /**
+     * When the Grid stored this revision.
+     */
+    ingestedAt: string;
+    /**
+     * The upstream content time of this revision (`event.observedAt`).
+     */
+    observedAt: string;
+    /**
+     * Revision number, from 1.
+     */
+    revision: number;
+};
+/**
+ * EventRevisionList is one page of revisions.
+ */
+export type V1EventRevisionList = {
+    /**
+     * Token for the next page; pass it as `pageToken` with the same filters.
+     * Empty string on the last page.
+     */
+    nextPageToken: string;
+    /**
+     * Revisions on this page. Per-event history: newest revision first. The
+     * archive (`/api/v1/history`): `observedAt` newest first, then event id, then
+     * revision newest first.
+     */
+    revisions: Array<V1EventRevision>;
+};
+/**
+ * EventStatus is an event's lifecycle state. Every transition is a revision, so
+ * the history keeps when an event started and ended.
+ *
+ * - EVENT_STATUS_UNSPECIFIED: Never returned.
+ * - SCHEDULED: Planned or forecast and not yet in effect, e.g. a Caltrans lane-closure
+ * window the crew has not set up yet.
+ * - ACTIVE: In effect now.
+ * - RESOLVED: Over: an authoritatively active-only feed (CAL FIRE, Cal OES, CHP, Caltrans,
+ * PG&E) stopped listing it after a successful poll, or a closure passed its
+ * planned end plus an overrun grace without a pickup call.
+ * - EXPIRED: Aged out: past its own `expires`, or unseen for longer than the source's
+ * grace (`Source.expireAfterSeconds`). Used where a feed going quiet proves
+ * nothing (NWS alerts, FIRIS perimeters, mesh nodes).
+ */
+export type V1EventStatus = 'EVENT_STATUS_UNSPECIFIED' | 'SCHEDULED' | 'ACTIVE' | 'RESOLVED' | 'EXPIRED';
+/**
+ * FireWeatherConditions is the region's fire-weather state, from issued NWS
+ * products only. It never claims a Red Flag Warning that NWS has not issued.
+ */
+export type V1FireWeatherConditions = {
+    /**
+     * The NWS product's headline. Empty string when the state is normal.
+     */
+    headline: string;
+    /**
+     * LOWERCASE state: `normal`, `elevated` (a Fire Weather Watch is in effect)
+     * or `red-flag` (a Red Flag Warning is in effect). Empty string when the
+     * state could not be determined.
+     */
+    state: 'normal' | 'elevated' | 'red-flag' | '';
+    /**
+     * NWS fire-weather zones under the product. Empty when normal.
+     */
+    zones: Array<string>;
+};
+/**
+ * FireWeatherDetail is never populated on an event. Fire weather is a condition,
+ * served by `GET /api/v1/conditions` (`fireWeather`) and the `fire_weather` map
+ * layer.
+ *
+ */
+export type V1FireWeatherDetail = {
+    /**
+     * NWS product driving the state.
+     */
+    sourceEvent: string;
+    /**
+     * `normal`, `elevated` (Fire Weather Watch) or `red-flag` (Red Flag Warning).
+     * Lowercase.
+     */
+    state: 'normal' | 'elevated' | 'red-flag';
+    /**
+     * NWS fire-weather zones it covers.
+     */
+    zones: Array<string>;
+};
+/**
+ * ForecastPeriod is one hour of a location's forecast (NWS gridpoint data),
+ * rounded to whole numbers. A value NWS did not give is 0.
+ */
+export type V1ForecastPeriod = {
+    /**
+     * Relative humidity, percent.
+     */
+    humidityPercent: number;
+    /**
+     * Temperature, degrees Celsius.
+     */
+    temperatureCelsius: number;
+    /**
+     * Start of the hour, UTC.
+     */
+    time: string | null;
+    /**
+     * Direction the wind blows FROM, degrees clockwise from north.
+     */
+    windDirectionDegrees: number;
+    /**
+     * Wind gust, km/h.
+     */
+    windGustKmh: number;
+    /**
+     * Sustained wind speed, km/h.
+     */
+    windSpeedKmh: number;
+};
+/**
+ * Geometry is an event's or place's footprint.
+ *
+ * The GeoJSON comes in one of two forms, chosen per request with
+ * `geometryFormat`: `BASE64` (the default and legacy form) fills `geojson`;
+ * `OBJECT` fills `object` and leaves `geojson` empty. `bbox` and `centroid`
+ * are the same in both.
+ */
+export type V1Geometry = {
+    /**
+     * Bounding box of the geometry, in decimal degrees. Always set when geometry
+     * is present.
+     */
+    bbox: V1BoundingBox;
+    /**
+     * Representative point for markers and list views: the point itself for a
+     * Point, otherwise the middle of the bounding box (which can fall outside an
+     * irregular polygon).
+     */
+    centroid: V1LatLng;
+    /**
+     * LEGACY FORM (the default, `geometryFormat=BASE64`). The RFC 7946 GeoJSON
+     * geometry object (Point, LineString, Polygon, MultiPolygon, ...) as UTF-8
+     * JSON, BASE64-ENCODED in this JSON response because the field is protobuf
+     * `bytes`. Decode with `JSON.parse(atob(geojson))`. Coordinates are
+     * `[longitude, latitude]`. Empty in the `OBJECT` form. Kept unchanged for existing clients; new clients should
+     * request `geometryFormat=OBJECT` and read `object` instead. Perimeters,
+     * evacuation zones and outage areas run from kilobytes to about a megabyte.
+     */
+    geojson: string;
+    /**
+     * The same RFC 7946 geometry as a plain JSON object, e.g.
+     * `{"type": "Point", "coordinates": [-120.36108, 38.24239]}`, ready for
+     * MapLibre, Leaflet or turf with no decoding. Sent only when the request
+     * asks for `geometryFormat=OBJECT`, and then only when the event has
+     * GeoJSON; otherwise the key is absent (never `null`).
+     */
+    object?: GeoJsonGeometry;
+};
+/**
+ * LaneClosureDetail is one Caltrans planned lane-closure WINDOW from the CWWP2
+ * data portal. Every field is Caltrans data; none of it is AI-generated.
+ *
+ * A multi-day job is one window (one event) per day, and neither `closureId`
+ * nor `logNumber` identifies a job; `windowId` is the only unique key. A window
+ * is SCHEDULED until the crew radios it set up (`setUpAt`), then ACTIVE until
+ * they radio it picked up, or until `plannedEnd` plus a 12-hour overrun grace
+ * passes with no pickup call, when it is presumed over and RESOLVED. The
+ * planned end is an estimate crews overrun, so it is never mapped onto the
+ * envelope `expires`.
+ */
+export type V1LaneClosureDetail = {
+    /**
+     * Start point.
+     */
+    begin: V1LatLng | null;
+    /**
+     * Where the closure starts, verbatim, e.g. "Avery".
+     */
+    beginLocation: string;
+    /**
+     * How the closure runs.
+     */
+    closureDuration: 'Standard' | 'Long Term' | 'Intermittent';
+    /**
+     * Route-level project id. Not unique.
+     */
+    closureId: string;
+    /**
+     * Closure type, verbatim: "Full", "Lane", "One-Way Traffic", "Alternating
+     * Lanes", "Moving", ...
+     */
+    closureType: string;
+    /**
+     * Travel direction, verbatim, e.g. "East / West", "North".
+     */
+    direction: string;
+    /**
+     * Caltrans district whose feed listed it (3 or 10 here).
+     */
+    district: number;
+    /**
+     * End point.
+     */
+    end: V1LatLng | null;
+    /**
+     * True when the window has no planned end.
+     */
+    endIndefinite: boolean;
+    /**
+     * Where it ends; equals `beginLocation` for a closure at one spot.
+     */
+    endLocation: string;
+    /**
+     * Caltrans's delay estimate in minutes. 0 when none or not reported.
+     */
+    estimatedDelayMinutes: number;
+    /**
+     * Facility, verbatim: "Conventional Hwy", "On Ramp", "Off Ramp", ...
+     */
+    facility: string;
+    /**
+     * Lanes closed, verbatim: "1, RShoulder", "All", "Rt Turn Ln".
+     */
+    lanesClosed: string;
+    /**
+     * Per-project request number. Not unique.
+     */
+    logNumber: string;
+    /**
+     * Planned end of the window. `null` when `endIndefinite`.
+     */
+    plannedEnd: string | null;
+    /**
+     * Planned start of the window.
+     */
+    plannedStart: string;
+    /**
+     * Route, e.g. "SR-4", "US-50".
+     */
+    route: string;
+    /**
+     * When the crew radioed the closure set up (the 10-97 call). `null` while it
+     * is SCHEDULED.
+     */
+    setUpAt: string | null;
+    /**
+     * Number of lanes at the site. 0 when not reported.
+     */
+    totalLanes: number;
+    /**
+     * CWWP2 window id, unique per window.
+     */
+    windowId: string;
+    /**
+     * Work being done, e.g. "Drainage Work", "Tree Work".
+     */
+    workType: string;
+};
+/**
+ * LatLng is one WGS 84 point in decimal degrees. Note the order: unlike GeoJSON
+ * coordinates, this is latitude first.
+ */
+export type V1LatLng = {
+    /**
+     * Degrees latitude.
+     */
+    lat: number;
+    /**
+     * Degrees longitude (negative in California).
+     */
+    lng: number;
+};
+/**
+ * Layer is the event taxonomy. Response values are these UPPERCASE names; the
+ * `layer` query parameter also accepts lowercase slugs (`road_incident`).
+ *
+ * Only event layers appear here. The condition layers (`road_segment`,
+ * `chain_control`, `fire_weather`, `message_sign`) are map layers and summary
+ * inputs, never events.
+ *
+ * - LAYER_UNSPECIFIED: Never returned.
+ * - WILDFIRE: Wildfires: CAL FIRE incidents joined with FIRIS/NIFC perimeters (sources
+ * `calfire`, `firis`). Scoped wider than other layers, so a fire approaching
+ * the region shows up before it arrives.
+ * - EVACUATION: Evacuation zones under an order, warning, advisory or shelter-in-place,
+ * from Cal OES / Genasys (source `caloes`). Life-safety: see the summary's
+ * `activeEvacuations`.
+ * - WEATHER_ALERT: National Weather Service watches, warnings and advisories for the region's
+ * forecast zones (source `nws`). No geometry; attached to places by zone.
+ * - FIRE_WEATHER: Reserved. Fire weather is a condition (`GET /api/v1/conditions`), not an
+ * event layer; no event carries it.
+ * - EARTHQUAKE: USGS earthquakes of magnitude 2.5 or more in the last 7 days (source `usgs`).
+ * - ROAD_INCIDENT: CHP traffic incidents (source `chp`, AI-summarized) and Caltrans planned
+ * lane-closure windows (source `caltrans`). Planned windows not yet set up are
+ * SCHEDULED.
+ * - POWER:
+ * PG&E electric outages (source `pge`) and Public Safety Power Shutoffs
+ * (source `psps`). Most outages affect one customer and are INFO.
+ * - GAUGE: Reserved for stream gauges; no events today.
+ * - AIR_QUALITY: Reserved for air quality; no events today.
+ * - MESH: MeshCore community radio nodes (source `meshcore`), one event per node.
+ * Ambient INFO state, not a hazard. It dominates an unscoped event query.
+ * - ANNOUNCEMENT: Reserved for announcements; no events today.
+ * - BURN_STATUS: One event per tracked county saying whether residential burning is allowed
+ * today (sources `burnline`, `calfire-burn`). Ambient, permanently ACTIVE,
+ * always INFO; its revision history is the record of changes.
+ */
+export type V1Layer = 'LAYER_UNSPECIFIED' | 'WILDFIRE' | 'EVACUATION' | 'WEATHER_ALERT' | 'FIRE_WEATHER' | 'EARTHQUAKE' | 'ROAD_INCIDENT' | 'POWER' | 'GAUGE' | 'AIR_QUALITY' | 'MESH' | 'ANNOUNCEMENT' | 'BURN_STATUS';
+/**
+ * MeshAdminTelemetry is one reading taken from a node's own admin interface by an
+ * operator-run monitor. It is the node's self-reported view, which is why it
+ * sits beside rather than replaces the gateway-reported `snr`/`rssi`: those are
+ * what a distant listener heard, these are what the node measured.
+ *
+ * Gauges are nullable: `null` means the monitor could not read it, which is not
+ * the same as 0 (a 0% battery and an unknown battery must not render alike).
+ * Counters are plain, count since the node's last boot (they reset at a
+ * reboot), and are 64-bit, so they arrive as JSON STRINGS.
+ */
+export type V1MeshAdminTelemetry = {
+    /**
+     * Milliseconds spent transmitting since boot.
+     */
+    airtimeMs: string;
+    /**
+     * Battery charge in percent, 0-100. Nullable. See `batteryPercentSource`.
+     */
+    batteryPercent: number | null;
+    /**
+     * Whether `batteryPercent` was measured by the node or estimated from
+     * voltage. Empty string when no percentage is reported.
+     */
+    batteryPercentSource: '' | 'measured' | 'estimated';
+    /**
+     * Battery voltage in volts. Nullable.
+     */
+    batteryVolts: number | null;
+    /**
+     * Duplicate direct-routed packets dropped since boot.
+     */
+    directDups: string;
+    /**
+     * Duplicate flood-routed packets dropped since boot.
+     */
+    floodDups: string;
+    /**
+     * Transmit-queue overflow events since boot.
+     */
+    fullEvents: string;
+    /**
+     * Relative humidity in percent. Nullable (most nodes have no sensor).
+     */
+    humidity: number | null;
+    /**
+     * The monitor's last attempt to read this node, successful or not. Can be
+     * `null` (always `null` on archived samples).
+     */
+    lastAttemptAt: string | null;
+    /**
+     * RSSI of the last packet the node itself received, in dBm. Nullable.
+     */
+    lastRssiDbm: number | null;
+    /**
+     * SNR of the last packet the node itself received, in dB. Nullable.
+     */
+    lastSnrDb: number | null;
+    /**
+     * The monitor's last successful read of this node. Can be `null` (always
+     * `null` on archived samples).
+     */
+    lastSuccessAt: string | null;
+    /**
+     * Radio noise floor in dBm. Nullable.
+     */
+    noiseFloorDbm: number | null;
+    /**
+     * Packets received since boot.
+     */
+    packetsReceived: string;
+    /**
+     * Packets sent since boot.
+     */
+    packetsSent: string;
+    /**
+     * Barometric pressure in hPa. Nullable (most nodes have no sensor).
+     */
+    pressure: number | null;
+    /**
+     * Direct-routed packets received since boot.
+     */
+    recvDirect: string;
+    /**
+     * Receive errors (undecodable packets) since boot.
+     */
+    recvErrors: string;
+    /**
+     * Flood-routed packets received since boot.
+     */
+    recvFlood: string;
+    /**
+     * When the monitor produced the report. In the archive this is the sample's
+     * own time.
+     */
+    reportedAt: string | null;
+    /**
+     * Which monitor reported it (its registry id, also a row on `/api/v1/sources`).
+     */
+    reporterId: string;
+    /**
+     * Milliseconds spent receiving since boot.
+     */
+    rxAirtimeMs: string;
+    /**
+     * Direct-routed packets sent since boot.
+     */
+    sentDirect: string;
+    /**
+     * Flood-routed packets sent since boot.
+     */
+    sentFlood: string;
+    /**
+     * Temperature in degrees Celsius. Nullable.
+     */
+    temperatureC: number | null;
+    /**
+     * Packets waiting in the transmit queue. Nullable.
+     */
+    txQueueLen: number | null;
+    /**
+     * Seconds since the node booted. A decrease between samples is a reboot.
+     */
+    uptimeSeconds: string;
+};
+/**
+ * MeshDetail is the MESH detail block, for one MeshCore radio node, keyed by its
+ * Ed25519 public key.
+ *
+ * Identity, location and reachability changes write a revision. The volatile
+ * signal readings in `telemetry` change constantly without one.
+ *
+ */
+export type V1MeshDetail = {
+    /**
+     * Name the node advertises. Free text and can include emoji.
+     */
+    name: string;
+    /**
+     * Node role as advertised. Repeaters and room servers relay traffic;
+     * companions and sensors do not.
+     */
+    nodeType: 'companion' | 'repeater' | 'room_server' | 'sensor';
+    /**
+     * Full Ed25519 public key, 64 lowercase hex characters. It is also the native
+     * half of the event id (`meshcore:{publicKey}`) and the `node` parameter of
+     * `GET /api/v1/mesh/telemetry`.
+     */
+    publicKey: string;
+    /**
+     * Whether an operator-run monitor can reach this node's admin interface.
+     * MESH_REACHABILITY_UNSPECIFIED for the many nodes no monitor watches. A
+     * change writes a revision, so the history answers "how often is this
+     * repeater down?".
+     *
+     */
+    reachability: V1MeshReachability;
+    /**
+     * Signal readings and activity clocks. These change without a new revision.
+     *
+     */
+    telemetry: V1MeshTelemetry | null;
+};
+/**
+ * MeshReachability is an operator monitor's verdict on a node's admin interface,
+ * smoothed so a marginal link does not flap.
+ *
+ * - MESH_REACHABILITY_UNSPECIFIED: No monitor watches this node (most nodes). Says nothing about liveness.
+ * - REACHABLE: A monitor reached it recently.
+ * - UNREACHABLE: A monitor has been failing to reach it for longer than its window.
+ */
+export type V1MeshReachability = 'MESH_REACHABILITY_UNSPECIFIED' | 'REACHABLE' | 'UNREACHABLE';
+/**
+ * MeshTelemetry is a mesh node's volatile signal state and activity clocks. None
+ * of it writes a revision, so history snapshots do not reflect it.
+ *
+ * For "is this node up right now", use `lastRelayedAt` (repeaters relay
+ * constantly but advertise only every day or two), then `lastHeardAt`; never
+ * the event's `observedAt`.
+ *
+ */
+export type V1MeshTelemetry = {
+    /**
+     * Latest reading from an operator-run monitor that logs into the node's admin
+     * interface. `null` for nodes no monitor watches. The full series is at
+     * `GET /api/v1/mesh/telemetry?node={publicKey}`.
+     *
+     */
+    admin: V1MeshAdminTelemetry | null;
+    /**
+     * Ids of the gateways (observer node keys, uppercase hex) that heard the node.
+     */
+    gateways: Array<string>;
+    /**
+     * Hops the last-heard advert travelled; 0 means heard directly. Nullable,
+     * like `snr`: `null` is unknown, not zero hops.
+     */
+    hopCount: number | null;
+    /**
+     * Time stamped by the node itself on its last advert (the node's clock, which
+     * can be wrong). `null` if no bridge has heard an advert.
+     */
+    lastAdvertAt: string | null;
+    /**
+     * When the Grid last received one of this node's own adverts, by our clock
+     * (compare `lastAdvertAt`, the node's clock). Answers "when did the node last
+     * speak". `null` when no advert has been received since activity tracking
+     * began. Filled at read time on current events only; history revisions do not
+     * carry it.
+     *
+     */
+    lastHeardAt: string | null;
+    /**
+     * When the Grid last received a packet this node RELAYED, by our clock. A
+     * repeater advertises every day or two but relays constantly, so this is the
+     * clock that says it is up right now. `null` when no relay has been
+     * attributed. Read-time only, like `lastHeardAt`.
+     *
+     * A hop is credited only when exactly one relay-capable node fits it, so a
+     * node whose traffic is ambiguous gets no relay time (it reads older than on
+     * other mesh tools). Flood-routed packets of any type credit every hop; a
+     * direct-routed packet's remaining route credits its 2- and 3-byte hops only.
+     * A relay also keeps a known node ACTIVE for a while after it, the way an
+     * advert does; it never creates a node or changes its name or position.
+     *
+     */
+    lastRelayedAt: string | null;
+    /**
+     * Received signal strength of the last advert, in dBm, gateway-reported.
+     * Nullable, like `snr`.
+     */
+    rssi: number | null;
+    /**
+     * Signal-to-noise ratio of the last advert, in dB, as a listening gateway
+     * reported it. Nullable: `null` unless an MQTT bridge heard the advert (then
+     * `lastAdvertAt` is set too).
+     *
+     */
+    snr: number | null;
+};
+/**
+ * MeshTelemetryArchive is one node's samples over a window, with what a chart
+ * needs in order not to lie about them.
+ */
+export type V1MeshTelemetryArchive = {
+    /**
+     * Median gap between samples in the window, in seconds, so a chart knows which
+     * gaps are abnormal enough to break a line on. 64-bit, so a JSON STRING
+     * (`"1831"`). Nullable: `null` with fewer than two samples.
+     *
+     */
+    cadenceSeconds: string | null;
+    /**
+     * What the archive holds for this node at all, whatever window was asked
+     * for. A window outside it has no samples because we do not have them, which
+     * is not the same as the node being quiet.
+     */
+    coverage: V1MeshTelemetryCoverage;
+    /**
+     * Window start actually used (after defaults and clamping).
+     */
+    from: string;
+    /**
+     * The requested node, normalized to the bare lowercase key (no `meshcore:`
+     * prefix).
+     */
+    node: string;
+    /**
+     * Sample times where the node's uptime went backwards, i.e. it rebooted. Every
+     * counter restarts there, so break counter lines at these times. Empty list
+     * when none.
+     */
+    reboots: Array<string>;
+    /**
+     * Samples in the window, oldest first.
+     */
+    samples: Array<V1MeshTelemetrySample>;
+    /**
+     * Window end actually used.
+     */
+    to: string;
+    /**
+     * True when the window held more than the 20,000 samples one response carries;
+     * the series ends early. Narrow the window to see the rest.
+     */
+    truncated: boolean;
+};
+/**
+ * MeshTelemetryCoverage is the span of the whole archive for one node.
+ */
+export type V1MeshTelemetryCoverage = {
+    /**
+     * Oldest archived sample. `null` when the archive holds none.
+     */
+    from: string | null;
+    /**
+     * Number of archived samples in total.
+     */
+    samples: number;
+    /**
+     * Newest archived sample. `null` when the archive holds none.
+     */
+    to: string | null;
+};
+/**
+ * MeshTelemetrySample is one archived report.
+ *
+ */
+export type V1MeshTelemetrySample = {
+    /**
+     * The reading. `reading.reportedAt` is the sample's own time; gauges are
+     * nullable exactly as on the live event.
+     */
+    reading: V1MeshAdminTelemetry;
+    /**
+     * When the Grid first stored it.
+     */
+    receivedAt: string;
+};
+/**
+ * Place is a named geography that events attach to.
+ */
+export type V1Place = {
+    /**
+     * The place's shape: a Polygon for counties and areas, a LineString for
+     * corridors, a Point for towns.
+     */
+    geometry: V1Geometry;
+    /**
+     * Namespaced id, `{kind}:{slug}`.
+     */
+    id: string;
+    /**
+     * What kind of place this is.
+     */
+    kind: V1PlaceKind;
+    /**
+     * Display name.
+     */
+    name: string;
+    /**
+     * Id of the containing place (a town's county). Empty string when none.
+     */
+    parentId: string;
+    /**
+     * URL-safe short name, unique across all kinds. Use it in paths and the
+     * `place` parameter.
+     */
+    slug: string;
+};
+/**
+ * PlaceKind is the type of a place.
+ *
+ * - PLACE_KIND_UNSPECIFIED: Never returned.
+ * - AREA: A configured coverage area such as `ebbetts-pass` (the Highway 4 corridor
+ * region). Area places own the scanner feeds and the fire-weather zones.
+ * - COUNTY: A county, from Census polygons.
+ * - TOWN: A town, stored as a Point. `places:resolve` matches a town within 3 km of
+ * its point. Events attach to a town only by overlapping polygons (and
+ * wildfires by proximity), never by that radius.
+ * - EVAC_ZONE: Reserved for evacuation zones as places; none exist today.
+ * - CORRIDOR: A highway segment, stored as a LineString. Point events within about 1.5 km
+ * of the line attach to it.
+ * - SITE: Reserved for individual sites; none exist today.
+ */
+export type V1PlaceKind = 'PLACE_KIND_UNSPECIFIED' | 'AREA' | 'COUNTY' | 'TOWN' | 'EVAC_ZONE' | 'CORRIDOR' | 'SITE';
+/**
+ * PlaceList is the place directory.
+ */
+export type V1PlaceList = {
+    /**
+     * Places, ordered by kind and then name.
+     */
+    places: Array<V1Place>;
+};
+/**
+ * PlaceSummary is the one-call rollup for a place.
+ *
+ * `summary` covers hazards only. Each entry in `domains` covers one subject
+ * area, including the ambient ones (`burn`, `comms`) that the hazard rollup
+ * leaves out.
+ */
+export type V1PlaceSummary = {
+    /**
+     * One block per domain, always in this order: `fire`, `evacuation`,
+     * `weather`, `roads`, `seismic`, `power`, then `burn` (when burn counties are
+     * configured) and `comms` (when the mesh source is enabled). Both are
+     * configured in production.
+     */
+    domains: Array<V1SummaryDomain>;
+    /**
+     * When this summary was computed.
+     */
+    generatedAt: string;
+    /**
+     * Overall posture. The rules below are checked in order and the first match
+     * wins.
+     *
+     * - `ACTIVE`: an active evacuation at ORDER, WARNING or SHELTER_IN_PLACE; or
+     * any active EXTREME event; or an active wildfire at SEVERE or above.
+     * - `WATCH`: any active SEVERE event; or an active evacuation ADVISORY; or
+     * fire weather `elevated` (Fire Weather Watch) or `red-flag` (Red Flag
+     * Warning) for a place inside a coverage area; or the evacuation source
+     * UNAVAILABLE (unknown is never quiet); or any layer feeding the
+     * summary UNAVAILABLE while an active event is MODERATE or above.
+     * - `QUIET`: otherwise. A MODERATE or lower event on its own leaves the
+     * place QUIET.
+     *
+     * Only these inputs can raise it: ACTIVE events on the WILDFIRE,
+     * EVACUATION, WEATHER_ALERT, EARTHQUAKE, ROAD_INCIDENT and POWER layers
+     * (by severity), the fire-weather state, and source health. These never
+     * raise it: SCHEDULED events (a planned closure, a watch or PSPS not yet in
+     * effect), MESH nodes, BURN_STATUS, INFO POWER outages, and every condition
+     * other than fire weather. A CLOSED `road_segment` or a chain control
+     * raises the `roads` domain's `highestSeverity`, not `mode`, so a place can
+     * be QUIET with a closed highway. Show each domain's `status` and
+     * `highestSeverity` alongside `mode`.
+     */
+    mode: 'QUIET' | 'WATCH' | 'ACTIVE';
+    /**
+     * The place's slug.
+     */
+    place: string;
+    /**
+     * The place's namespaced id.
+     */
+    placeId: string;
+    /**
+     * The place's display name.
+     */
+    placeName: string;
+    /**
+     * Health of the sources behind the summary's layers. Region-wide, not
+     * specific to the place.
+     */
+    sources: Array<V1SummarySourceHealth>;
+    /**
+     * Cross-layer hazard rollup.
+     */
+    summary: V1SummaryStats;
+};
+/**
+ * PowerDetail is the POWER detail block, for a PG&E outage or a Public Safety
+ * Power Shutoff (PSPS). The envelope `category` says which: `unplanned` and
+ * `planned` outages fill the outage fields; `psps` fills the PSPS fields. The
+ * other group is zero, empty or `null`.
+ *
+ * Every PG&E time here is an estimate PG&E often overruns, so none of them is
+ * mapped onto the envelope `expires` or drives the lifecycle.
+ */
+export type V1PowerDetail = {
+    /**
+     * PG&E's planned all-clear time. A plan, not proof the shutoff ended: it is
+     * set even while the stage is still Watch. Never use it to decide the power
+     * is back; use `status`.
+     *
+     */
+    allClear: string | null;
+    /**
+     * Raw PG&E cause code, e.g. "PLNND SHUTDOWN", "TREE CONTACT", "EMERG REPAIRS".
+     * Empty string for PSPS.
+     */
+    cause: string;
+    /**
+     * PG&E crew status, verbatim: "Awaiting T-Man", "T-Man On Site", "Crew On
+     * Site", "No Access", ... Empty string for PSPS.
+     */
+    crewStatus: string;
+    /**
+     * Estimated customers without power. 0 means PG&E gave no count. Statewide,
+     * the median outage affects one customer.
+     */
+    customersAffected: number;
+    /**
+     * Planned end of de-energization (an estimate). `null` for outages.
+     */
+    deEnergizationEnd: string | null;
+    /**
+     * Planned start of de-energization. `null` for outages.
+     */
+    deEnergizationStart: string | null;
+    /**
+     * PG&E's estimated time of restoration. An estimate that is often missed;
+     * `null` when not given.
+     *
+     */
+    estimatedRestoration: string | null;
+    /**
+     * --- PSPS (source `psps`) ---
+     * PG&E PSPS event id. Empty string for outages.
+     */
+    eventId: string;
+    /**
+     * PG&E PSPS event name. Empty string for outages.
+     */
+    eventName: string;
+    /**
+     * Medical-baseline customers in the shutoff footprint: people whose medical
+     * equipment depends on grid power. No other feed reports this.
+     */
+    medicalBaselineAffected: number;
+    /**
+     * --- outage (source `pge`) ---
+     * PG&E outage id, the native half of `pge:{id}`. Empty string for PSPS.
+     */
+    outageId: string;
+    /**
+     * PSPS stage: `Watch` (shutoff under consideration, MODERATE) or `Warning`
+     * (shutoff committed, SEVERE). Empty string for outages.
+     */
+    stage: '' | 'Watch' | 'Warning';
+    /**
+     * The de-energization time-period slice this event covers. Empty string for
+     * outages.
+     */
+    timePeriod: string;
+};
+/**
+ * Provenance says which upstream published an event. Show `attribution` next to
+ * the data.
+ */
+export type V1Provenance = {
+    /**
+     * Attribution text to display, e.g. "CAL FIRE / FIRIS / NIFC". Can be an
+     * empty string.
+     */
+    attribution: string;
+    /**
+     * When the Grid fetched the upstream data behind this revision.
+     */
+    fetchedAt: string;
+    /**
+     * Source registry id; joins to `Source.id` on `/api/v1/sources`.
+     */
+    sourceId: 'calfire' | 'firis' | 'caloes' | 'nws' | 'usgs' | 'chp' | 'caltrans' | 'pge' | 'psps' | 'meshcore' | 'burnline' | 'calfire-burn';
+    /**
+     * Display name of the publisher, e.g. "CAL FIRE", "NWS Sacramento CA",
+     * "CHP / Caltrans".
+     */
+    sourceName: string;
+    /**
+     * Link to the publisher's page for this item or feed (for evacuations, the
+     * Genasys or county zone viewer). Empty string when none, which today means
+     * CHP incidents, Caltrans lane closures, FIRIS perimeters, NWS alerts and
+     * burn status. Fall back to `Source.homepageUrl` for `sourceId`.
+     */
+    sourceUrl: string;
+};
+/**
+ * ResolvePlaceResponse lists the places containing a point.
+ */
+export type V1ResolvePlaceResponse = {
+    /**
+     * Containing places, most specific first. Empty when the point is outside
+     * every place.
+     */
+    places: Array<V1Place>;
+    /**
+     * The point that was resolved.
+     */
+    query: V1ResolveQuery;
+};
+/**
+ * ResolveQuery echoes the point that was resolved.
+ */
+export type V1ResolveQuery = {
+    /**
+     * Latitude used for the lookup (the geocoded point for an address).
+     */
+    lat: number;
+    /**
+     * Longitude used for the lookup.
+     */
+    lng: number;
+    /**
+     * The address the geocoder matched, normalized. Empty string for a lat/lng
+     * query.
+     */
+    matchedAddress: string;
+};
+/**
+ * RoadIncidentDetail is the ROAD_INCIDENT detail block, for a CHP incident or a
+ * Caltrans lane-closure window. The incident type is the envelope `category`,
+ * the location is `areaLabel`, and the short line is `headline`.
+ */
+export type V1RoadIncidentDetail = {
+    /**
+     * The Caltrans closure window, for source `caltrans` only; `null` for CHP
+     * incidents.
+     */
+    closure: V1LaneClosureDetail | null;
+    /**
+     * AI-estimated duration (CHP incidents only). Empty string when not assessed.
+     */
+    duration: '' | 'unknown' | '< 1 hour' | 'several hours' | 'ongoing';
+    /**
+     * AI-assessed traffic impact (CHP incidents only); it drives `severity`.
+     * Empty string for Caltrans closures and when not yet assessed.
+     */
+    impact: '' | 'none' | 'light' | 'moderate' | 'severe';
+    /**
+     * CHP log number for an incident; for a Caltrans closure, its closure id.
+     */
+    logNumber: string;
+    /**
+     * Free-form extras from the AI analysis, string to string (keys such as
+     * `incident_type`, `lanes_blocked`, `injuries`). Keys vary; treat as display
+     * only. Empty object when none.
+     */
+    metadata: {
+        [key: string]: string;
+    };
+};
+/**
+ * Scanner is one Broadcastify audio feed.
+ */
+export type V1Scanner = {
+    /**
+     * Agencies heard on it.
+     */
+    agency: string;
+    /**
+     * Listening page on Broadcastify.
+     */
+    broadcastifyUrl: string;
+    /**
+     * What the feed carries.
+     */
+    channelLabel: string;
+    /**
+     * Broadcastify feed id.
+     */
+    feedId: string;
+};
+/**
+ * ScannerList is the scanner feeds.
+ */
+export type V1ScannerList = {
+    /**
+     * Feeds, in configuration order.
+     */
+    scanners: Array<V1Scanner>;
+};
+/**
+ * Severity is the unified 5-level scale shared by every layer: how urgently the
+ * public should respond, not physical magnitude. The enum number is the rank
+ * (`severityRank`, 0-4), for sorting and colour ramps.
+ *
+ * How each layer is graded. WILDFIRE: the worse of a containment floor (under
+ * 50% contained SEVERE, 50-99% MODERATE, 100% MINOR) and size (1,000+ acres
+ * under 50% contained EXTREME, 100+ acres SEVERE). EVACUATION: ORDER EXTREME,
+ * WARNING and SHELTER_IN_PLACE SEVERE, ADVISORY MODERATE. WEATHER_ALERT: the NWS
+ * severity (Extreme..Minor) one-to-one, otherwise INFO. EARTHQUAKE: M5+ SEVERE,
+ * M4+ MODERATE, M2.5+ MINOR. ROAD_INCIDENT: a CHP incident by its AI-assessed
+ * impact (severe SEVERE, moderate MODERATE, light MINOR, none INFO); a Caltrans
+ * closure by its structure (full closure SEVERE, a travel lane or one-way
+ * traffic MODERATE, shoulder only MINOR). POWER: 1,000+ customers SEVERE, 100+
+ * MODERATE, 10+ MINOR, fewer INFO, unknown count MINOR, planned outages one rank
+ * lower; PSPS Warning SEVERE, Watch MODERATE. MESH and BURN_STATUS: always INFO.
+ * Condition layers on the map: road segment CLOSED SEVERE, restricted or heavy
+ * congestion MODERATE; chain control R3 SEVERE, R2 MODERATE, R1 MINOR, road
+ * closed MINOR; fire weather red-flag SEVERE, elevated MODERATE.
+ *
+ * - INFO: Rank 0. Informational: ambient state, single-customer outages, small quakes,
+ * clear roads. Also the default when a source gives no grade.
+ * - MINOR: Rank 1. Minor impact.
+ * - MODERATE: Rank 2. Moderate impact; worth attention.
+ * - SEVERE: Rank 3. Severe; act or prepare now.
+ * - EXTREME: Rank 4. Extreme; life-safety (evacuation orders, large uncontained fires).
+ */
+export type V1Severity = 'INFO' | 'MINOR' | 'MODERATE' | 'SEVERE' | 'EXTREME';
+/**
+ * Source is one row of the source registry, with its health.
+ *
+ * Two kinds of row, told apart by `kind`: a FEED is an upstream the Grid
+ * fetches on a schedule, and its id is what events carry in
+ * `provenance.sourceId`. A REPORTER is an operator-run monitor that pushes data
+ * to the Grid (`alanpi`, `relay`, `burn-line`); its row carries health only and
+ * no event names it as its source.
+ *
+ * To judge health, read `status`. It is rewritten at every attempt, so as a
+ * second check against the Grid itself stalling, treat a row as suspect when
+ * `lastAttemptAt` is older than `staleAfterSeconds`. Do not compare
+ * `lastAttemptAt` with `pollIntervalSeconds`: that misfires for reporters.
+ *
+ * Not every source id that appears in the API has a row. The live condition
+ * layers fetch on request, outside the scheduler that writes this registry, so
+ * `google` (the `road_segment` layer's travel times) has no row, and the
+ * `caltrans` and `nws` rows describe the scheduled lane-closure and alert
+ * polls, not the live `chain_control`, `message_sign`, `road_segment` and
+ * `fire_weather` fetches. For those layers read the map layer's
+ * `metadata.sourceStatus` or the summary domain's `status`.
+ */
+export type V1Source = {
+    /**
+     * Attribution text to display.
+     */
+    attribution: string;
+    /**
+     * For sources whose silence proves nothing (NWS, FIRIS, MeshCore): how long,
+     * in seconds, an event may go unseen before it is EXPIRED. 0 means the source
+     * never auto-expires; its events are RESOLVED when a good poll stops listing
+     * them.
+     */
+    expireAfterSeconds: number;
+    /**
+     * Public page for the upstream. Use it as the fallback link for an event
+     * whose `canonicalUrl` and `provenance.sourceUrl` are empty (join on
+     * `provenance.sourceId`). Empty string for REPORTER rows, and for a feed with
+     * no public page.
+     */
+    homepageUrl: string;
+    /**
+     * Registry id; `Provenance.sourceId` on events joins to it (FEED rows only).
+     */
+    id: string;
+    /**
+     * Whether this row is a scheduled feed or a push reporter.
+     */
+    kind: V1SourceKind;
+    /**
+     * When the row was last evaluated, successfully or not. `null` if never.
+     * `status` is rewritten at each attempt, so if this is older than
+     * `staleAfterSeconds`, the Grid itself has stopped checking: treat the
+     * source as STALE whatever `status` says.
+     */
+    lastAttemptAt: string | null;
+    /**
+     * The last attempt's error text. Empty string after a success.
+     */
+    lastError: string;
+    /**
+     * When an attempt last succeeded. `null` if never. For a REPORTER this is the
+     * last check that found it reporting on time, not the time of its last
+     * report (`lastError` names that once it goes quiet).
+     */
+    lastSuccessAt: string | null;
+    /**
+     * Display name, e.g. "CHP (traffic incidents)".
+     */
+    name: string;
+    /**
+     * How often, in seconds, the Grid re-evaluates this row. For a FEED that is
+     * its poll interval. For a REPORTER it is the cadence of the Grid's check on
+     * the reporter, not how often the reporter reports.
+     */
+    pollIntervalSeconds: number;
+    /**
+     * For a FEED: seconds after the last success during which a failing source
+     * still reads STALE rather than UNAVAILABLE (default three poll intervals).
+     * For a REPORTER: how long it may go without reporting before it stops
+     * reading OK (it then reads STALE for this long again, then UNAVAILABLE).
+     */
+    staleAfterSeconds: number;
+    /**
+     * Health of this source. This is the field to judge it by; see the message
+     * description.
+     */
+    status: V1SourceStatus;
+};
+/**
+ * SourceKind says what a source registry row describes.
+ *
+ * - SOURCE_KIND_UNSPECIFIED: Never returned.
+ * - FEED: An upstream feed the Grid fetches on a schedule (CAL FIRE, NWS, PG&E, ...).
+ * Events name it in `provenance.sourceId`.
+ * - REPORTER: An operator-run monitor that pushes to the Grid's ingest endpoint. Health
+ * only: no event carries its id, and `homepageUrl` is empty.
+ */
+export type V1SourceKind = 'SOURCE_KIND_UNSPECIFIED' | 'FEED' | 'REPORTER';
+/**
+ * SourceList is the source registry.
+ */
+export type V1SourceList = {
+    /**
+     * Every source, ordered by id, including the health-only push-reporter rows.
+     */
+    sources: Array<V1Source>;
+};
+/**
+ * SourceStatus is a source's health. The same three values appear as strings in
+ * the summary's domains and sidecar, on `/api/v1/cameras`, and on the map
+ * layers' `metadata.sourceStatus`.
+ *
+ * - SOURCE_STATUS_UNSPECIFIED: Not polled yet since the registry row was created. Treat as UNAVAILABLE.
+ * - OK: The last attempt succeeded.
+ * - STALE: The last attempt failed, but the last success is within
+ * `staleAfterSeconds`; what is served is last-good data.
+ * - UNAVAILABLE: Failing beyond `staleAfterSeconds`, or never succeeded. Nothing current can
+ * be vouched for: render "unknown", never "none".
+ */
+export type V1SourceStatus = 'SOURCE_STATUS_UNSPECIFIED' | 'OK' | 'STALE' | 'UNAVAILABLE';
+/**
+ * SummaryDomain is one subject area's status for the place.
+ *
+ * Domain inputs: `fire` = WILDFIRE events + the fire_weather condition;
+ * `evacuation` = EVACUATION; `weather` = WEATHER_ALERT; `roads` = ROAD_INCIDENT
+ * events (not SCHEDULED roadwork) + the chain_control and road_segment
+ * conditions; `seismic` = EARTHQUAKE; `power` = POWER (including INFO
+ * outages); `burn` = BURN_STATUS; `comms` = MESH. A domain counts every one of
+ * its ACTIVE and SCHEDULED events at any severity, but a condition only when it
+ * is above INFO (an open road or normal fire weather is not "active").
+ */
+export type V1SummaryDomain = {
+    /**
+     * Number of counted items (events plus above-INFO conditions). It can be
+     * non-zero while `summary.totalActive` is 0: `comms` counts mesh nodes,
+     * `burn` counts burn status, and `power` counts INFO outages.
+     */
+    activeCount: number;
+    /**
+     * Domain name.
+     */
+    domain: 'fire' | 'evacuation' | 'weather' | 'roads' | 'seismic' | 'power' | 'burn' | 'comms';
+    /**
+     * Up to three counted items, most severe first (events before conditions on
+     * ties). An item is an event OR a condition-layer feature; check `kind`.
+     */
+    headlines: Array<V1SummaryDomainHeadline>;
+    /**
+     * Highest severity among the domain's counted items; `INFO` when none.
+     */
+    highestSeverity: 'INFO' | 'MINOR' | 'MODERATE' | 'SEVERE' | 'EXTREME';
+    /**
+     * The WORST source status across the domain's layers, so partial data never
+     * presents as complete. A failing source with stored events reads STALE.
+     */
+    status: 'OK' | 'STALE' | 'UNAVAILABLE';
+};
+/**
+ * SummaryDomainHeadline is one item in a domain's headline list: an event, or a
+ * live condition-layer feature (a closed road segment, a chain control, a fire
+ * weather banner). Use `kind` to tell them apart before following `id`.
+ */
+export type V1SummaryDomainHeadline = {
+    /**
+     * The item's headline.
+     */
+    headline: string;
+    /**
+     * The item's id. For `kind: EVENT` an event id, fetchable at
+     * `GET /api/v1/events/{id}`. For `kind: CONDITION` a map-feature id
+     * (`road:{segment}`, `cc:{checkpoint}`, `fw:region`): it is NOT an event and
+     * `GET /api/v1/events/{id}` returns 404. Find it as `properties.id` in the
+     * place's `{layer}.geojson` map layer (the layer slug is `layer` lowercased).
+     */
+    id: string;
+    /**
+     * `EVENT` when `id` is a stored event, `CONDITION` when it is a live
+     * condition-layer map feature with no event record.
+     */
+    kind: 'EVENT' | 'CONDITION';
+    /**
+     * The item's layer, UPPERCASE. For an event, its `Event.layer`. For a
+     * condition, the condition layer (`ROAD_SEGMENT`, `CHAIN_CONTROL`,
+     * `FIRE_WEATHER`); lowercase it for the `.geojson` map-layer path.
+     */
+    layer: 'WILDFIRE' | 'EVACUATION' | 'WEATHER_ALERT' | 'EARTHQUAKE' | 'ROAD_INCIDENT' | 'POWER' | 'MESH' | 'BURN_STATUS' | 'ROAD_SEGMENT' | 'CHAIN_CONTROL' | 'FIRE_WEATHER';
+    /**
+     * The item's severity.
+     */
+    severity: 'INFO' | 'MINOR' | 'MODERATE' | 'SEVERE' | 'EXTREME';
+};
+/**
+ * SummarySourceHealth is one source registry row behind the summary's layers.
+ */
+export type V1SummarySourceHealth = {
+    /**
+     * Source id, as on `/api/v1/sources`.
+     */
+    id: string;
+    /**
+     * When the source last polled successfully. `null` if never.
+     */
+    lastSuccessAt: string | null;
+    /**
+     * The source's health. A source never polled reads `UNAVAILABLE`.
+     */
+    status: 'OK' | 'STALE' | 'UNAVAILABLE';
+};
+/**
+ * SummaryStats is the place's hazard rollup.
+ *
+ * It counts the place's ACTIVE and SCHEDULED events except four carve-outs:
+ * MESH nodes and BURN_STATUS (ambient state, shown in their own domains), POWER
+ * outages at INFO (single-customer service calls), and SCHEDULED road closures
+ * (planned roadwork). A SCHEDULED weather watch or PSPS still counts. Condition
+ * layers never count here.
+ */
+export type V1SummaryStats = {
+    /**
+     * ACTIVE evacuation zones attached to the place. NULLABLE: `null` when the
+     * evacuation source is UNAVAILABLE with nothing stored (unknown: render
+     * "unknown, check Genasys", never "none"). `0` means a healthy fetch found no
+     * active zone ("no active evacuations reported", not a guarantee). Never
+     * coerce `null` to 0.
+     */
+    activeEvacuations: number | null;
+    /**
+     * The authoritative evacuation viewer (Genasys Protect), the same link as
+     * the `evacuation` map layer's `metadata.sourceUrl`. Always set, whatever
+     * `evacuationStatus` says: it is where to send people when the count is
+     * `null` ("unknown, check Genasys") and the place to confirm a 0 or an N.
+     * For one zone's own page use the event's `provenance.sourceUrl`.
+     */
+    evacuationSourceUrl: string;
+    /**
+     * Health of the evacuation source as served: `OK`, `STALE` (source failing
+     * but stored zones are served; the count is last-good) or `UNAVAILABLE`
+     * (then `activeEvacuations` is `null`).
+     */
+    evacuationStatus: 'OK' | 'STALE' | 'UNAVAILABLE';
+    /**
+     * Highest severity among the counted events; `INFO` when there are none.
+     */
+    highestSeverity: 'INFO' | 'MINOR' | 'MODERATE' | 'SEVERE' | 'EXTREME';
+    /**
+     * Rank of `highestSeverity`, 0 (INFO) to 4 (EXTREME).
+     */
+    highestSeverityRank: number;
+    /**
+     * Count of counted events per severity name (`INFO` .. `EXTREME`). A severity
+     * with no events is absent rather than 0.
+     */
+    severityCounts: {
+        [key: string]: number;
+    };
+    /**
+     * Up to five counted events, most severe first, then most recently observed.
+     * Every id here is an event (`GET /api/v1/events/{id}`).
+     */
+    topEvents: Array<V1SummaryTopEvent>;
+    /**
+     * Number of counted events (ACTIVE and SCHEDULED, after the carve-outs).
+     */
+    totalActive: number;
+};
+/**
+ * SummaryTopEvent is one of the place's most urgent hazard events.
+ */
+export type V1SummaryTopEvent = {
+    /**
+     * The event's headline.
+     */
+    headline: string;
+    /**
+     * Event id, fetchable at `GET /api/v1/events/{id}`.
+     */
+    id: string;
+    /**
+     * The event's layer as the UPPERCASE enum name, the same value as
+     * `Event.layer`. Never MESH or BURN_STATUS (excluded from the rollup).
+     */
+    layer: 'WILDFIRE' | 'EVACUATION' | 'WEATHER_ALERT' | 'EARTHQUAKE' | 'ROAD_INCIDENT' | 'POWER';
+    /**
+     * The event's severity.
+     */
+    severity: 'INFO' | 'MINOR' | 'MODERATE' | 'SEVERE' | 'EXTREME';
+    /**
+     * Rank of `severity`, 0-4.
+     */
+    severityRank: number;
+    /**
+     * The event's source id (`provenance.sourceId`).
+     */
+    source: string;
+};
+/**
+ * WeatherAlertDetail is the WEATHER_ALERT detail block, for one NWS product.
+ *
+ * It carries only fields the envelope lacks: the NWS event name is the
+ * envelope `category`, and the issuing office is `provenance.sourceName`.
+ */
+export type V1WeatherAlertDetail = {
+    /**
+     * NWS free-text list of the affected zones.
+     */
+    areaDesc: string;
+    /**
+     * NWS certainty.
+     */
+    certainty: 'Observed' | 'Likely' | 'Possible' | 'Unlikely' | 'Unknown';
+    /**
+     * NWS recommended actions, verbatim, with newlines. Empty string when none.
+     */
+    instruction: string;
+    /**
+     * NWS's own severity word, distinct from the unified `severity` it maps to.
+     */
+    nwsSeverity: 'Extreme' | 'Severe' | 'Moderate' | 'Minor' | 'Unknown';
+    /**
+     * NWS urgency.
+     */
+    urgency: 'Immediate' | 'Expected' | 'Future' | 'Past' | 'Unknown';
+    /**
+     * NWS forecast zone codes the alert covers, e.g. "CAZ138".
+     */
+    zones: Array<string>;
+};
+/**
+ * WeatherConditions is current weather at one location, from OpenWeatherMap.
+ * Whole numbers, metric units. A value that could not be read is 0.
+ */
+export type V1WeatherConditions = {
+    /**
+     * Feels-like temperature, degrees Celsius.
+     */
+    feelsLikeCelsius: number;
+    /**
+     * Relative humidity, percent.
+     */
+    humidityPercent: number;
+    /**
+     * Location id; joins to `WeatherForecast.locationId`.
+     */
+    locationId: string;
+    /**
+     * Display name.
+     */
+    locationName: string;
+    /**
+     * Air temperature, degrees Celsius.
+     */
+    temperatureCelsius: number;
+    /**
+     * Visibility, km (OpenWeatherMap caps it at 10).
+     */
+    visibilityKm: number;
+    /**
+     * OpenWeatherMap description, lowercase, e.g. "clear sky".
+     */
+    weatherDescription: string;
+    /**
+     * OpenWeatherMap icon code; the image is
+     * `https://openweathermap.org/img/wn/{icon}@2x.png`.
+     */
+    weatherIcon: string;
+    /**
+     * OpenWeatherMap condition group: "Clear", "Clouds", "Rain", "Snow",
+     * "Thunderstorm", "Drizzle", "Mist", ...
+     */
+    weatherMain: string;
+    /**
+     * Direction the wind blows FROM, degrees clockwise from north.
+     */
+    windDirectionDegrees: number;
+    /**
+     * Wind speed, km/h.
+     */
+    windSpeedKmh: number;
+};
+/**
+ * WeatherForecast is a location's short-range forecast: the hourly NWS gridpoint
+ * series (wind, gust, humidity, temperature) plus an at-a-glance summary.
+ * Informational only: it never implies a fire-weather warning (issued products
+ * are in `fireWeather`).
+ *
+ */
+export type V1WeatherForecast = {
+    /**
+     * Hours covered by `periods`.
+     */
+    horizonHours: number;
+    /**
+     * When NWS last updated the grid. Can be `null`.
+     */
+    issuedAt: string | null;
+    /**
+     * Location id; joins to `WeatherConditions.locationId`.
+     */
+    locationId: string;
+    /**
+     * Lowest relative humidity over the horizon, percent. 0 when NWS gave none.
+     */
+    minHumidityPercent: number;
+    /**
+     * When that peak gust is forecast. Can be `null`.
+     */
+    peakWindGustAt: string | null;
+    /**
+     * Highest wind gust over the horizon, km/h.
+     */
+    peakWindGustKmh: number;
+    /**
+     * Hourly periods, in time order.
+     */
+    periods: Array<V1ForecastPeriod>;
+    /**
+     * Data source and NWS grid cell.
+     */
+    source: string;
+};
+/**
+ * WildfireDetail is the WILDFIRE detail block.
+ */
+export type V1WildfireDetail = {
+    /**
+     * Burned area in acres: CAL FIRE's figure, or the FIRIS perimeter's area when
+     * only a perimeter is known. Fractional.
+     */
+    acres: number;
+    /**
+     * Cause as reported. Empty string when unknown.
+     */
+    cause: string;
+    /**
+     * Percent contained, 0-100. 0 also when unknown (perimeter-only fires).
+     */
+    containment: number;
+    /**
+     * County named by CAL FIRE. Empty string for perimeter-only fires.
+     */
+    county: string;
+    /**
+     * True when `geometry` is a FIRIS perimeter polygon; false when it is CAL
+     * FIRE's single origin point.
+     */
+    hasPerimeter: boolean;
+};
+/**
+ * An `ETag` from an earlier response, for a `304` revalidation.
+ */
+export type IfNoneMatch = string;
+/**
+ * Recency window for relay links: a positive Go duration. The documented
+ * choices are `24h`, `72h` (the default), `168h` and `720h`; any positive
+ * duration works (`90m`), and values above `9600h` (400 days) are
+ * clamped. Anything else (`abc`, `0`, `-1h`) is a `400
+ * INVALID_ARGUMENT`. `/api/v1/mesh/links` echoes the applied window in
+ * `window`.
+ *
+ */
+export type MeshWindow = string;
+/**
+ * A place slug (`calaveras-county`, `ebbetts-pass`, `hwy4-murphys-arnold`)
+ * or namespaced id (`county:calaveras-county`). Slugs are globally unique.
+ * `GET /api/v1/places` lists them; `GET /api/v1/places:resolve` maps an
+ * address or lat/lng to the places containing it.
+ *
+ */
+export type Place = string;
+export type GridServiceListCamerasData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only cameras within 25 km of this place (slug or id), nearest first.
+         * Default: every camera near any coverage area.
+         */
+        place?: string;
+    };
+    url: '/api/v1/cameras';
+};
+export type GridServiceListCamerasErrors = {
+    /**
+     * NOT_FOUND: unknown place.
+     */
+    404: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceListCamerasError = GridServiceListCamerasErrors[keyof GridServiceListCamerasErrors];
+export type GridServiceListCamerasResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1CameraList;
+};
+export type GridServiceListCamerasResponse = GridServiceListCamerasResponses[keyof GridServiceListCamerasResponses];
+export type GridServiceGetConditionsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only weather locations inside this place's bounding box (slug or id). Does
+         * not filter `fireWeather`.
+         */
+        place?: string;
+    };
+    url: '/api/v1/conditions';
+};
+export type GridServiceGetConditionsErrors = {
+    /**
+     * NOT_FOUND: unknown place.
+     */
+    404: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceGetConditionsError = GridServiceGetConditionsErrors[keyof GridServiceGetConditionsErrors];
+export type GridServiceGetConditionsResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1Conditions;
+};
+export type GridServiceGetConditionsResponse = GridServiceGetConditionsResponses[keyof GridServiceGetConditionsResponses];
+export type GridServiceListEventsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only events attached to this place: slug (`arnold`) or namespaced id
+         * (`town:arnold`). Omit for every place, including events outside all places.
+         */
+        place?: string;
+        /**
+         * Only these layers. Repeat the parameter or comma-separate. Case-insensitive;
+         * lowercase slugs (`road_incident`) and the aliases `mesh_node` and `network`
+         * (for MESH) also work. FIRE_WEATHER, GAUGE, AIR_QUALITY and ANNOUNCEMENT are
+         * accepted but no events carry them. Default: every layer.
+         */
+        layer?: Array<'WILDFIRE' | 'EVACUATION' | 'WEATHER_ALERT' | 'EARTHQUAKE' | 'ROAD_INCIDENT' | 'POWER' | 'MESH' | 'BURN_STATUS'>;
+        /**
+         * Only these statuses. Repeat the parameter or comma-separate.
+         * Case-insensitive. Default: ACTIVE and SCHEDULED. Pass `ACTIVE` alone to drop
+         * planned roadwork; add RESOLVED and EXPIRED to include ended events.
+         */
+        status?: Array<'ACTIVE' | 'SCHEDULED' | 'RESOLVED' | 'EXPIRED'>;
+        /**
+         * Only events at this severity or above. Case-insensitive. Default: no
+         * minimum (same as INFO). `MINOR` drops mesh nodes, burn status and
+         * single-customer outages.
+         */
+        severityMin?: 'INFO' | 'MINOR' | 'MODERATE' | 'SEVERE' | 'EXTREME';
+        /**
+         * Only events whose `observedAt` is at or after this RFC 3339 time, e.g.
+         * `2026-11-06T00:00:00Z`.
+         */
+        since?: string;
+        /**
+         * Most events per page. 0 or omitted means the default of 50; values over
+         * 200 are clamped to 200; a negative value is a 400 INVALID_ARGUMENT. A page
+         * can hold FEWER events than this, because it also stops before its encoded
+         * size passes about 3 MiB (perimeter-heavy events): keep requesting while
+         * `nextPageToken` is non-empty, and never treat a short page as the end.
+         */
+        pageSize?: number;
+        /**
+         * The previous page's `nextPageToken`. Omit for the first page.
+         */
+        pageToken?: string;
+        /**
+         * Include the AI model's full prompt and response (`enhancement.request` and
+         * `enhancement.response`). Large; default false, which returns them as empty
+         * strings.
+         */
+        enhancementIo?: boolean;
+        /**
+         * How each event's `geometry` carries its GeoJSON. `BASE64` (default, the
+         * legacy form): the base64 `geometry.geojson` string. `OBJECT`: a plain
+         * JSON object in `geometry.object`, with `geometry.geojson` empty.
+         * Case-insensitive; anything else is a 400.
+         */
+        geometryFormat?: 'BASE64' | 'OBJECT';
+    };
+    url: '/api/v1/events';
+};
+export type GridServiceListEventsErrors = {
+    /**
+     * INVALID_ARGUMENT: an unknown layer, status, severity or geometryFormat, a timestamp that is not RFC 3339, a negative page size, or a bad page token.
+     */
+    400: RpcStatus;
+    /**
+     * NOT_FOUND: unknown place.
+     */
+    404: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceListEventsError = GridServiceListEventsErrors[keyof GridServiceListEventsErrors];
+export type GridServiceListEventsResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1EventList;
+};
+export type GridServiceListEventsResponse = GridServiceListEventsResponses[keyof GridServiceListEventsResponses];
+export type GridServiceGetEventData = {
+    body?: never;
+    path: {
+        /**
+         * Event id, e.g. `chp:261106ST0341` or `burn:calaveras-county`.
+         */
+        id: string;
+    };
+    query?: {
+        /**
+         * Include `enhancement.request` and `enhancement.response`. Default false.
+         */
+        enhancementIo?: boolean;
+        /**
+         * `BASE64` (default, legacy) or `OBJECT`; same as on `/api/v1/events`.
+         */
+        geometryFormat?: 'BASE64' | 'OBJECT';
+    };
+    url: '/api/v1/events/{id}';
+};
+export type GridServiceGetEventErrors = {
+    /**
+     * INVALID_ARGUMENT: an unknown geometryFormat.
+     */
+    400: RpcStatus;
+    /**
+     * NOT_FOUND: no event has this id.
+     */
+    404: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceGetEventError = GridServiceGetEventErrors[keyof GridServiceGetEventErrors];
+export type GridServiceGetEventResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1Event;
+};
+export type GridServiceGetEventResponse = GridServiceGetEventResponses[keyof GridServiceGetEventResponses];
+export type GridServiceGetEventHistoryData = {
+    body?: never;
+    path: {
+        /**
+         * Event id.
+         */
+        id: string;
+    };
+    query?: {
+        /**
+         * Most revisions per page. 0 or omitted means the default of 50; values
+         * over 200 are clamped to 200; a negative value is a 400 INVALID_ARGUMENT. A
+         * page can hold fewer (it stops at about 3 MiB encoded): follow
+         * `nextPageToken` until it is empty.
+         */
+        pageSize?: number;
+        /**
+         * The previous page's `nextPageToken`. Omit for the first page.
+         */
+        pageToken?: string;
+        /**
+         * Include `enhancement.request` and `enhancement.response`. Default false.
+         */
+        enhancementIo?: boolean;
+        /**
+         * `BASE64` (default, legacy) or `OBJECT`; same as on `/api/v1/events`.
+         */
+        geometryFormat?: 'BASE64' | 'OBJECT';
+    };
+    url: '/api/v1/events/{id}/history';
+};
+export type GridServiceGetEventHistoryErrors = {
+    /**
+     * INVALID_ARGUMENT: a negative page size, a bad page token, or an unknown geometryFormat.
+     */
+    400: RpcStatus;
+    /**
+     * NOT_FOUND: no event has this id.
+     */
+    404: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceGetEventHistoryError = GridServiceGetEventHistoryErrors[keyof GridServiceGetEventHistoryErrors];
+export type GridServiceGetEventHistoryResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1EventRevisionList;
+};
+export type GridServiceGetEventHistoryResponse = GridServiceGetEventHistoryResponses[keyof GridServiceGetEventHistoryResponses];
+export type GridServiceListHistoryData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only revisions of events currently attached to this place (slug or id).
+         */
+        place?: string;
+        /**
+         * Only these layers; same rules as on `/api/v1/events`.
+         */
+        layer?: Array<'WILDFIRE' | 'EVACUATION' | 'WEATHER_ALERT' | 'EARTHQUAKE' | 'ROAD_INCIDENT' | 'POWER' | 'MESH' | 'BURN_STATUS'>;
+        /**
+         * Window start on each revision's `observedAt`, RFC 3339, inclusive. Default:
+         * no lower bound.
+         */
+        from?: string;
+        /**
+         * Window end, RFC 3339, exclusive. Default: no upper bound.
+         */
+        to?: string;
+        /**
+         * Most revisions per page. 0 or omitted means the default of 50; values
+         * over 200 are clamped to 200; a negative value is a 400 INVALID_ARGUMENT. A
+         * page can hold fewer (it stops at about 3 MiB encoded): follow
+         * `nextPageToken` until it is empty.
+         */
+        pageSize?: number;
+        /**
+         * The previous page's `nextPageToken`. Omit for the first page.
+         */
+        pageToken?: string;
+        /**
+         * Include `enhancement.request` and `enhancement.response`. Default false.
+         */
+        enhancementIo?: boolean;
+        /**
+         * `BASE64` (default, legacy) or `OBJECT`; same as on `/api/v1/events`.
+         */
+        geometryFormat?: 'BASE64' | 'OBJECT';
+    };
+    url: '/api/v1/history';
+};
+export type GridServiceListHistoryErrors = {
+    /**
+     * INVALID_ARGUMENT: an unknown layer or geometryFormat, a timestamp that is not RFC 3339, a negative page size, or a bad page token.
+     */
+    400: RpcStatus;
+    /**
+     * NOT_FOUND: unknown place.
+     */
+    404: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceListHistoryError = GridServiceListHistoryErrors[keyof GridServiceListHistoryErrors];
+export type GridServiceListHistoryResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1EventRevisionList;
+};
+export type GridServiceListHistoryResponse = GridServiceListHistoryResponses[keyof GridServiceListHistoryResponses];
+export type ListMeshLinksData = {
+    body?: never;
+    headers?: {
+        /**
+         * An `ETag` from an earlier response, for a `304` revalidation.
+         */
+        'If-None-Match'?: string;
+    };
+    path?: never;
+    query?: {
+        /**
+         * Recency window for relay links: a positive Go duration. The documented
+         * choices are `24h`, `72h` (the default), `168h` and `720h`; any positive
+         * duration works (`90m`), and values above `9600h` (400 days) are
+         * clamped. Anything else (`abc`, `0`, `-1h`) is a `400
+         * INVALID_ARGUMENT`. `/api/v1/mesh/links` echoes the applied window in
+         * `window`.
+         *
+         */
+        window?: string;
+    };
+    url: '/api/v1/mesh/links';
+};
+export type ListMeshLinksErrors = {
+    /**
+     * `window` is not a positive Go duration (`abc`, `0`, `-1h`).
+     */
+    400: RpcStatus;
+    /**
+     * Server-side failure. The real error is logged, never sent.
+     */
+    500: RpcStatus;
+    /**
+     * The server is handing over to a new instance during a deploy. Retry after
+     * `Retry-After` seconds. Plain text, not JSON.
+     *
+     */
+    503: string;
+};
+export type ListMeshLinksError = ListMeshLinksErrors[keyof ListMeshLinksErrors];
+export type ListMeshLinksResponses = {
+    /**
+     * The links, possibly empty.
+     */
+    200: MeshLinkList;
+};
+export type ListMeshLinksResponse = ListMeshLinksResponses[keyof ListMeshLinksResponses];
+export type GridServiceGetMeshTelemetryData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Required. The node's public key (`Event.mesh.publicKey`) or its event id
+         * (`meshcore:{key}`), case-insensitive. 8 to 64 hex characters, even length:
+         * a monitor-only node known by a 16-character key prefix is valid. Anything
+         * else is a 400 INVALID_ARGUMENT. A well-formed key the archive does not know
+         * returns 200 with `coverage.samples: 0` and no samples.
+         */
+        node: string;
+        /**
+         * Window start, RFC 3339, inclusive. Default: 24 hours before `to`.
+         */
+        from?: string;
+        /**
+         * Window end, RFC 3339, exclusive. Default: now.
+         */
+        to?: string;
+    };
+    url: '/api/v1/mesh/telemetry';
+};
+export type GridServiceGetMeshTelemetryErrors = {
+    /**
+     * INVALID_ARGUMENT: `node` missing or not 8-64 even-length hex (optionally prefixed `meshcore:`), or `from` not before `to`.
+     */
+    400: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceGetMeshTelemetryError = GridServiceGetMeshTelemetryErrors[keyof GridServiceGetMeshTelemetryErrors];
+export type GridServiceGetMeshTelemetryResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1MeshTelemetryArchive;
+};
+export type GridServiceGetMeshTelemetryResponse = GridServiceGetMeshTelemetryResponses[keyof GridServiceGetMeshTelemetryResponses];
+export type GridServiceListPlacesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only places of this kind. Case-insensitive. EVAC_ZONE and SITE are accepted
+         * but no places of those kinds exist today. Default: every kind.
+         */
+        kind?: 'AREA' | 'COUNTY' | 'TOWN' | 'CORRIDOR' | 'EVAC_ZONE' | 'SITE';
+        /**
+         * Case-insensitive substring of the place name, e.g. `calav`.
+         */
+        q?: string;
+        /**
+         * `BASE64` (default, legacy) or `OBJECT` for each place's `geometry`; same
+         * as on `/api/v1/events`.
+         */
+        geometryFormat?: 'BASE64' | 'OBJECT';
+    };
+    url: '/api/v1/places';
+};
+export type GridServiceListPlacesErrors = {
+    /**
+     * INVALID_ARGUMENT: unknown kind or geometryFormat.
+     */
+    400: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceListPlacesError = GridServiceListPlacesErrors[keyof GridServiceListPlacesErrors];
+export type GridServiceListPlacesResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1PlaceList;
+};
+export type GridServiceListPlacesResponse = GridServiceListPlacesResponses[keyof GridServiceListPlacesResponses];
+export type GridServiceGetPlaceData = {
+    body?: never;
+    path: {
+        /**
+         * Place slug (`arnold`) or namespaced id (`town:arnold`).
+         */
+        place: string;
+    };
+    query?: {
+        /**
+         * `BASE64` (default, legacy) or `OBJECT`; same as on `/api/v1/events`.
+         */
+        geometryFormat?: 'BASE64' | 'OBJECT';
+    };
+    url: '/api/v1/places/{place}';
+};
+export type GridServiceGetPlaceErrors = {
+    /**
+     * INVALID_ARGUMENT: an unknown geometryFormat.
+     */
+    400: RpcStatus;
+    /**
+     * NOT_FOUND: unknown place.
+     */
+    404: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceGetPlaceError = GridServiceGetPlaceErrors[keyof GridServiceGetPlaceErrors];
+export type GridServiceGetPlaceResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1Place;
+};
+export type GridServiceGetPlaceResponse = GridServiceGetPlaceResponses[keyof GridServiceGetPlaceResponses];
+export type GetMapLayerData = {
+    body?: never;
+    headers?: {
+        /**
+         * An `ETag` from an earlier response, for a `304` revalidation.
+         */
+        'If-None-Match'?: string;
+    };
+    path: {
+        /**
+         * A place slug (`calaveras-county`, `ebbetts-pass`, `hwy4-murphys-arnold`)
+         * or namespaced id (`county:calaveras-county`). Slugs are globally unique.
+         * `GET /api/v1/places` lists them; `GET /api/v1/places:resolve` maps an
+         * address or lat/lng to the places containing it.
+         *
+         */
+        place: string;
+        /**
+         * Layer slug (lowercase).
+         */
+        layer: 'road_incident' | 'chain_control' | 'road_segment' | 'message_sign' | 'weather_alert' | 'fire_weather' | 'earthquake' | 'wildfire' | 'evacuation' | 'power' | 'mesh_node' | 'mesh_link' | 'camera';
+    };
+    query?: {
+        /**
+         * Recency window for relay links: a positive Go duration. The documented
+         * choices are `24h`, `72h` (the default), `168h` and `720h`; any positive
+         * duration works (`90m`), and values above `9600h` (400 days) are
+         * clamped. Anything else (`abc`, `0`, `-1h`) is a `400
+         * INVALID_ARGUMENT`. `/api/v1/mesh/links` echoes the applied window in
+         * `window`.
+         *
+         */
+        window?: string;
+    };
+    url: '/api/v1/places/{place}/map/{layer}.geojson';
+};
+export type GetMapLayerErrors = {
+    /**
+     * `window` is not a positive Go duration (`abc`, `0`, `-1h`).
+     */
+    400: RpcStatus;
+    /**
+     * Unknown place or unknown layer.
+     */
+    404: RpcStatus;
+    /**
+     * Server-side failure. The real error is logged, never sent.
+     */
+    500: RpcStatus;
+    /**
+     * A condition-backed layer is not wired in this deployment (never in production).
+     */
+    501: RpcStatus;
+    /**
+     * The server is handing over to a new instance during a deploy. Retry after
+     * `Retry-After` seconds. Plain text, not JSON.
+     *
+     */
+    503: string;
+};
+export type GetMapLayerError = GetMapLayerErrors[keyof GetMapLayerErrors];
+export type GetMapLayerResponses = {
+    /**
+     * The layer. Empty `features` is a valid answer; read `metadata.sourceStatus` to know whether it is confirmed-empty or unknown.
+     */
+    200: MapFeatureCollection;
+};
+export type GetMapLayerResponse = GetMapLayerResponses[keyof GetMapLayerResponses];
+export type GridServiceGetPlaceSummaryData = {
+    body?: never;
+    path: {
+        /**
+         * Place slug (`calaveras-county`) or namespaced id (`county:calaveras-county`).
+         */
+        place: string;
+    };
+    query?: never;
+    url: '/api/v1/places/{place}/summary';
+};
+export type GridServiceGetPlaceSummaryErrors = {
+    /**
+     * NOT_FOUND: unknown place.
+     */
+    404: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceGetPlaceSummaryError = GridServiceGetPlaceSummaryErrors[keyof GridServiceGetPlaceSummaryErrors];
+export type GridServiceGetPlaceSummaryResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1PlaceSummary;
+};
+export type GridServiceGetPlaceSummaryResponse = GridServiceGetPlaceSummaryResponses[keyof GridServiceGetPlaceSummaryResponses];
+export type GridServiceResolvePlaceData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Latitude in decimal degrees, -90 to 90. Requires `lng`.
+         */
+        lat?: number;
+        /**
+         * Longitude in decimal degrees, -180 to 180 (negative in California).
+         * Requires `lat`.
+         */
+        lng?: number;
+        /**
+         * A US street address, geocoded with the Census geocoder. Include the city,
+         * state or ZIP for a reliable match.
+         */
+        address?: string;
+        /**
+         * `BASE64` (default, legacy) or `OBJECT` for each place's `geometry`; same
+         * as on `/api/v1/events`.
+         */
+        geometryFormat?: 'BASE64' | 'OBJECT';
+    };
+    url: '/api/v1/places:resolve';
+};
+export type GridServiceResolvePlaceErrors = {
+    /**
+     * INVALID_ARGUMENT: neither or both of lat+lng and address, only one of lat/lng, a value out of range, or an unknown geometryFormat.
+     */
+    400: RpcStatus;
+    /**
+     * NOT_FOUND: the geocoder found no match for the address (add city, state or ZIP).
+     */
+    404: RpcStatus;
+    /**
+     * UNAVAILABLE: the address geocoder is down; retry later or resolve by lat/lng.
+     */
+    503: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceResolvePlaceError = GridServiceResolvePlaceErrors[keyof GridServiceResolvePlaceErrors];
+export type GridServiceResolvePlaceResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1ResolvePlaceResponse;
+};
+export type GridServiceResolvePlaceResponse = GridServiceResolvePlaceResponses[keyof GridServiceResolvePlaceResponses];
+export type GridServiceListScannersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * An AREA place (slug or id) returns that area's feeds. Any other place, or
+         * none, returns every feed.
+         */
+        place?: string;
+    };
+    url: '/api/v1/scanners';
+};
+export type GridServiceListScannersErrors = {
+    /**
+     * NOT_FOUND: unknown place.
+     */
+    404: RpcStatus;
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceListScannersError = GridServiceListScannersErrors[keyof GridServiceListScannersErrors];
+export type GridServiceListScannersResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1ScannerList;
+};
+export type GridServiceListScannersResponse = GridServiceListScannersResponses[keyof GridServiceListScannersResponses];
+export type GridServiceListSourcesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/sources';
+};
+export type GridServiceListSourcesErrors = {
+    /**
+     * An unexpected error response.
+     */
+    default: RpcStatus;
+};
+export type GridServiceListSourcesError = GridServiceListSourcesErrors[keyof GridServiceListSourcesErrors];
+export type GridServiceListSourcesResponses = {
+    /**
+     * A successful response.
+     */
+    200: V1SourceList;
+};
+export type GridServiceListSourcesResponse = GridServiceListSourcesResponses[keyof GridServiceListSourcesResponses];