@empressaio/atom-contract 1.11.0 → 1.13.0

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

@@ -0,0 +1,710 @@
+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 ParcelExternalKey, type ParcelGeometrySourceTier, type ParcelGeometryStoreRef, type ParcelKeyKind, type ParcelNodeAbsence, type SiteLayerVerifiedAbsence } from "./common.js";
+/**
+ * Parcel node ANCHOR atom — parcel identity and geometry provenance.
+ *
+ * Rail 1 of the county shape. This atom is the citable record that a parcel
+ * exists, which external key names it, where its ring came from, and at what
+ * vintage. Every other property rail keys on `parcelNodeId`, so this is the
+ * anchor the chain hangs from — MCP has advertised the type since the property
+ * chain shipped (`did:hauska:parcel-node:{parcelNodeId}`); this closes the gap
+ * where nothing produced it.
+ *
+ * **It is NOT the geometry.** Geometry Law rule 1 fixes one ring per parcel in
+ * `txgio_parcel`; the ten engine files that serve geometry read that store
+ * directly. `geometryStoreRef` is a POINTER into that truth frame. Putting the
+ * ring in the atom would create a second source of geometry truth, re-open the
+ * defect class Geometry Law rule 3 closed, and multiply row count by the whole
+ * statewide parcel corpus. Do not add a geometry body field to this type.
+ *
+ * **Typed absence is first-class**, matching `building-footprint` /
+ * `utility-easement`: a parcel we established does not exist, or a county whose
+ * ring source we probed and found unpublished, is a FINDING with provenance —
+ * not a missing row. `sourceTier: "absent"` fails closed unless `verifiedAbsence`
+ * carries a non-empty `provenanceScope`, and absence never coexists with a
+ * resolved `geometryStoreRef`.
+ */
+export interface ParcelNodeAtomInstance {
+    entityType: "parcel-node";
+    /** `did:hauska:parcel-node:{parcelNodeId}` — the convention MCP already serves. */
+    atomDid: string;
+    /** `{county_fips}:{prop_id}`, or the `{fips}:_county_coverage` anchor. */
+    parcelNodeId: string;
+    countyFips: string;
+    /** Which key kind the second token of `parcelNodeId` carries. */
+    keyKind: ParcelKeyKind;
+    /** Additional external keys, each with its own provenance. */
+    externalKeys?: ReadonlyArray<ParcelExternalKey>;
+    reasoningChain: Extract<ReasoningChain, {
+        reasoningKind: "observed";
+    }>;
+    geometrySourceTier: ParcelGeometrySourceTier;
+    /** Pointer into the single geometry truth frame. Never the ring itself. */
+    geometryStoreRef?: ParcelGeometryStoreRef;
+    /** False when the county ring set is not in the store yet. */
+    geometryLoaded: boolean;
+    /** Per-parcel typed absence (fail-closed; distinct from not-yet-loaded). */
+    absence?: ParcelNodeAbsence;
+    /** County-level verified absence on the `_county_coverage` anchor. */
+    verifiedAbsence?: SiteLayerVerifiedAbsence;
+    /**
+     * Count of `PARCEL-RING-SOURCE-DIVERGENCE` observations between the county
+     * CAD ring and the TxGIO ring. Reporting only — it never re-picks the truth
+     * frame, which stays TxGIO unless an explicit override tier is recorded.
+     */
+    divergenceObservationCount?: number;
+    accessPolicy: AccessPolicy;
+    sourceCitation: string;
+    extractedAt: string;
+    asOf?: string;
+    sourceVintage?: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    evaluatedAt: string;
+    atomTier: AtomTier;
+    readContract?: ReasoningReadContract;
+}
+/** Canonical parcel-node DID (matches the published MCP property-chain form). */
+export declare function parcelNodeAtomDid(parcelNodeId: string): string;
+export declare const PARCEL_NODE_ATOM_DID_PATTERN: RegExp;
+export declare const PARCEL_NODE_SCHEMA: z.ZodEffects<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;
+    }>>>;
+    sourceVintage: z.ZodOptional<z.ZodString>;
+    verificationStatus: z.ZodEnum<["machine", "human", "unsurveyed"]>;
+    sourceAdapter: z.ZodString;
+    evaluatedAt: z.ZodString;
+    sourceCitation: z.ZodString;
+    extractedAt: z.ZodString;
+    asOf: z.ZodOptional<z.ZodString>;
+    entityType: z.ZodLiteral<"parcel-node">;
+    atomDid: z.ZodEffects<z.ZodString, string, string>;
+    parcelNodeId: z.ZodEffects<z.ZodString, string, string>;
+    countyFips: z.ZodString;
+    keyKind: z.ZodEnum<["prop_id", "geo_id_crosswalk"]>;
+    externalKeys: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        keyKind: z.ZodEnum<["prop_id", "geo_id_crosswalk"]>;
+        keyValue: z.ZodString;
+        sourceCitation: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        sourceCitation: string;
+        keyKind: "prop_id" | "geo_id_crosswalk";
+        keyValue: string;
+    }, {
+        sourceCitation: string;
+        keyKind: "prop_id" | "geo_id_crosswalk";
+        keyValue: string;
+    }>, "many">>>;
+    reasoningChain: z.ZodObject<{
+        reasoningKind: z.ZodLiteral<"observed">;
+    }, "strip", z.ZodTypeAny, {
+        reasoningKind: "observed";
+    }, {
+        reasoningKind: "observed";
+    }>;
+    geometrySourceTier: z.ZodEnum<["txgio-stratmap", "county-arcgis-override", "absent"]>;
+    geometryStoreRef: z.ZodOptional<z.ZodObject<{
+        store: z.ZodLiteral<"txgio_parcel">;
+        countyFips: z.ZodString;
+        propId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        store: "txgio_parcel";
+        countyFips: string;
+        propId: string;
+    }, {
+        store: "txgio_parcel";
+        countyFips: string;
+        propId: string;
+    }>>;
+    geometryLoaded: z.ZodBoolean;
+    absence: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<["no-parcel-geometry", "geometry-incomplete", "parcel-key-unresolved"]>;
+        reason: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "no-parcel-geometry" | "geometry-incomplete" | "parcel-key-unresolved";
+        reason: string;
+    }, {
+        kind: "no-parcel-geometry" | "geometry-incomplete" | "parcel-key-unresolved";
+        reason: string;
+    }>>;
+    verifiedAbsence: z.ZodOptional<z.ZodObject<{
+        evaluated: z.ZodLiteral<true>;
+        provenanceScope: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        evaluated: true;
+        provenanceScope: string[];
+    }, {
+        evaluated: true;
+        provenanceScope: string[];
+    }>>;
+    divergenceObservationCount: z.ZodOptional<z.ZodNumber>;
+    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: "parcel-node";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    evaluatedAt: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    countyFips: string;
+    keyKind: "prop_id" | "geo_id_crosswalk";
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    geometrySourceTier: "absent" | "txgio-stratmap" | "county-arcgis-override";
+    geometryLoaded: boolean;
+    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;
+    absence?: {
+        kind: "no-parcel-geometry" | "geometry-incomplete" | "parcel-key-unresolved";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+    sourceVintage?: string | undefined;
+    externalKeys?: readonly {
+        sourceCitation: string;
+        keyKind: "prop_id" | "geo_id_crosswalk";
+        keyValue: string;
+    }[] | undefined;
+    geometryStoreRef?: {
+        store: "txgio_parcel";
+        countyFips: string;
+        propId: string;
+    } | undefined;
+    divergenceObservationCount?: number | undefined;
+}, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "parcel-node";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    evaluatedAt: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    countyFips: string;
+    keyKind: "prop_id" | "geo_id_crosswalk";
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    geometrySourceTier: "absent" | "txgio-stratmap" | "county-arcgis-override";
+    geometryLoaded: boolean;
+    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;
+    absence?: {
+        kind: "no-parcel-geometry" | "geometry-incomplete" | "parcel-key-unresolved";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+    sourceVintage?: string | undefined;
+    externalKeys?: readonly {
+        sourceCitation: string;
+        keyKind: "prop_id" | "geo_id_crosswalk";
+        keyValue: string;
+    }[] | undefined;
+    geometryStoreRef?: {
+        store: "txgio_parcel";
+        countyFips: string;
+        propId: string;
+    } | undefined;
+    divergenceObservationCount?: number | undefined;
+}>, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "parcel-node";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    evaluatedAt: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    countyFips: string;
+    keyKind: "prop_id" | "geo_id_crosswalk";
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    geometrySourceTier: "absent" | "txgio-stratmap" | "county-arcgis-override";
+    geometryLoaded: boolean;
+    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;
+    absence?: {
+        kind: "no-parcel-geometry" | "geometry-incomplete" | "parcel-key-unresolved";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+    sourceVintage?: string | undefined;
+    externalKeys?: readonly {
+        sourceCitation: string;
+        keyKind: "prop_id" | "geo_id_crosswalk";
+        keyValue: string;
+    }[] | undefined;
+    geometryStoreRef?: {
+        store: "txgio_parcel";
+        countyFips: string;
+        propId: string;
+    } | undefined;
+    divergenceObservationCount?: number | undefined;
+}, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "parcel-node";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    evaluatedAt: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    countyFips: string;
+    keyKind: "prop_id" | "geo_id_crosswalk";
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    geometrySourceTier: "absent" | "txgio-stratmap" | "county-arcgis-override";
+    geometryLoaded: boolean;
+    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;
+    absence?: {
+        kind: "no-parcel-geometry" | "geometry-incomplete" | "parcel-key-unresolved";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+    sourceVintage?: string | undefined;
+    externalKeys?: readonly {
+        sourceCitation: string;
+        keyKind: "prop_id" | "geo_id_crosswalk";
+        keyValue: string;
+    }[] | undefined;
+    geometryStoreRef?: {
+        store: "txgio_parcel";
+        countyFips: string;
+        propId: string;
+    } | undefined;
+    divergenceObservationCount?: number | undefined;
+}>;
+export declare function createParcelNode(input: z.input<typeof PARCEL_NODE_SCHEMA>): ParcelNodeAtomInstance;
+//# sourceMappingURL=parcel-node.d.ts.map