@empressaio/atom-contract 1.10.0 → 1.12.0

package/dist/property/road-node.d.ts

@@ -0,0 +1,694 @@
+import { z } from "zod";
+import type { AccessPolicy } from "../registration.js";
+import type { AtomTier } from "../conformance/common.js";
+import type { ReasoningChain } from "../reasoning-chain.js";
+import type { ReasoningReadContract } from "../read-contract/reasoning-axes.js";
+/** v1 road hierarchy (27c WDLL 3 / R1). */
+export type RoadClassification = "highway" | "major_collector" | "minor_collector" | "residential" | "alley" | "gravel" | "unclassified";
+export declare const ROAD_CLASSIFICATION_VALUES: ReadonlyArray<RoadClassification>;
+export declare const ROAD_CLASSIFICATION_SCHEMA: z.ZodEnum<["highway", "major_collector", "minor_collector", "residential", "alley", "gravel", "unclassified"]>;
+export declare const ROAD_CENTERLINE_SCHEMA: z.ZodObject<{
+    type: z.ZodLiteral<"LineString">;
+    coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "LineString";
+    coordinates: [number, number][];
+}, {
+    type: "LineString";
+    coordinates: [number, number][];
+}>;
+export type RoadCenterline = z.infer<typeof ROAD_CENTERLINE_SCHEMA>;
+export declare const ROW_PROVENANCE_KIND: "approximate-assumed-per-class";
+export declare const ROW_PROVENANCE_SCHEMA: z.ZodObject<{
+    kind: z.ZodLiteral<"approximate-assumed-per-class">;
+    /** Descriptor table key used for assumed width (jurisdiction knowledge). */
+    assumedWidthTableKey: z.ZodString;
+    osmHighwayTag: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "approximate-assumed-per-class";
+    assumedWidthTableKey: string;
+    osmHighwayTag: string;
+    note?: string | undefined;
+}, {
+    kind: "approximate-assumed-per-class";
+    assumedWidthTableKey: string;
+    osmHighwayTag: string;
+    note?: string | undefined;
+}>;
+export type RowProvenance = z.infer<typeof ROW_PROVENANCE_SCHEMA>;
+export declare const ROAD_ROW_SCHEMA: z.ZodObject<{
+    assumedWidthFt: z.ZodNumber;
+    provenance: z.ZodObject<{
+        kind: z.ZodLiteral<"approximate-assumed-per-class">;
+        /** Descriptor table key used for assumed width (jurisdiction knowledge). */
+        assumedWidthTableKey: z.ZodString;
+        osmHighwayTag: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "approximate-assumed-per-class";
+        assumedWidthTableKey: string;
+        osmHighwayTag: string;
+        note?: string | undefined;
+    }, {
+        kind: "approximate-assumed-per-class";
+        assumedWidthTableKey: string;
+        osmHighwayTag: string;
+        note?: string | undefined;
+    }>;
+    /** Offset polylines from centerline + assumed half-width (v1 approximate). */
+    leftEdge: z.ZodObject<{
+        type: z.ZodLiteral<"LineString">;
+        coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "LineString";
+        coordinates: [number, number][];
+    }, {
+        type: "LineString";
+        coordinates: [number, number][];
+    }>;
+    rightEdge: z.ZodObject<{
+        type: z.ZodLiteral<"LineString">;
+        coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "LineString";
+        coordinates: [number, number][];
+    }, {
+        type: "LineString";
+        coordinates: [number, number][];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    provenance: {
+        kind: "approximate-assumed-per-class";
+        assumedWidthTableKey: string;
+        osmHighwayTag: string;
+        note?: string | undefined;
+    };
+    assumedWidthFt: number;
+    leftEdge: {
+        type: "LineString";
+        coordinates: [number, number][];
+    };
+    rightEdge: {
+        type: "LineString";
+        coordinates: [number, number][];
+    };
+}, {
+    provenance: {
+        kind: "approximate-assumed-per-class";
+        assumedWidthTableKey: string;
+        osmHighwayTag: string;
+        note?: string | undefined;
+    };
+    assumedWidthFt: number;
+    leftEdge: {
+        type: "LineString";
+        coordinates: [number, number][];
+    };
+    rightEdge: {
+        type: "LineString";
+        coordinates: [number, number][];
+    };
+}>;
+export type RoadRow = z.infer<typeof ROAD_ROW_SCHEMA>;
+/** Digital-twin-ready attach slot — no infra atoms in R1 scope. */
+export declare const ROAD_ATTACH_POINT_SCHEMA: z.ZodObject<{
+    kind: z.ZodLiteral<"infra-slot">;
+    refKey: z.ZodString;
+    position: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "infra-slot";
+    refKey: string;
+    position: [number, number];
+    note?: string | undefined;
+}, {
+    kind: "infra-slot";
+    refKey: string;
+    position: [number, number];
+    note?: string | undefined;
+}>;
+export type RoadAttachPoint = z.infer<typeof ROAD_ATTACH_POINT_SCHEMA>;
+/**
+ * Road NODE atom — first-class spine node (27c WDLL 3).
+ *
+ * Stable id `{county_fips}:road:{osm_way_id}`. Centerline from OSM;
+ * ROW edges from assumed per-class width with honest approximate provenance.
+ */
+export interface RoadNodeAtomInstance {
+    entityType: "road-node";
+    atomDid: string;
+    roadNodeId: string;
+    /** Human label when OSM carries a name tag (e.g. "Spring Street"). */
+    displayName?: string;
+    countyFips: string;
+    osmWayId: number;
+    classification: RoadClassification;
+    centerline: RoadCenterline;
+    row: RoadRow;
+    /** Reserved reference/attach points for future infra atoms (streetlight, water main, …). */
+    attachPoints: ReadonlyArray<RoadAttachPoint>;
+    reasoningChain: Extract<ReasoningChain, {
+        reasoningKind: "observed";
+    }>;
+    accessPolicy: AccessPolicy;
+    sourceCitation: string;
+    extractedAt: string;
+    asOf?: string;
+    atomTier: AtomTier;
+    readContract?: ReasoningReadContract;
+}
+export declare const ROAD_NODE_SCHEMA: z.ZodObject<{
+    atomTier: z.ZodLiteral<AtomTier>;
+    readContract: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        axes: z.ZodReadonly<z.ZodObject<{
+            calibratedConfidence: z.ZodReadonly<z.ZodObject<{
+                readonly estimate: z.ZodNumber;
+                readonly n: z.ZodNumber;
+                readonly intervalWidth: z.ZodNumber;
+                readonly provenance: z.ZodEnum<["asserted", "backtest", "seed", "live"]>;
+            }, "strip", z.ZodTypeAny, {
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }, {
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>>;
+            assertedConfidence: z.ZodReadonly<z.ZodObject<{
+                readonly estimate: z.ZodNumber;
+                readonly n: z.ZodNumber;
+                readonly intervalWidth: z.ZodNumber;
+                readonly provenance: z.ZodEnum<["asserted", "backtest", "seed", "live"]>;
+            }, "strip", z.ZodTypeAny, {
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }, {
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>>;
+            consequence: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"property-risk">;
+                stratum: z.ZodEnum<[import("../read-contract/reasoning-axes.js").PropertyRiskStratum, ...import("../read-contract/reasoning-axes.js").PropertyRiskStratum[]]>;
+                basis: z.ZodString;
+                assertedAt: z.ZodString;
+                auditRef: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            }, {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"not-applicable">;
+                reason: z.ZodString;
+                assertedAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            }, {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            }>]>;
+        }, "strip", z.ZodTypeAny, {
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }, {
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }>>;
+        assembledAt: z.ZodString;
+        modelAttribution: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            modelId: z.ZodString;
+            modelVersion: z.ZodString;
+            promptTemplateVersion: z.ZodString;
+            contextTemplateVersion: z.ZodString;
+            samplingParams: z.ZodReadonly<z.ZodObject<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodUnknown, z.objectOutputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">, z.objectInputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>>;
+            retrievedAtomSetId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectOutputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }, {
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectInputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        axes: Readonly<{
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }>;
+        assembledAt: string;
+        modelAttribution?: Readonly<{
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectOutputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }> | undefined;
+    }, {
+        axes: Readonly<{
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }>;
+        assembledAt: string;
+        modelAttribution?: Readonly<{
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectInputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }> | undefined;
+    }>>>;
+    sourceCitation: z.ZodString;
+    extractedAt: z.ZodString;
+    asOf: z.ZodOptional<z.ZodString>;
+    entityType: z.ZodLiteral<"road-node">;
+    atomDid: z.ZodEffects<z.ZodString, string, string>;
+    roadNodeId: z.ZodEffects<z.ZodString, string, string>;
+    displayName: z.ZodOptional<z.ZodString>;
+    countyFips: z.ZodString;
+    osmWayId: z.ZodNumber;
+    classification: z.ZodEnum<["highway", "major_collector", "minor_collector", "residential", "alley", "gravel", "unclassified"]>;
+    centerline: z.ZodObject<{
+        type: z.ZodLiteral<"LineString">;
+        coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "LineString";
+        coordinates: [number, number][];
+    }, {
+        type: "LineString";
+        coordinates: [number, number][];
+    }>;
+    row: z.ZodObject<{
+        assumedWidthFt: z.ZodNumber;
+        provenance: z.ZodObject<{
+            kind: z.ZodLiteral<"approximate-assumed-per-class">;
+            /** Descriptor table key used for assumed width (jurisdiction knowledge). */
+            assumedWidthTableKey: z.ZodString;
+            osmHighwayTag: z.ZodString;
+            note: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "approximate-assumed-per-class";
+            assumedWidthTableKey: string;
+            osmHighwayTag: string;
+            note?: string | undefined;
+        }, {
+            kind: "approximate-assumed-per-class";
+            assumedWidthTableKey: string;
+            osmHighwayTag: string;
+            note?: string | undefined;
+        }>;
+        /** Offset polylines from centerline + assumed half-width (v1 approximate). */
+        leftEdge: z.ZodObject<{
+            type: z.ZodLiteral<"LineString">;
+            coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "LineString";
+            coordinates: [number, number][];
+        }, {
+            type: "LineString";
+            coordinates: [number, number][];
+        }>;
+        rightEdge: z.ZodObject<{
+            type: z.ZodLiteral<"LineString">;
+            coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "LineString";
+            coordinates: [number, number][];
+        }, {
+            type: "LineString";
+            coordinates: [number, number][];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        provenance: {
+            kind: "approximate-assumed-per-class";
+            assumedWidthTableKey: string;
+            osmHighwayTag: string;
+            note?: string | undefined;
+        };
+        assumedWidthFt: number;
+        leftEdge: {
+            type: "LineString";
+            coordinates: [number, number][];
+        };
+        rightEdge: {
+            type: "LineString";
+            coordinates: [number, number][];
+        };
+    }, {
+        provenance: {
+            kind: "approximate-assumed-per-class";
+            assumedWidthTableKey: string;
+            osmHighwayTag: string;
+            note?: string | undefined;
+        };
+        assumedWidthFt: number;
+        leftEdge: {
+            type: "LineString";
+            coordinates: [number, number][];
+        };
+        rightEdge: {
+            type: "LineString";
+            coordinates: [number, number][];
+        };
+    }>;
+    attachPoints: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"infra-slot">;
+        refKey: z.ZodString;
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        note: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "infra-slot";
+        refKey: string;
+        position: [number, number];
+        note?: string | undefined;
+    }, {
+        kind: "infra-slot";
+        refKey: string;
+        position: [number, number];
+        note?: string | undefined;
+    }>, "many">;
+    reasoningChain: z.ZodObject<{
+        reasoningKind: z.ZodLiteral<"observed">;
+    }, "strip", z.ZodTypeAny, {
+        reasoningKind: "observed";
+    }, {
+        reasoningKind: "observed";
+    }>;
+    accessPolicy: z.ZodEnum<["public-free", "public-paid", "platform-internal", "tenant-private", "tenant-shared"]>;
+}, "strip", z.ZodTypeAny, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "road-node";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    roadNodeId: string;
+    countyFips: string;
+    osmWayId: number;
+    classification: "highway" | "major_collector" | "minor_collector" | "residential" | "alley" | "gravel" | "unclassified";
+    centerline: {
+        type: "LineString";
+        coordinates: [number, number][];
+    };
+    row: {
+        provenance: {
+            kind: "approximate-assumed-per-class";
+            assumedWidthTableKey: string;
+            osmHighwayTag: string;
+            note?: string | undefined;
+        };
+        assumedWidthFt: number;
+        leftEdge: {
+            type: "LineString";
+            coordinates: [number, number][];
+        };
+        rightEdge: {
+            type: "LineString";
+            coordinates: [number, number][];
+        };
+    };
+    attachPoints: {
+        kind: "infra-slot";
+        refKey: string;
+        position: [number, number];
+        note?: string | undefined;
+    }[];
+    displayName?: string | undefined;
+    asOf?: string | undefined;
+    readContract?: Readonly<{
+        axes: Readonly<{
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }>;
+        assembledAt: string;
+        modelAttribution?: Readonly<{
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectOutputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }> | undefined;
+    }> | undefined;
+}, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "road-node";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    roadNodeId: string;
+    countyFips: string;
+    osmWayId: number;
+    classification: "highway" | "major_collector" | "minor_collector" | "residential" | "alley" | "gravel" | "unclassified";
+    centerline: {
+        type: "LineString";
+        coordinates: [number, number][];
+    };
+    row: {
+        provenance: {
+            kind: "approximate-assumed-per-class";
+            assumedWidthTableKey: string;
+            osmHighwayTag: string;
+            note?: string | undefined;
+        };
+        assumedWidthFt: number;
+        leftEdge: {
+            type: "LineString";
+            coordinates: [number, number][];
+        };
+        rightEdge: {
+            type: "LineString";
+            coordinates: [number, number][];
+        };
+    };
+    attachPoints: {
+        kind: "infra-slot";
+        refKey: string;
+        position: [number, number];
+        note?: string | undefined;
+    }[];
+    displayName?: string | undefined;
+    asOf?: string | undefined;
+    readContract?: Readonly<{
+        axes: Readonly<{
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }>;
+        assembledAt: string;
+        modelAttribution?: Readonly<{
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectInputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }> | undefined;
+    }> | undefined;
+}>;
+export declare function createRoadNode(input: z.input<typeof ROAD_NODE_SCHEMA>): RoadNodeAtomInstance;
+export declare function roadNodeIdFromParts(countyFips: string, osmWayId: number): string;
+//# sourceMappingURL=road-node.d.ts.map

package/dist/property/road-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"road-node.d.ts","sourceRoot":"","sources":["../../src/property/road-node.ts"],"names":[],"mappings":"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"}