@empressaio/atom-contract 1.30.0 → 1.32.0

package/dist/property/boundary-edge.d.ts

@@ -0,0 +1,802 @@
+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";
+import { type RoadClassification } from "./road-node.js";
+/** `{county_fips}:{prop_id}:boundary:{edgeIndex}` (27f S2-U2 / WDLL 4-5). */
+export declare const BOUNDARY_EDGE_ID_PATTERN: RegExp;
+export type BoundaryEdgeRole = "front" | "side" | "rear" | "side_corner";
+export declare const BOUNDARY_EDGE_ROLE_VALUES: ReadonlyArray<BoundaryEdgeRole>;
+export declare const BOUNDARY_EDGE_ROLE_SCHEMA: z.ZodEnum<["front", "side", "rear", "side_corner"]>;
+export type BoundaryAdjacencyKind = "ROW" | "alley" | "neighbor-parcel" | "unmapped";
+export declare const BOUNDARY_ADJACENCY_KIND_VALUES: ReadonlyArray<BoundaryAdjacencyKind>;
+export declare const BOUNDARY_ADJACENCY_KIND_SCHEMA: z.ZodEnum<["ROW", "alley", "neighbor-parcel", "unmapped"]>;
+/**
+ * How the front role was chosen (honesty requirement — surfaces cite it):
+ * - "situs-street-match": parcel situs street name matched exactly one
+ *   road-adjacent edge's road displayName.
+ * - "adjacency-heuristic": road-proximity heuristic (no situs / no match /
+ *   ambiguous match).
+ */
+export type BoundaryFrontBasis = "situs-street-match" | "adjacency-heuristic";
+export declare const BOUNDARY_FRONT_BASIS_SCHEMA: z.ZodEnum<["situs-street-match", "adjacency-heuristic"]>;
+export declare const BOUNDARY_FACING_ROAD_SCHEMA: z.ZodObject<{
+    roadNodeId: z.ZodString;
+    classification: z.ZodEnum<["highway", "major_collector", "minor_collector", "residential", "alley", "gravel", "unclassified"]>;
+    provenance: z.ZodString;
+    osmHighwayTag: z.ZodOptional<z.ZodString>;
+    /** Mirrors road-node isPedestrianWay when known (same engine denylist). */
+    isPedestrianWay: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    provenance: string;
+    roadNodeId: string;
+    classification: "alley" | "highway" | "major_collector" | "minor_collector" | "residential" | "gravel" | "unclassified";
+    osmHighwayTag?: string | undefined;
+    isPedestrianWay?: boolean | undefined;
+}, {
+    provenance: string;
+    roadNodeId: string;
+    classification: "alley" | "highway" | "major_collector" | "minor_collector" | "residential" | "gravel" | "unclassified";
+    osmHighwayTag?: string | undefined;
+    isPedestrianWay?: boolean | undefined;
+}>;
+export interface BoundaryFacingRoad {
+    roadNodeId: string;
+    classification: RoadClassification;
+    provenance: string;
+    osmHighwayTag?: string;
+    isPedestrianWay?: boolean;
+}
+export declare const BOUNDARY_RESOLVED_SETBACK_SCHEMA: z.ZodObject<{
+    feet: z.ZodNumber;
+    provenance: z.ZodString;
+    atomCitation: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    provenance: string;
+    feet: number;
+    atomCitation?: string | undefined;
+}, {
+    provenance: string;
+    feet: number;
+    atomCitation?: string | undefined;
+}>;
+export type BoundaryResolvedSetback = z.infer<typeof BOUNDARY_RESOLVED_SETBACK_SCHEMA>;
+/**
+ * "not-applicable": no zoning ordinance exists to derive a setback from
+ * (unincorporated land). Distinct from "no-setback-row" (a genuinely missing
+ * ordinance-chart row for a KNOWN zoned district — a real gap, not an
+ * absence of zoning itself).
+ */
+export declare const BOUNDARY_SETBACK_ABSENCE_KINDS: readonly ["no-setback-row", "unmapped-adjacency", "not-applicable"];
+export type BoundarySetbackAbsenceKind = (typeof BOUNDARY_SETBACK_ABSENCE_KINDS)[number];
+export declare const BOUNDARY_SETBACK_ABSENCE_SCHEMA: z.ZodObject<{
+    kind: z.ZodEnum<["no-setback-row", "unmapped-adjacency", "not-applicable"]>;
+    reason: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "not-applicable" | "no-setback-row" | "unmapped-adjacency";
+    reason: string;
+}, {
+    kind: "not-applicable" | "no-setback-row" | "unmapped-adjacency";
+    reason: string;
+}>;
+export type BoundarySetbackAbsence = z.infer<typeof BOUNDARY_SETBACK_ABSENCE_SCHEMA>;
+export declare const BOUNDARY_SETBACK_SCHEMA: z.ZodUnion<[z.ZodObject<{
+    feet: z.ZodNumber;
+    provenance: z.ZodString;
+    atomCitation: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    provenance: string;
+    feet: number;
+    atomCitation?: string | undefined;
+}, {
+    provenance: string;
+    feet: number;
+    atomCitation?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodEnum<["no-setback-row", "unmapped-adjacency", "not-applicable"]>;
+    reason: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "not-applicable" | "no-setback-row" | "unmapped-adjacency";
+    reason: string;
+}, {
+    kind: "not-applicable" | "no-setback-row" | "unmapped-adjacency";
+    reason: string;
+}>]>;
+export type BoundarySetback = BoundaryResolvedSetback | BoundarySetbackAbsence;
+/**
+ * GIS-approximate interior frame (local-ENU metres from depth-warm
+ * projectRing: centroid origin, +X east, +Y north) — NOT raw WGS84 lng/lat.
+ * Used for GIS property-line-tags.
+ */
+export declare const BOUNDARY_INTERIOR_FRAME_SCHEMA: z.ZodObject<{
+    ringCcw: z.ZodBoolean;
+    centroidInside: z.ZodBoolean;
+    inwardNormal: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }>;
+    edgeEndpoints: z.ZodTuple<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>], null>;
+}, "strict", z.ZodTypeAny, {
+    ringCcw: boolean;
+    centroidInside: boolean;
+    inwardNormal: {
+        x: number;
+        y: number;
+    };
+    edgeEndpoints: [[number, number], [number, number]];
+}, {
+    ringCcw: boolean;
+    centroidInside: boolean;
+    inwardNormal: {
+        x: number;
+        y: number;
+    };
+    edgeEndpoints: [[number, number], [number, number]];
+}>;
+export interface BoundaryInteriorFrame {
+    ringCcw: boolean;
+    centroidInside: boolean;
+    inwardNormal: {
+        x: number;
+        y: number;
+    };
+    edgeEndpoints: [[number, number], [number, number]];
+}
+/**
+ * GIS-approximate bearing + distance on a boundary edge (never survey-grade).
+ * Honesty string must stay machine-checkable (WDLL anti-fabrication).
+ */
+export declare const BOUNDARY_PROPERTY_LINE_TAGS_SCHEMA: z.ZodObject<{
+    bearing: z.ZodString;
+    distanceFeet: z.ZodNumber;
+    provenance: z.ZodObject<{
+        kind: z.ZodLiteral<"gis-approximate">;
+        honesty: z.ZodString;
+        source: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "gis-approximate";
+        source: string;
+        honesty: string;
+    }, {
+        kind: "gis-approximate";
+        source: string;
+        honesty: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    provenance: {
+        kind: "gis-approximate";
+        source: string;
+        honesty: string;
+    };
+    bearing: string;
+    distanceFeet: number;
+}, {
+    provenance: {
+        kind: "gis-approximate";
+        source: string;
+        honesty: string;
+    };
+    bearing: string;
+    distanceFeet: number;
+}>;
+export type BoundaryPropertyLineTags = z.infer<typeof BOUNDARY_PROPERTY_LINE_TAGS_SCHEMA>;
+/**
+ * Property boundary edge atom — per-parcel edge with role, adjacency,
+ * resolved setback, and interior-frame geometry (27f S2-U2 / WDLL 4-5).
+ *
+ * Stable id `{county_fips}:{prop_id}:boundary:{edgeIndex}`. A parcel
+ * normally carries several of these (one per boundary side), unlike most
+ * other property atom kinds which are one-per-parcel.
+ */
+export interface BoundaryEdgeAtomInstance {
+    entityType: "property-boundary-edge";
+    atomDid: string;
+    boundaryEdgeId: string;
+    parcelNodeId: string;
+    countyFips: string;
+    propId: string;
+    edgeIndex: number;
+    role: BoundaryEdgeRole;
+    /** Present on the front edge only: which rule assigned the front role. */
+    frontBasis?: BoundaryFrontBasis;
+    adjacencyKind: BoundaryAdjacencyKind;
+    parcelNeighborPropId: string | null;
+    facingRoad: BoundaryFacingRoad | null;
+    setback: BoundarySetback;
+    interior: BoundaryInteriorFrame;
+    /** GIS-approx from ring endpoints; optional until backfill lands. */
+    propertyLineTags?: BoundaryPropertyLineTags;
+    effectiveDate: string;
+    status: "active" | "retired";
+    supersedesEntityId: string | null;
+    reasoningChain: Extract<ReasoningChain, {
+        reasoningKind: "observed";
+    }>;
+    accessPolicy: AccessPolicy;
+    sourceCitation: string;
+    extractedAt: string;
+    asOf?: string;
+    atomTier: AtomTier;
+    readContract?: ReasoningReadContract;
+}
+export declare const BOUNDARY_EDGE_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, {
+                kind: "property-risk";
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                basis: string;
+                auditRef?: string | undefined;
+            }, {
+                kind: "property-risk";
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                basis: string;
+                auditRef?: string | undefined;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"not-applicable">;
+                reason: z.ZodString;
+                assertedAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                kind: "not-applicable";
+                assertedAt: string;
+                reason: string;
+            }, {
+                kind: "not-applicable";
+                assertedAt: string;
+                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: {
+                kind: "property-risk";
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                kind: "not-applicable";
+                assertedAt: string;
+                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: {
+                kind: "property-risk";
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                kind: "not-applicable";
+                assertedAt: string;
+                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: {
+                kind: "property-risk";
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                kind: "not-applicable";
+                assertedAt: string;
+                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: {
+                kind: "property-risk";
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                kind: "not-applicable";
+                assertedAt: string;
+                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<"property-boundary-edge">;
+    atomDid: z.ZodEffects<z.ZodString, string, string>;
+    boundaryEdgeId: z.ZodEffects<z.ZodString, string, string>;
+    parcelNodeId: z.ZodEffects<z.ZodString, string, string>;
+    countyFips: z.ZodString;
+    propId: z.ZodString;
+    edgeIndex: z.ZodNumber;
+    role: z.ZodEnum<["front", "side", "rear", "side_corner"]>;
+    frontBasis: z.ZodOptional<z.ZodEnum<["situs-street-match", "adjacency-heuristic"]>>;
+    adjacencyKind: z.ZodEnum<["ROW", "alley", "neighbor-parcel", "unmapped"]>;
+    parcelNeighborPropId: z.ZodNullable<z.ZodString>;
+    facingRoad: z.ZodNullable<z.ZodObject<{
+        roadNodeId: z.ZodString;
+        classification: z.ZodEnum<["highway", "major_collector", "minor_collector", "residential", "alley", "gravel", "unclassified"]>;
+        provenance: z.ZodString;
+        osmHighwayTag: z.ZodOptional<z.ZodString>;
+        /** Mirrors road-node isPedestrianWay when known (same engine denylist). */
+        isPedestrianWay: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        provenance: string;
+        roadNodeId: string;
+        classification: "alley" | "highway" | "major_collector" | "minor_collector" | "residential" | "gravel" | "unclassified";
+        osmHighwayTag?: string | undefined;
+        isPedestrianWay?: boolean | undefined;
+    }, {
+        provenance: string;
+        roadNodeId: string;
+        classification: "alley" | "highway" | "major_collector" | "minor_collector" | "residential" | "gravel" | "unclassified";
+        osmHighwayTag?: string | undefined;
+        isPedestrianWay?: boolean | undefined;
+    }>>;
+    setback: z.ZodUnion<[z.ZodObject<{
+        feet: z.ZodNumber;
+        provenance: z.ZodString;
+        atomCitation: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        provenance: string;
+        feet: number;
+        atomCitation?: string | undefined;
+    }, {
+        provenance: string;
+        feet: number;
+        atomCitation?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodEnum<["no-setback-row", "unmapped-adjacency", "not-applicable"]>;
+        reason: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "not-applicable" | "no-setback-row" | "unmapped-adjacency";
+        reason: string;
+    }, {
+        kind: "not-applicable" | "no-setback-row" | "unmapped-adjacency";
+        reason: string;
+    }>]>;
+    interior: z.ZodObject<{
+        ringCcw: z.ZodBoolean;
+        centroidInside: z.ZodBoolean;
+        inwardNormal: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            x: number;
+            y: number;
+        }, {
+            x: number;
+            y: number;
+        }>;
+        edgeEndpoints: z.ZodTuple<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>], null>;
+    }, "strict", z.ZodTypeAny, {
+        ringCcw: boolean;
+        centroidInside: boolean;
+        inwardNormal: {
+            x: number;
+            y: number;
+        };
+        edgeEndpoints: [[number, number], [number, number]];
+    }, {
+        ringCcw: boolean;
+        centroidInside: boolean;
+        inwardNormal: {
+            x: number;
+            y: number;
+        };
+        edgeEndpoints: [[number, number], [number, number]];
+    }>;
+    propertyLineTags: z.ZodOptional<z.ZodObject<{
+        bearing: z.ZodString;
+        distanceFeet: z.ZodNumber;
+        provenance: z.ZodObject<{
+            kind: z.ZodLiteral<"gis-approximate">;
+            honesty: z.ZodString;
+            source: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "gis-approximate";
+            source: string;
+            honesty: string;
+        }, {
+            kind: "gis-approximate";
+            source: string;
+            honesty: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        provenance: {
+            kind: "gis-approximate";
+            source: string;
+            honesty: string;
+        };
+        bearing: string;
+        distanceFeet: number;
+    }, {
+        provenance: {
+            kind: "gis-approximate";
+            source: string;
+            honesty: string;
+        };
+        bearing: string;
+        distanceFeet: number;
+    }>>;
+    effectiveDate: z.ZodString;
+    status: z.ZodEnum<["active", "retired"]>;
+    supersedesEntityId: z.ZodNullable<z.ZodString>;
+    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";
+    status: "active" | "retired";
+    entityType: "property-boundary-edge";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    role: "front" | "side" | "rear" | "side_corner";
+    effectiveDate: string;
+    countyFips: string;
+    propId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    boundaryEdgeId: string;
+    parcelNodeId: string;
+    edgeIndex: number;
+    adjacencyKind: "alley" | "ROW" | "neighbor-parcel" | "unmapped";
+    parcelNeighborPropId: string | null;
+    facingRoad: {
+        provenance: string;
+        roadNodeId: string;
+        classification: "alley" | "highway" | "major_collector" | "minor_collector" | "residential" | "gravel" | "unclassified";
+        osmHighwayTag?: string | undefined;
+        isPedestrianWay?: boolean | undefined;
+    } | null;
+    setback: {
+        provenance: string;
+        feet: number;
+        atomCitation?: string | undefined;
+    } | {
+        kind: "not-applicable" | "no-setback-row" | "unmapped-adjacency";
+        reason: string;
+    };
+    interior: {
+        ringCcw: boolean;
+        centroidInside: boolean;
+        inwardNormal: {
+            x: number;
+            y: number;
+        };
+        edgeEndpoints: [[number, number], [number, number]];
+    };
+    supersedesEntityId: string | null;
+    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: {
+                kind: "property-risk";
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                kind: "not-applicable";
+                assertedAt: string;
+                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;
+    frontBasis?: "situs-street-match" | "adjacency-heuristic" | undefined;
+    propertyLineTags?: {
+        provenance: {
+            kind: "gis-approximate";
+            source: string;
+            honesty: string;
+        };
+        bearing: string;
+        distanceFeet: number;
+    } | undefined;
+}, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    status: "active" | "retired";
+    entityType: "property-boundary-edge";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    role: "front" | "side" | "rear" | "side_corner";
+    effectiveDate: string;
+    countyFips: string;
+    propId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    boundaryEdgeId: string;
+    parcelNodeId: string;
+    edgeIndex: number;
+    adjacencyKind: "alley" | "ROW" | "neighbor-parcel" | "unmapped";
+    parcelNeighborPropId: string | null;
+    facingRoad: {
+        provenance: string;
+        roadNodeId: string;
+        classification: "alley" | "highway" | "major_collector" | "minor_collector" | "residential" | "gravel" | "unclassified";
+        osmHighwayTag?: string | undefined;
+        isPedestrianWay?: boolean | undefined;
+    } | null;
+    setback: {
+        provenance: string;
+        feet: number;
+        atomCitation?: string | undefined;
+    } | {
+        kind: "not-applicable" | "no-setback-row" | "unmapped-adjacency";
+        reason: string;
+    };
+    interior: {
+        ringCcw: boolean;
+        centroidInside: boolean;
+        inwardNormal: {
+            x: number;
+            y: number;
+        };
+        edgeEndpoints: [[number, number], [number, number]];
+    };
+    supersedesEntityId: string | null;
+    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: {
+                kind: "property-risk";
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                kind: "not-applicable";
+                assertedAt: string;
+                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;
+    frontBasis?: "situs-street-match" | "adjacency-heuristic" | undefined;
+    propertyLineTags?: {
+        provenance: {
+            kind: "gis-approximate";
+            source: string;
+            honesty: string;
+        };
+        bearing: string;
+        distanceFeet: number;
+    } | undefined;
+}>;
+export declare function createBoundaryEdge(input: z.input<typeof BOUNDARY_EDGE_SCHEMA>): BoundaryEdgeAtomInstance;
+export declare function boundaryEdgeIdFromParts(countyFips: string, propId: string, edgeIndex: number): string;
+//# sourceMappingURL=boundary-edge.d.ts.map