@sierragridteam/sdk 0.0.0-stage → 0.1.0

package/dist/generated/zod.gen.js

@@ -0,0 +1,1849 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import * as z from 'zod';
+export const zBurnLineReading = z.object({
+    cleaned_transcription: z.string().optional(),
+    confidence: z.int().gte(0).lte(100).optional(),
+    line_id: z.string(),
+    message: z.string().optional(),
+    observed_at: z.iso.datetime(),
+    status: z.enum([
+        '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 const zBurnLineReport = z.object({
+    generated_at: z.iso.datetime().optional(),
+    readings: z.array(zBurnLineReading).min(1).max(1000),
+    schema_version: z.literal(1)
+});
+/**
+ * The 202 body. Validated and queued, not yet stored; it lands on the next ingest cycle (about a minute).
+ */
+export const zIngestAccepted = z.object({
+    accepted: z.int(),
+    receivedAt: z.iso.datetime(),
+    reporterId: z.string(),
+    stream: z.string(),
+    warnings: z.array(z.string()).optional()
+});
+/**
+ * A JSON-RPC 2.0 request. Omit `id` for a notification (answered 202, no body).
+ */
+export const zJsonRpcRequest = z.object({
+    id: z.unknown().optional(),
+    jsonrpc: z.enum(['2.0']),
+    method: z.enum([
+        'initialize',
+        'ping',
+        'tools/list',
+        'tools/call',
+        'resources/list',
+        'resources/read',
+        'prompts/list',
+        'prompts/get',
+        'notifications/initialized'
+    ]),
+    params: z.record(z.string(), z.unknown()).optional()
+});
+export const zJsonRpcResponse = z.object({
+    error: z.object({
+        code: z.int(),
+        message: z.string()
+    }).optional(),
+    id: z.unknown().optional(),
+    jsonrpc: z.enum(['2.0']),
+    result: z.record(z.string(), z.unknown()).optional()
+});
+/**
+ * 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 const zMapCameraProps = z.object({
+    county: z.string().optional(),
+    direction: z.string().optional(),
+    distanceMeters: z.int(),
+    elevationFeet: z.int().optional(),
+    imageRefreshMinutes: z.int().optional(),
+    imageUrl: z.string(),
+    route: z.string().optional(),
+    streamUrl: z.string().optional()
+});
+/**
+ * chain_control block. Severity follows the level (R1 MINOR, R2 MODERATE, R3 SEVERE); a seasonal pass closure (`category` closed) is MINOR.
+ */
+export const zMapChainControlProps = z.object({
+    direction: z.string().optional(),
+    highway: z.string().optional(),
+    level: z.enum([
+        'R1',
+        'R2',
+        'R3'
+    ]).optional()
+});
+/**
+ * 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 const zMapClosureProps = z.object({
+    closureType: z.string().optional(),
+    estimatedDelayMinutes: z.int().optional(),
+    lanesClosed: z.string().optional(),
+    plannedEnd: z.iso.datetime().optional(),
+    plannedStart: z.iso.datetime().optional(),
+    setUpAt: z.iso.datetime().optional(),
+    totalLanes: z.int().optional(),
+    windowId: z.string(),
+    workType: z.string().optional()
+});
+/**
+ * earthquake block (USGS).
+ */
+export const zMapEarthquakeProps = z.object({
+    depthKm: z.number(),
+    felt: z.int().optional(),
+    magnitude: z.number()
+});
+/**
+ * evacuation block (Cal OES / Genasys zones). Life-safety; reference only, link `source.url`.
+ */
+export const zMapEvacuationProps = z.object({
+    county: z.string().optional(),
+    eventType: z.string().optional(),
+    level: z.enum([
+        'ORDER',
+        'WARNING',
+        'ADVISORY',
+        'SHELTER_IN_PLACE'
+    ]),
+    zoneId: z.string().optional()
+});
+/**
+ * The upstream feed this feature came from. Render `attribution` with the feature.
+ */
+export const zMapFeatureSource = z.object({
+    attribution: z.string().optional(),
+    fetchedAt: z.iso.datetime().optional(),
+    id: z.string(),
+    name: z.string(),
+    url: z.string().optional()
+});
+/**
+ * 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 const zMapFireWeatherProps = z.object({
+    forecast: z.object({
+        horizonHours: z.int().optional(),
+        issuedAt: z.iso.datetime().optional(),
+        minHumidityPercent: z.int().optional(),
+        peakWindGustAt: z.iso.datetime().optional(),
+        peakWindGustKmh: z.int().optional(),
+        source: z.string().optional()
+    }).optional(),
+    sourceEvent: z.string().optional(),
+    state: z.enum([
+        'normal',
+        'elevated',
+        'red-flag'
+    ]).optional(),
+    zones: z.array(z.string()).optional()
+});
+/**
+ * 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 const zMapGeometry = z.object({
+    coordinates: z.array(z.unknown()),
+    type: z.enum([
+        'Point',
+        'MultiPoint',
+        'LineString',
+        'MultiLineString',
+        'Polygon',
+        'MultiPolygon'
+    ])
+}).nullable();
+/**
+ * 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 const zGeoJsonGeometry = zMapGeometry;
+/**
+ * road_incident block.
+ */
+export const zMapIncidentProps = z.object({
+    closure: zMapClosureProps.optional(),
+    logNumber: z.string().optional()
+});
+/**
+ * Provenance and freshness of the whole layer.
+ */
+export const zMapLayerMetadata = z.object({
+    area: z.string(),
+    attribution: z.string().optional(),
+    generatedAt: z.iso.datetime(),
+    lastSourceUpdate: z.iso.datetime().optional(),
+    layer: z.enum([
+        'road_incident',
+        'chain_control',
+        'road_segment',
+        'message_sign',
+        'weather_alert',
+        'fire_weather',
+        'earthquake',
+        'wildfire',
+        'evacuation',
+        'power',
+        'mesh_node',
+        'mesh_link',
+        'camera'
+    ]),
+    schemaVersion: z.literal(1),
+    sourceStatus: z.enum([
+        'OK',
+        'STALE',
+        'UNAVAILABLE'
+    ]),
+    sourceUrl: z.string().optional()
+});
+/**
+ * The last sample an operator monitor read off the node itself. Gauges the device did not report are absent, never 0.
+ */
+export const zMapMeshAdminProps = z.object({
+    airtimeMs: z.int().optional(),
+    batteryPercent: z.number().optional(),
+    batteryPercentSource: z.string().optional(),
+    batteryVolts: z.number().optional(),
+    lastSuccessAt: z.iso.datetime().optional(),
+    noiseFloorDbm: z.int().optional(),
+    packetsReceived: z.int().optional(),
+    packetsSent: z.int().optional(),
+    recvErrors: z.int().optional(),
+    reportedAt: z.iso.datetime().optional(),
+    reporterId: z.string(),
+    rxAirtimeMs: z.int().optional(),
+    temperatureC: z.number().optional(),
+    txQueueLen: z.int().optional(),
+    uptimeSeconds: z.int().optional()
+});
+/**
+ * mesh_link edge block - one undirected relay link between two located nodes. Weight by `daysActive`/`observations`, fade by `lastSeen`.
+ */
+export const zMapMeshLinkProps = z.object({
+    a: z.string(),
+    b: z.string(),
+    bestSnr: z.number().optional(),
+    daysActive: z.int(),
+    firstSeen: z.iso.datetime().optional(),
+    lastSeen: z.iso.datetime().optional(),
+    observations: z.int()
+});
+/**
+ * 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 const zMapMeshProps = z.object({
+    admin: zMapMeshAdminProps.optional(),
+    gateways: z.array(z.string()).optional(),
+    hopCount: z.int().optional(),
+    inRegion: z.boolean().optional(),
+    lastHeardAt: z.iso.datetime().optional(),
+    lastRelayedAt: z.iso.datetime().optional(),
+    name: z.string().optional(),
+    nodeType: z.enum([
+        'companion',
+        'repeater',
+        'room_server',
+        'sensor'
+    ]).optional(),
+    publicKey: z.string(),
+    reachability: z.enum(['REACHABLE', 'UNREACHABLE']).optional(),
+    rssi: z.int().optional(),
+    snr: z.number().optional()
+});
+/**
+ * message_sign block - what a Caltrans changeable message sign is showing, verbatim. Context, not a hazard.
+ */
+export const zMapMessageSignProps = z.object({
+    direction: z.string().optional(),
+    district: z.int(),
+    inService: z.boolean(),
+    pages: z.array(z.tuple([
+        z.string(),
+        z.string(),
+        z.string()
+    ])).optional(),
+    route: z.string().optional(),
+    signId: z.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 const zMapPowerProps = z.object({
+    allClear: z.iso.datetime().optional(),
+    cause: z.string().optional(),
+    crewStatus: z.string().optional(),
+    customersAffected: z.int().optional(),
+    deEnergizationEnd: z.iso.datetime().optional(),
+    deEnergizationStart: z.iso.datetime().optional(),
+    estimatedRestoration: z.iso.datetime().optional(),
+    eventName: z.string().optional(),
+    medicalBaselineAffected: z.int().optional(),
+    outageId: z.string().optional(),
+    stage: z.enum(['Watch', 'Warning']).optional()
+});
+/**
+ * road_segment block (Google Routes travel time over a configured route). The numbers are absent, not 0, until the route has been measured.
+ */
+export const zMapRoadProps = z.object({
+    congestion: z.enum([
+        'CLEAR',
+        'LIGHT',
+        'MODERATE',
+        'HEAVY',
+        'SEVERE',
+        'UNSPECIFIED'
+    ]).optional(),
+    delayMinutes: z.int().optional(),
+    distanceKm: z.int().optional(),
+    durationMinutes: z.int().optional(),
+    roadId: z.string()
+});
+/**
+ * weather_alert block. The NWS CAP fields are verbatim; `nwsSeverity` is NWS's own scale, distinct from the unified `severity`.
+ */
+export const zMapWeatherProps = z.object({
+    certainty: z.string().optional(),
+    event: z.string().optional(),
+    instruction: z.string().optional(),
+    nwsSeverity: z.enum([
+        'Extreme',
+        'Severe',
+        'Moderate',
+        'Minor',
+        'Unknown'
+    ]).optional(),
+    source: z.enum(['NWS']).optional(),
+    urgency: z.string().optional(),
+    zones: z.array(z.string()).optional()
+});
+/**
+ * wildfire block (CAL FIRE incidents and FIRIS perimeters).
+ */
+export const zMapWildfireProps = z.object({
+    acres: z.number().optional(),
+    cause: z.string().optional(),
+    containment: z.int().gte(0).lte(100),
+    county: z.string().optional(),
+    hasPerimeter: z.boolean()
+});
+/**
+ * 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 const zMapFeatureProperties = z.object({
+    areaLabel: z.string().optional(),
+    camera: zMapCameraProps.optional(),
+    category: z.string().optional(),
+    chainControl: zMapChainControlProps.optional(),
+    description: z.string().optional(),
+    earthquake: zMapEarthquakeProps.optional(),
+    effective: z.iso.datetime().optional(),
+    evacuation: zMapEvacuationProps.optional(),
+    expires: z.iso.datetime().optional(),
+    fireWeather: zMapFireWeatherProps.optional(),
+    headline: z.string(),
+    id: z.string(),
+    incident: zMapIncidentProps.optional(),
+    kind: z.enum([
+        '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'
+    ]),
+    layer: z.enum([
+        'ROAD_INCIDENT',
+        'CHAIN_CONTROL',
+        'ROAD_SEGMENT',
+        'MESSAGE_SIGN',
+        'WEATHER_ALERT',
+        'FIRE_WEATHER',
+        'EARTHQUAKE',
+        'WILDFIRE',
+        'EVACUATION',
+        'POWER',
+        'MESH_NODE',
+        'MESH_LINK',
+        'CAMERA'
+    ]),
+    mesh: zMapMeshProps.optional(),
+    meshLink: zMapMeshLinkProps.optional(),
+    messageSign: zMapMessageSignProps.optional(),
+    power: zMapPowerProps.optional(),
+    road: zMapRoadProps.optional(),
+    severity: z.enum([
+        'INFO',
+        'MINOR',
+        'MODERATE',
+        'SEVERE',
+        'EXTREME'
+    ]),
+    severityRank: z.int().gte(0).lte(4),
+    source: zMapFeatureSource,
+    status: z.enum([
+        'ACTIVE',
+        'SCHEDULED',
+        'ORDER',
+        'WARNING',
+        'ADVISORY',
+        'SHELTER_IN_PLACE',
+        'OPEN',
+        'CLOSED',
+        'RESTRICTED',
+        'MAINTENANCE',
+        'UNSPECIFIED'
+    ]).optional(),
+    summary: z.string().optional(),
+    summaryEnhanced: z.object({
+        enhancedAt: z.iso.datetime().optional()
+    }).optional(),
+    updatedAt: z.iso.datetime().optional(),
+    weather: zMapWeatherProps.optional(),
+    wildfire: zMapWildfireProps.optional()
+});
+/**
+ * An RFC 7946 Feature.
+ */
+export const zMapFeature = z.object({
+    geometry: zMapGeometry,
+    properties: zMapFeatureProperties,
+    type: z.enum(['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 const zMapFeatureCollection = z.object({
+    features: z.array(zMapFeature),
+    metadata: zMapLayerMetadata,
+    type: z.enum(['FeatureCollection'])
+});
+/**
+ * One undirected relay link. Every member is always present.
+ */
+export const zMeshLink = z.object({
+    a: z.string(),
+    b: z.string(),
+    bestSnr: z.number(),
+    daysActive: z.int(),
+    firstSeen: z.iso.datetime(),
+    lastSeen: z.iso.datetime(),
+    observations: z.int()
+});
+export const zMeshLinkList = z.object({
+    generatedAt: z.iso.datetime(),
+    links: z.array(zMeshLink),
+    window: z.string()
+});
+/**
+ * One reception. Extra bridge fields are accepted and ignored.
+ */
+export const zMeshPacket = z.object({
+    RSSI: z.unknown().optional(),
+    SNR: z.unknown().optional(),
+    origin_id: z.string().optional(),
+    packet_type: z.int(),
+    raw: z.string(),
+    timestamp: z.string().optional()
+});
+/**
+ * `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 const zMeshPacketReport = z.object({
+    generated_at: z.iso.datetime().optional(),
+    observer: z.string().regex(/^[0-9a-fA-F]{8,64}$/).optional(),
+    packets: z.array(zMeshPacket).max(1000),
+    schema_version: z.literal(1)
+});
+export const zMeshRepeaterReading = z.object({
+    airtime_ms: z.int().nullish(),
+    battery_percent: z.number().nullish(),
+    battery_percent_source: z.string().optional(),
+    battery_voltage: z.number().nullish(),
+    direct_dups: z.int().nullish(),
+    flood_dups: z.int().nullish(),
+    full_evts: z.int().nullish(),
+    humidity: z.number().nullish(),
+    id: z.string().regex(/^[0-9a-fA-F]{8,64}$/),
+    last_attempt: z.int().nullish(),
+    last_rssi_dbm: z.int().nullish(),
+    last_snr_db: z.number().nullish(),
+    last_success: z.int().nullish(),
+    name: z.string().optional(),
+    nb_recv: z.int().nullish(),
+    nb_sent: z.int().nullish(),
+    noise_floor_dbm: z.int().nullish(),
+    online: z.boolean().nullish(),
+    pressure: z.number().nullish(),
+    recv_direct: z.int().nullish(),
+    recv_errors: z.int().nullish(),
+    recv_flood: z.int().nullish(),
+    rx_airtime_ms: z.int().nullish(),
+    sent_direct: z.int().nullish(),
+    sent_flood: z.int().nullish(),
+    temperature_c: z.number().nullish(),
+    tx_queue_len: z.int().nullish(),
+    uptime_s: z.int().nullish()
+});
+/**
+ * `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 const zMeshRepeaterReport = z.object({
+    generated_at: z.iso.datetime().optional(),
+    repeaters: z.array(zMeshRepeaterReading).max(1000),
+    schema_version: z.literal(1)
+});
+export const zProtobufAny = z.object({
+    '@type': z.string().optional()
+});
+/**
+ * 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 const zRpcStatus = z.object({
+    code: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
+    codeName: z.enum([
+        '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'
+    ]).optional(),
+    details: z.array(zProtobufAny).optional(),
+    message: z.string().optional()
+});
+/**
+ * BoundingBox is a WGS 84 bounding box in decimal degrees.
+ */
+export const zV1BoundingBox = z.object({
+    maxLat: z.number(),
+    maxLng: z.number(),
+    minLat: z.number(),
+    minLng: z.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 const zV1BurnDay = z.enum([
+    'BURN_DAY_UNKNOWN',
+    'BURN_DAY_YES',
+    'BURN_DAY_NO',
+    'BURN_DAY_MARGINAL'
+]).default('BURN_DAY_UNKNOWN');
+/**
+ * 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 const zV1BurnObservation = z.object({
+    confidence: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    message: z.string(),
+    observedAt: z.iso.datetime(),
+    transcript: z.string()
+});
+/**
+ * BurnLineReading is one recorded phone line's answer for today.
+ */
+export const zV1BurnLineReading = z.object({
+    burnDay: zV1BurnDay,
+    id: z.string(),
+    name: z.string(),
+    observation: zV1BurnObservation.nullable(),
+    phone: z.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 const zV1BurnPermission = z.enum([
+    'BURN_PERMISSION_UNKNOWN',
+    'BURN_PERMISSION_ALLOWED',
+    'BURN_PERMISSION_PROHIBITED'
+]).default('BURN_PERMISSION_UNKNOWN');
+/**
+ * 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 const zV1CalfireBurnStatus = z.enum([
+    'CALFIRE_BURN_STATUS_UNKNOWN',
+    'CALFIRE_BURNING_SUSPENDED',
+    'CALFIRE_PERMIT_REQUIRED',
+    'CALFIRE_NO_PERMIT_REQUIRED'
+]).default('CALFIRE_BURN_STATUS_UNKNOWN');
+/**
+ * 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 const zV1BurnStatusDetail = z.object({
+    burnDay: zV1BurnDay,
+    burnLines: z.array(zV1BurnLineReading),
+    calfireArea: z.string(),
+    calfireEffective: z.iso.datetime().nullable(),
+    calfireObservedAt: z.iso.datetime().nullable(),
+    calfireStatus: zV1CalfireBurnStatus,
+    permission: zV1BurnPermission
+});
+/**
+ * EarthquakeDetail is the EARTHQUAKE detail block. The USGS event page is the
+ * envelope `canonicalUrl`.
+ */
+export const zV1EarthquakeDetail = z.object({
+    depthKm: z.number(),
+    felt: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    magnitude: z.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 const zV1Enhancement = z.object({
+    enhancedAt: z.iso.datetime().nullable(),
+    fields: z.array(z.string()),
+    model: z.string(),
+    request: z.string(),
+    response: z.string()
+});
+/**
+ * EvacuationDetail is the EVACUATION detail block, one Cal OES / Genasys zone.
+ */
+export const zV1EvacuationDetail = z.object({
+    county: z.string(),
+    eventType: z.string(),
+    level: z.enum([
+        'ORDER',
+        'WARNING',
+        'ADVISORY',
+        'SHELTER_IN_PLACE'
+    ]),
+    zoneId: z.string()
+});
+/**
+ * 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 const zV1EventStatus = z.enum([
+    'EVENT_STATUS_UNSPECIFIED',
+    'SCHEDULED',
+    'ACTIVE',
+    'RESOLVED',
+    'EXPIRED'
+]).default('EVENT_STATUS_UNSPECIFIED');
+/**
+ * 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 const zV1FireWeatherConditions = z.object({
+    headline: z.string(),
+    state: z.enum([
+        'normal',
+        'elevated',
+        'red-flag',
+        ''
+    ]),
+    zones: z.array(z.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 const zV1FireWeatherDetail = z.object({
+    sourceEvent: z.string(),
+    state: z.enum([
+        'normal',
+        'elevated',
+        'red-flag'
+    ]),
+    zones: z.array(z.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 const zV1ForecastPeriod = z.object({
+    humidityPercent: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    temperatureCelsius: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    time: z.iso.datetime().nullable(),
+    windDirectionDegrees: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    windGustKmh: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    windSpeedKmh: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
+});
+/**
+ * LatLng is one WGS 84 point in decimal degrees. Note the order: unlike GeoJSON
+ * coordinates, this is latitude first.
+ */
+export const zV1LatLng = z.object({
+    lat: z.number(),
+    lng: z.number()
+});
+/**
+ * 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 const zV1Camera = z.object({
+    county: z.string(),
+    description: z.string(),
+    direction: z.enum([
+        '',
+        'North',
+        'South',
+        'East',
+        'West'
+    ]),
+    distanceMeters: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    elevationFeet: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    id: z.string(),
+    imageRefreshMinutes: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    imageUrl: z.string(),
+    location: zV1LatLng,
+    name: z.string(),
+    nearbyPlace: z.string(),
+    route: z.string(),
+    streamUrl: z.string()
+});
+/**
+ * CameraList is the camera directory.
+ */
+export const zV1CameraList = z.object({
+    attribution: z.string(),
+    cameras: z.array(zV1Camera),
+    lastSourceUpdate: z.iso.datetime().nullable(),
+    sourceStatus: z.enum([
+        'OK',
+        'STALE',
+        'UNAVAILABLE'
+    ])
+});
+/**
+ * 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 const zV1Geometry = z.object({
+    bbox: zV1BoundingBox,
+    centroid: zV1LatLng,
+    geojson: z.string(),
+    object: zGeoJsonGeometry.optional()
+});
+/**
+ * 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 const zV1LaneClosureDetail = z.object({
+    begin: zV1LatLng.nullable(),
+    beginLocation: z.string(),
+    closureDuration: z.enum([
+        'Standard',
+        'Long Term',
+        'Intermittent'
+    ]),
+    closureId: z.string(),
+    closureType: z.string(),
+    direction: z.string(),
+    district: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    end: zV1LatLng.nullable(),
+    endIndefinite: z.boolean(),
+    endLocation: z.string(),
+    estimatedDelayMinutes: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    facility: z.string(),
+    lanesClosed: z.string(),
+    logNumber: z.string(),
+    plannedEnd: z.iso.datetime().nullable(),
+    plannedStart: z.iso.datetime(),
+    route: z.string(),
+    setUpAt: z.iso.datetime().nullable(),
+    totalLanes: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    windowId: z.string(),
+    workType: z.string()
+});
+/**
+ * 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 const zV1Layer = z.enum([
+    'LAYER_UNSPECIFIED',
+    'WILDFIRE',
+    'EVACUATION',
+    'WEATHER_ALERT',
+    'FIRE_WEATHER',
+    'EARTHQUAKE',
+    'ROAD_INCIDENT',
+    'POWER',
+    'GAUGE',
+    'AIR_QUALITY',
+    'MESH',
+    'ANNOUNCEMENT',
+    'BURN_STATUS'
+]).default('LAYER_UNSPECIFIED');
+/**
+ * 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 const zV1MeshAdminTelemetry = z.object({
+    airtimeMs: z.string().regex(/^-?[0-9]+$/),
+    batteryPercent: z.number().nullable(),
+    batteryPercentSource: z.enum([
+        '',
+        'measured',
+        'estimated'
+    ]),
+    batteryVolts: z.number().nullable(),
+    directDups: z.string().regex(/^-?[0-9]+$/),
+    floodDups: z.string().regex(/^-?[0-9]+$/),
+    fullEvents: z.string().regex(/^-?[0-9]+$/),
+    humidity: z.number().nullable(),
+    lastAttemptAt: z.iso.datetime().nullable(),
+    lastRssiDbm: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).nullable(),
+    lastSnrDb: z.number().nullable(),
+    lastSuccessAt: z.iso.datetime().nullable(),
+    noiseFloorDbm: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).nullable(),
+    packetsReceived: z.string().regex(/^-?[0-9]+$/),
+    packetsSent: z.string().regex(/^-?[0-9]+$/),
+    pressure: z.number().nullable(),
+    recvDirect: z.string().regex(/^-?[0-9]+$/),
+    recvErrors: z.string().regex(/^-?[0-9]+$/),
+    recvFlood: z.string().regex(/^-?[0-9]+$/),
+    reportedAt: z.iso.datetime().nullable(),
+    reporterId: z.string(),
+    rxAirtimeMs: z.string().regex(/^-?[0-9]+$/),
+    sentDirect: z.string().regex(/^-?[0-9]+$/),
+    sentFlood: z.string().regex(/^-?[0-9]+$/),
+    temperatureC: z.number().nullable(),
+    txQueueLen: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).nullable(),
+    uptimeSeconds: z.string().regex(/^-?[0-9]+$/)
+});
+/**
+ * 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 const zV1MeshReachability = z.enum([
+    'MESH_REACHABILITY_UNSPECIFIED',
+    'REACHABLE',
+    'UNREACHABLE'
+]).default('MESH_REACHABILITY_UNSPECIFIED');
+/**
+ * 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 const zV1MeshTelemetry = z.object({
+    admin: zV1MeshAdminTelemetry.nullable(),
+    gateways: z.array(z.string()),
+    hopCount: z.int().nullable(),
+    lastAdvertAt: z.iso.datetime().nullable(),
+    lastHeardAt: z.iso.datetime().nullable(),
+    lastRelayedAt: z.iso.datetime().nullable(),
+    rssi: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).nullable(),
+    snr: z.number().nullable()
+});
+/**
+ * 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 const zV1MeshDetail = z.object({
+    name: z.string(),
+    nodeType: z.enum([
+        'companion',
+        'repeater',
+        'room_server',
+        'sensor'
+    ]),
+    publicKey: z.string().regex(/^[0-9a-f]{64}$/),
+    reachability: zV1MeshReachability,
+    telemetry: zV1MeshTelemetry.nullable()
+});
+/**
+ * MeshTelemetryCoverage is the span of the whole archive for one node.
+ */
+export const zV1MeshTelemetryCoverage = z.object({
+    from: z.iso.datetime().nullable(),
+    samples: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    to: z.iso.datetime().nullable()
+});
+/**
+ * MeshTelemetrySample is one archived report.
+ *
+ */
+export const zV1MeshTelemetrySample = z.object({
+    reading: zV1MeshAdminTelemetry,
+    receivedAt: z.iso.datetime()
+});
+/**
+ * MeshTelemetryArchive is one node's samples over a window, with what a chart
+ * needs in order not to lie about them.
+ */
+export const zV1MeshTelemetryArchive = z.object({
+    cadenceSeconds: z.string().regex(/^-?[0-9]+$/).nullable(),
+    coverage: zV1MeshTelemetryCoverage,
+    from: z.iso.datetime(),
+    node: z.string(),
+    reboots: z.array(z.iso.datetime()),
+    samples: z.array(zV1MeshTelemetrySample),
+    to: z.iso.datetime(),
+    truncated: z.boolean()
+});
+/**
+ * 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 const zV1PlaceKind = z.enum([
+    'PLACE_KIND_UNSPECIFIED',
+    'AREA',
+    'COUNTY',
+    'TOWN',
+    'EVAC_ZONE',
+    'CORRIDOR',
+    'SITE'
+]).default('PLACE_KIND_UNSPECIFIED');
+/**
+ * Place is a named geography that events attach to.
+ */
+export const zV1Place = z.object({
+    geometry: zV1Geometry,
+    id: z.string(),
+    kind: zV1PlaceKind,
+    name: z.string(),
+    parentId: z.string(),
+    slug: z.string()
+});
+/**
+ * PlaceList is the place directory.
+ */
+export const zV1PlaceList = z.object({
+    places: z.array(zV1Place)
+});
+/**
+ * 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 const zV1PowerDetail = z.object({
+    allClear: z.iso.datetime().nullable(),
+    cause: z.string(),
+    crewStatus: z.string(),
+    customersAffected: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    deEnergizationEnd: z.iso.datetime().nullable(),
+    deEnergizationStart: z.iso.datetime().nullable(),
+    estimatedRestoration: z.iso.datetime().nullable(),
+    eventId: z.string(),
+    eventName: z.string(),
+    medicalBaselineAffected: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    outageId: z.string(),
+    stage: z.enum([
+        '',
+        'Watch',
+        'Warning'
+    ]),
+    timePeriod: z.string()
+});
+/**
+ * Provenance says which upstream published an event. Show `attribution` next to
+ * the data.
+ */
+export const zV1Provenance = z.object({
+    attribution: z.string(),
+    fetchedAt: z.iso.datetime(),
+    sourceId: z.enum([
+        'calfire',
+        'firis',
+        'caloes',
+        'nws',
+        'usgs',
+        'chp',
+        'caltrans',
+        'pge',
+        'psps',
+        'meshcore',
+        'burnline',
+        'calfire-burn'
+    ]),
+    sourceName: z.string(),
+    sourceUrl: z.string()
+});
+/**
+ * ResolveQuery echoes the point that was resolved.
+ */
+export const zV1ResolveQuery = z.object({
+    lat: z.number(),
+    lng: z.number(),
+    matchedAddress: z.string()
+});
+/**
+ * ResolvePlaceResponse lists the places containing a point.
+ */
+export const zV1ResolvePlaceResponse = z.object({
+    places: z.array(zV1Place),
+    query: zV1ResolveQuery
+});
+/**
+ * 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 const zV1RoadIncidentDetail = z.object({
+    closure: zV1LaneClosureDetail.nullable(),
+    duration: z.enum([
+        '',
+        'unknown',
+        '< 1 hour',
+        'several hours',
+        'ongoing'
+    ]),
+    impact: z.enum([
+        '',
+        'none',
+        'light',
+        'moderate',
+        'severe'
+    ]),
+    logNumber: z.string(),
+    metadata: z.record(z.string(), z.string())
+});
+/**
+ * Scanner is one Broadcastify audio feed.
+ */
+export const zV1Scanner = z.object({
+    agency: z.string(),
+    broadcastifyUrl: z.string(),
+    channelLabel: z.string(),
+    feedId: z.string()
+});
+/**
+ * ScannerList is the scanner feeds.
+ */
+export const zV1ScannerList = z.object({
+    scanners: z.array(zV1Scanner)
+});
+/**
+ * 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 const zV1Severity = z.enum([
+    'INFO',
+    'MINOR',
+    'MODERATE',
+    'SEVERE',
+    'EXTREME'
+]).default('INFO');
+/**
+ * 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 const zV1SourceKind = z.enum([
+    'SOURCE_KIND_UNSPECIFIED',
+    'FEED',
+    'REPORTER'
+]).default('SOURCE_KIND_UNSPECIFIED');
+/**
+ * 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 const zV1SourceStatus = z.enum([
+    'SOURCE_STATUS_UNSPECIFIED',
+    'OK',
+    'STALE',
+    'UNAVAILABLE'
+]).default('SOURCE_STATUS_UNSPECIFIED');
+/**
+ * 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 const zV1Source = z.object({
+    attribution: z.string(),
+    expireAfterSeconds: z.int(),
+    homepageUrl: z.string(),
+    id: z.string(),
+    kind: zV1SourceKind,
+    lastAttemptAt: z.iso.datetime().nullable(),
+    lastError: z.string(),
+    lastSuccessAt: z.iso.datetime().nullable(),
+    name: z.string(),
+    pollIntervalSeconds: z.int(),
+    staleAfterSeconds: z.int(),
+    status: zV1SourceStatus
+});
+/**
+ * SourceList is the source registry.
+ */
+export const zV1SourceList = z.object({
+    sources: z.array(zV1Source)
+});
+/**
+ * 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 const zV1SummaryDomainHeadline = z.object({
+    headline: z.string(),
+    id: z.string(),
+    kind: z.enum(['EVENT', 'CONDITION']),
+    layer: z.enum([
+        'WILDFIRE',
+        'EVACUATION',
+        'WEATHER_ALERT',
+        'EARTHQUAKE',
+        'ROAD_INCIDENT',
+        'POWER',
+        'MESH',
+        'BURN_STATUS',
+        'ROAD_SEGMENT',
+        'CHAIN_CONTROL',
+        'FIRE_WEATHER'
+    ]),
+    severity: z.enum([
+        'INFO',
+        'MINOR',
+        'MODERATE',
+        'SEVERE',
+        'EXTREME'
+    ])
+});
+/**
+ * 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 const zV1SummaryDomain = z.object({
+    activeCount: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    domain: z.enum([
+        'fire',
+        'evacuation',
+        'weather',
+        'roads',
+        'seismic',
+        'power',
+        'burn',
+        'comms'
+    ]),
+    headlines: z.array(zV1SummaryDomainHeadline),
+    highestSeverity: z.enum([
+        'INFO',
+        'MINOR',
+        'MODERATE',
+        'SEVERE',
+        'EXTREME'
+    ]),
+    status: z.enum([
+        'OK',
+        'STALE',
+        'UNAVAILABLE'
+    ])
+});
+/**
+ * SummarySourceHealth is one source registry row behind the summary's layers.
+ */
+export const zV1SummarySourceHealth = z.object({
+    id: z.string(),
+    lastSuccessAt: z.iso.datetime().nullable(),
+    status: z.enum([
+        'OK',
+        'STALE',
+        'UNAVAILABLE'
+    ])
+});
+/**
+ * SummaryTopEvent is one of the place's most urgent hazard events.
+ */
+export const zV1SummaryTopEvent = z.object({
+    headline: z.string(),
+    id: z.string(),
+    layer: z.enum([
+        'WILDFIRE',
+        'EVACUATION',
+        'WEATHER_ALERT',
+        'EARTHQUAKE',
+        'ROAD_INCIDENT',
+        'POWER'
+    ]),
+    severity: z.enum([
+        'INFO',
+        'MINOR',
+        'MODERATE',
+        'SEVERE',
+        'EXTREME'
+    ]),
+    severityRank: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    source: z.string()
+});
+/**
+ * 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 const zV1SummaryStats = z.object({
+    activeEvacuations: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).nullable(),
+    evacuationSourceUrl: z.string(),
+    evacuationStatus: z.enum([
+        'OK',
+        'STALE',
+        'UNAVAILABLE'
+    ]),
+    highestSeverity: z.enum([
+        'INFO',
+        'MINOR',
+        'MODERATE',
+        'SEVERE',
+        'EXTREME'
+    ]),
+    highestSeverityRank: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).lte(4),
+    severityCounts: z.record(z.string(), z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
+    topEvents: z.array(zV1SummaryTopEvent),
+    totalActive: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
+});
+/**
+ * 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 const zV1PlaceSummary = z.object({
+    domains: z.array(zV1SummaryDomain),
+    generatedAt: z.iso.datetime(),
+    mode: z.enum([
+        'QUIET',
+        'WATCH',
+        'ACTIVE'
+    ]),
+    place: z.string(),
+    placeId: z.string(),
+    placeName: z.string(),
+    sources: z.array(zV1SummarySourceHealth),
+    summary: zV1SummaryStats
+});
+/**
+ * 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 const zV1WeatherAlertDetail = z.object({
+    areaDesc: z.string(),
+    certainty: z.enum([
+        'Observed',
+        'Likely',
+        'Possible',
+        'Unlikely',
+        'Unknown'
+    ]),
+    instruction: z.string(),
+    nwsSeverity: z.enum([
+        'Extreme',
+        'Severe',
+        'Moderate',
+        'Minor',
+        'Unknown'
+    ]),
+    urgency: z.enum([
+        'Immediate',
+        'Expected',
+        'Future',
+        'Past',
+        'Unknown'
+    ]),
+    zones: z.array(z.string())
+});
+/**
+ * WeatherConditions is current weather at one location, from OpenWeatherMap.
+ * Whole numbers, metric units. A value that could not be read is 0.
+ */
+export const zV1WeatherConditions = z.object({
+    feelsLikeCelsius: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    humidityPercent: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    locationId: z.string(),
+    locationName: z.string(),
+    temperatureCelsius: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    visibilityKm: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    weatherDescription: z.string(),
+    weatherIcon: z.string(),
+    weatherMain: z.string(),
+    windDirectionDegrees: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    windSpeedKmh: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
+});
+/**
+ * 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 const zV1WeatherForecast = z.object({
+    horizonHours: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    issuedAt: z.iso.datetime().nullable(),
+    locationId: z.string(),
+    minHumidityPercent: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    peakWindGustAt: z.iso.datetime().nullable(),
+    peakWindGustKmh: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    periods: z.array(zV1ForecastPeriod),
+    source: z.string()
+});
+/**
+ * Conditions is current, non-event state.
+ */
+export const zV1Conditions = z.object({
+    fireWeather: zV1FireWeatherConditions.nullable(),
+    forecast: z.array(zV1WeatherForecast),
+    lastUpdated: z.iso.datetime().nullable(),
+    weather: z.array(zV1WeatherConditions)
+});
+/**
+ * WildfireDetail is the WILDFIRE detail block.
+ */
+export const zV1WildfireDetail = z.object({
+    acres: z.number(),
+    cause: z.string(),
+    containment: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    county: z.string(),
+    hasPerimeter: z.boolean()
+});
+/**
+ * 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 const zV1Event = z.object({
+    areaLabel: z.string(),
+    burnStatus: zV1BurnStatusDetail.optional(),
+    canonicalUrl: z.string(),
+    category: z.string(),
+    description: z.string(),
+    earthquake: zV1EarthquakeDetail.optional(),
+    effective: z.iso.datetime().nullable(),
+    enhancement: zV1Enhancement.nullable(),
+    evacuation: zV1EvacuationDetail.optional(),
+    expires: z.iso.datetime().nullable(),
+    fireWeather: zV1FireWeatherDetail.optional(),
+    geometry: zV1Geometry.nullable(),
+    headline: z.string(),
+    id: z.string(),
+    ingestedAt: z.iso.datetime(),
+    layer: zV1Layer,
+    mesh: zV1MeshDetail.optional(),
+    observedAt: z.iso.datetime().nullable(),
+    placeIds: z.array(z.string()),
+    power: zV1PowerDetail.optional(),
+    provenance: zV1Provenance,
+    revision: z.int(),
+    roadIncident: zV1RoadIncidentDetail.optional(),
+    severity: zV1Severity,
+    status: zV1EventStatus,
+    summary: z.string(),
+    weatherAlert: zV1WeatherAlertDetail.optional(),
+    wildfire: zV1WildfireDetail.optional()
+});
+/**
+ * EventList is one page of events.
+ */
+export const zV1EventList = z.object({
+    events: z.array(zV1Event),
+    nextPageToken: z.string()
+});
+/**
+ * EventRevision is one stored snapshot of an event.
+ */
+export const zV1EventRevision = z.object({
+    event: zV1Event,
+    ingestedAt: z.iso.datetime(),
+    observedAt: z.iso.datetime(),
+    revision: z.int()
+});
+/**
+ * EventRevisionList is one page of revisions.
+ */
+export const zV1EventRevisionList = z.object({
+    nextPageToken: z.string(),
+    revisions: z.array(zV1EventRevision)
+});
+/**
+ * An `ETag` from an earlier response, for a `304` revalidation.
+ */
+export const zIfNoneMatch = z.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 const zMeshWindow = z.string().default('72h');
+/**
+ * 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 const zPlace = z.string();
+export const zGridServiceListCamerasQuery = z.object({
+    place: z.string().optional()
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceListCamerasResponse = zV1CameraList;
+export const zGridServiceGetConditionsQuery = z.object({
+    place: z.string().optional()
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceGetConditionsResponse = zV1Conditions;
+export const zGridServiceListEventsQuery = z.object({
+    place: z.string().optional(),
+    layer: z.array(z.enum([
+        'WILDFIRE',
+        'EVACUATION',
+        'WEATHER_ALERT',
+        'EARTHQUAKE',
+        'ROAD_INCIDENT',
+        'POWER',
+        'MESH',
+        'BURN_STATUS'
+    ])).optional(),
+    status: z.array(z.enum([
+        'ACTIVE',
+        'SCHEDULED',
+        'RESOLVED',
+        'EXPIRED'
+    ])).optional(),
+    severityMin: z.enum([
+        'INFO',
+        'MINOR',
+        'MODERATE',
+        'SEVERE',
+        'EXTREME'
+    ]).optional(),
+    since: z.iso.datetime().optional(),
+    pageSize: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
+    pageToken: z.string().optional(),
+    enhancementIo: z.boolean().optional(),
+    geometryFormat: z.enum(['BASE64', 'OBJECT']).optional().default('BASE64')
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceListEventsResponse = zV1EventList;
+export const zGridServiceGetEventPath = z.object({
+    id: z.string()
+});
+export const zGridServiceGetEventQuery = z.object({
+    enhancementIo: z.boolean().optional(),
+    geometryFormat: z.enum(['BASE64', 'OBJECT']).optional().default('BASE64')
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceGetEventResponse = zV1Event;
+export const zGridServiceGetEventHistoryPath = z.object({
+    id: z.string()
+});
+export const zGridServiceGetEventHistoryQuery = z.object({
+    pageSize: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
+    pageToken: z.string().optional(),
+    enhancementIo: z.boolean().optional(),
+    geometryFormat: z.enum(['BASE64', 'OBJECT']).optional().default('BASE64')
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceGetEventHistoryResponse = zV1EventRevisionList;
+export const zGridServiceListHistoryQuery = z.object({
+    place: z.string().optional(),
+    layer: z.array(z.enum([
+        'WILDFIRE',
+        'EVACUATION',
+        'WEATHER_ALERT',
+        'EARTHQUAKE',
+        'ROAD_INCIDENT',
+        'POWER',
+        'MESH',
+        'BURN_STATUS'
+    ])).optional(),
+    from: z.iso.datetime().optional(),
+    to: z.iso.datetime().optional(),
+    pageSize: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
+    pageToken: z.string().optional(),
+    enhancementIo: z.boolean().optional(),
+    geometryFormat: z.enum(['BASE64', 'OBJECT']).optional().default('BASE64')
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceListHistoryResponse = zV1EventRevisionList;
+export const zListMeshLinksHeaders = z.object({
+    'If-None-Match': z.string().optional()
+});
+export const zListMeshLinksQuery = z.object({
+    window: z.string().optional().default('72h')
+});
+/**
+ * The links, possibly empty.
+ */
+export const zListMeshLinksResponse = zMeshLinkList;
+export const zGridServiceGetMeshTelemetryQuery = z.object({
+    node: z.string().regex(/^([mM][eE][sS][hH][cC][oO][rR][eE]:)?([0-9a-fA-F]{2}){4,32}$/),
+    from: z.iso.datetime().optional(),
+    to: z.iso.datetime().optional()
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceGetMeshTelemetryResponse = zV1MeshTelemetryArchive;
+export const zGridServiceListPlacesQuery = z.object({
+    kind: z.enum([
+        'AREA',
+        'COUNTY',
+        'TOWN',
+        'CORRIDOR',
+        'EVAC_ZONE',
+        'SITE'
+    ]).optional(),
+    q: z.string().optional(),
+    geometryFormat: z.enum(['BASE64', 'OBJECT']).optional().default('BASE64')
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceListPlacesResponse = zV1PlaceList;
+export const zGridServiceGetPlacePath = z.object({
+    place: z.string()
+});
+export const zGridServiceGetPlaceQuery = z.object({
+    geometryFormat: z.enum(['BASE64', 'OBJECT']).optional().default('BASE64')
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceGetPlaceResponse = zV1Place;
+export const zGetMapLayerHeaders = z.object({
+    'If-None-Match': z.string().optional()
+});
+export const zGetMapLayerPath = z.object({
+    place: z.string(),
+    layer: z.enum([
+        'road_incident',
+        'chain_control',
+        'road_segment',
+        'message_sign',
+        'weather_alert',
+        'fire_weather',
+        'earthquake',
+        'wildfire',
+        'evacuation',
+        'power',
+        'mesh_node',
+        'mesh_link',
+        'camera'
+    ])
+});
+export const zGetMapLayerQuery = z.object({
+    window: z.string().optional().default('72h')
+});
+/**
+ * The layer. Empty `features` is a valid answer; read `metadata.sourceStatus` to know whether it is confirmed-empty or unknown.
+ */
+export const zGetMapLayerResponse = zMapFeatureCollection;
+export const zGridServiceGetPlaceSummaryPath = z.object({
+    place: z.string()
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceGetPlaceSummaryResponse = zV1PlaceSummary;
+export const zGridServiceResolvePlaceQuery = z.object({
+    lat: z.number().optional(),
+    lng: z.number().optional(),
+    address: z.string().optional(),
+    geometryFormat: z.enum(['BASE64', 'OBJECT']).optional().default('BASE64')
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceResolvePlaceResponse = zV1ResolvePlaceResponse;
+export const zGridServiceListScannersQuery = z.object({
+    place: z.string().optional()
+});
+/**
+ * A successful response.
+ */
+export const zGridServiceListScannersResponse = zV1ScannerList;
+/**
+ * A successful response.
+ */
+export const zGridServiceListSourcesResponse = zV1SourceList;