@propertysimple/client 0.1.0

package/contracts/src/operations.js

@@ -0,0 +1,56 @@
+import { directoryOperations } from './directory.js';
+import { smartFeedOperations } from './smart-feed.js';
+import { professionalIntelligenceOperations } from './professional-intelligence.js';
+import { directorySalesOperations } from './directory-sales.js';
+import { directoryIdentityOperations } from './directory-identity.js';
+import { directoryExecutionOperations } from './directory-execution.js';
+import { searchOperations } from './search.js';
+import { PublicationReportRequest, PublicationReceipt, DestinationQuery, DestinationResponse, } from './publication.js';
+import { JudgmentRequest, JudgmentSchema, IntelligenceCapabilitiesSchema } from './intelligence.js';
+import { Id, Empty, ResourceQuery, ResourcePageQuery, DatasetPageQuery, ListingDetailQuery, ListingSchema, ListingContactsSchema, AgentSchema, ListingQuery, IdentityQuery, IdentitySchema, AgentIdentitySchema, page, CatalogHealthQuery, CatalogHealthSchema, ListingPage, ListingMapQuery, ListingMapSchema, SimilarListingQuery, SimilarListingsSchema, SnapshotRequest, SnapshotSchema, CatalogChangeSchema, DomainEventSchema, ClassificationDefinitionSchema, ActionProfileSchema, OpportunityQuery, OpportunitySchema, PlanRequest, PlanSchema, PlanItemSchema, DispatchRequest, DispatchBatchSchema, AttemptRequest, AttemptSchema, OutcomesRequest, ContextEventsRequest, BatchResultSchema, WebhookRequest, WebhookSchema, CapabilitiesSchema, ReadinessSchema, } from './schemas.js';
+/** One registry drives the interface, HTTP validation and SDK response validation. */
+export const operations = {
+    ...searchOperations,
+    ...directoryOperations,
+    ...smartFeedOperations,
+    ...professionalIntelligenceOperations,
+    ...directorySalesOperations,
+    ...directoryIdentityOperations,
+    ...directoryExecutionOperations,
+    evaluateJudgment: { input: JudgmentRequest, output: JudgmentSchema },
+    getJudgment: { input: ResourceQuery, output: JudgmentSchema },
+    intelligenceCapabilities: { input: Empty, output: IntelligenceCapabilitiesSchema },
+    capabilities: { input: Empty, output: CapabilitiesSchema },
+    reportPublication: { input: PublicationReportRequest, output: PublicationReceipt },
+    resolveDestination: { input: DestinationQuery, output: DestinationResponse },
+    listListings: { input: ListingQuery, output: ListingPage },
+    getCatalogHealth: { input: CatalogHealthQuery, output: CatalogHealthSchema },
+    getListing: { input: ListingDetailQuery, output: ListingSchema },
+    getListingContacts: {
+        input: ResourceQuery.extend({ dataset_id: Id.optional() }),
+        output: ListingContactsSchema,
+    },
+    listListingMap: { input: ListingMapQuery, output: ListingMapSchema },
+    listSimilarListings: { input: SimilarListingQuery, output: SimilarListingsSchema },
+    resolveListingIdentity: { input: IdentityQuery, output: IdentitySchema },
+    resolveAgentIdentity: { input: IdentityQuery, output: AgentIdentitySchema },
+    getAgent: { input: ResourceQuery, output: AgentSchema },
+    listAgentListings: { input: ListingQuery.safeExtend({ id: Id }), output: ListingPage },
+    classificationSchema: { input: Empty, output: ClassificationDefinitionSchema },
+    createSnapshot: { input: SnapshotRequest, output: SnapshotSchema },
+    getSnapshot: { input: ResourceQuery, output: SnapshotSchema },
+    listSnapshotItems: { input: ResourcePageQuery, output: ListingPage },
+    listCatalogChanges: { input: DatasetPageQuery, output: page(CatalogChangeSchema) },
+    listEvents: { input: DatasetPageQuery, output: page(DomainEventSchema) },
+    listActionProfiles: { input: Empty, output: page(ActionProfileSchema) },
+    listOpportunities: { input: OpportunityQuery, output: page(OpportunitySchema) },
+    createPlan: { input: PlanRequest, output: PlanSchema },
+    getPlan: { input: ResourceQuery, output: PlanSchema },
+    listPlanItems: { input: ResourcePageQuery, output: page(PlanItemSchema) },
+    claimDispatchBatch: { input: DispatchRequest, output: DispatchBatchSchema },
+    startAttempt: { input: AttemptRequest, output: AttemptSchema },
+    recordActionOutcomes: { input: OutcomesRequest, output: BatchResultSchema },
+    recordProductContextEvents: { input: ContextEventsRequest, output: BatchResultSchema },
+    createWebhookSubscription: { input: WebhookRequest, output: WebhookSchema },
+    readiness: { input: Empty, output: ReadinessSchema },
+};

package/contracts/src/opportunity-events.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { DomainEventSchema } from './schemas.js';
+export declare const MarketAgeEvidenceSchema: z.ZodObject<{
+    threshold_days: z.ZodNumber;
+    listed_at: z.ZodISODateTime;
+    listed_precision: z.ZodEnum<{
+        date: "date";
+        instant: "instant";
+    }>;
+    source_observed_at: z.ZodISODateTime;
+}, z.core.$strict>;
+/** An observed occasion, never a recommendation, consent, send or order permit.
+ * received_at is the platform observation clock used for activity charts;
+ * occurred_at preserves the source/calculated boundary for enrollment/history. */
+export declare const OpportunityObservationSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"opportunity-observation-v1">;
+    id: z.ZodString;
+    sequence: z.ZodString;
+    listing_id: z.ZodString;
+    episode_id: z.ZodString;
+    type: z.ZodEnum<{
+        new_to_market: "new_to_market";
+        price_drop: "price_drop";
+        open_house_changed: "open_house_changed";
+        market_age_milestone: "market_age_milestone";
+        source_removed: "source_removed";
+    }>;
+    received_at: z.ZodISODateTime;
+    occurred_at: z.ZodISODateTime;
+    evidence: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    requires_current_eligibility: z.ZodLiteral<true>;
+    authorizes_order: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export type OpportunityObservation = z.infer<typeof OpportunityObservationSchema>;
+/** Map durable /v1/events replay to a product-neutral observation. Baseline,
+ * parser corrections and arbitrary catalog updates are deliberately not events
+ * a consumer can mistake for a newly received marketing opportunity. */
+export declare function opportunityObservation(input: z.infer<typeof DomainEventSchema>): OpportunityObservation | null;

package/contracts/src/opportunity-events.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { DomainEventSchema } from './schemas.js';
+export const MarketAgeEvidenceSchema = z.strictObject({
+    threshold_days: z.number().int().min(30).multipleOf(30),
+    listed_at: z.iso.datetime({ offset: true }),
+    listed_precision: z.enum(['date', 'instant']),
+    source_observed_at: z.iso.datetime({ offset: true }),
+});
+/** An observed occasion, never a recommendation, consent, send or order permit.
+ * received_at is the platform observation clock used for activity charts;
+ * occurred_at preserves the source/calculated boundary for enrollment/history. */
+export const OpportunityObservationSchema = z
+    .strictObject({
+    schema_version: z.literal('opportunity-observation-v1'),
+    id: z.string().min(1),
+    sequence: z.string().regex(/^\d+$/),
+    listing_id: z.string().min(1),
+    episode_id: z.string().min(1),
+    type: z.enum([
+        'new_to_market',
+        'price_drop',
+        'open_house_changed',
+        'market_age_milestone',
+        'source_removed',
+    ]),
+    received_at: z.iso.datetime({ offset: true }),
+    occurred_at: z.iso.datetime({ offset: true }),
+    evidence: DomainEventSchema.shape.evidence,
+    requires_current_eligibility: z.literal(true),
+    authorizes_order: z.literal(false),
+})
+    .superRefine((event, context) => {
+    if (event.type === 'market_age_milestone' &&
+        !MarketAgeEvidenceSchema.safeParse(event.evidence).success) {
+        context.addIssue({
+            code: 'custom',
+            path: ['evidence'],
+            message: 'Invalid market-age milestone evidence.',
+        });
+    }
+});
+/** Map durable /v1/events replay to a product-neutral observation. Baseline,
+ * parser corrections and arbitrary catalog updates are deliberately not events
+ * a consumer can mistake for a newly received marketing opportunity. */
+export function opportunityObservation(input) {
+    const event = DomainEventSchema.parse(input);
+    const type = event.type === 'listing_removed' ? 'source_removed' : event.type;
+    if (![
+        'new_to_market',
+        'price_drop',
+        'open_house_changed',
+        'market_age_milestone',
+        'source_removed',
+    ].includes(type))
+        return null;
+    return OpportunityObservationSchema.parse({
+        schema_version: 'opportunity-observation-v1',
+        id: event.id,
+        sequence: event.sequence,
+        listing_id: event.listing_id,
+        episode_id: event.episode_id,
+        type,
+        received_at: event.observed_at,
+        occurred_at: event.occurred_at,
+        evidence: event.evidence,
+        requires_current_eligibility: true,
+        authorizes_order: false,
+    });
+}

package/contracts/src/platform-api.d.ts

@@ -0,0 +1,12 @@
+import type { Input, Operation, Output, Principal } from './schemas.js';
+export interface RequestContext {
+    request_id: string;
+    /** Required by the router on mutations. Services must scope it to tenant, operation and body hash. */
+    idempotency_key?: string;
+}
+export type MutationContext = RequestContext;
+/** Services must authorize resource ownership as well as the router's coarse scopes. */
+export type PlatformApi = {
+    [K in Operation]: (principal: Principal, input: Input<K>, context: RequestContext) => Promise<Output<K>>;
+};
+export type Authenticate = (request: Request) => Promise<Principal | null>;

package/contracts/src/platform-api.js

@@ -0,0 +1 @@
+export {};

package/contracts/src/professional-intelligence.d.ts

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+export declare const DirectoryAssessmentTask: z.ZodEnum<{
+    entity_match: "entity_match";
+    office_variant: "office_variant";
+    relationship_support: "relationship_support";
+    professional_category: "professional_category";
+}>;
+export declare const DirectoryAssessmentRequest: z.ZodObject<{
+    dataset_id: z.ZodString;
+    entity_id: z.ZodString;
+    comparison_id: z.ZodOptional<z.ZodString>;
+    task: z.ZodEnum<{
+        entity_match: "entity_match";
+        office_variant: "office_variant";
+        relationship_support: "relationship_support";
+        professional_category: "professional_category";
+    }>;
+    relationship: z.ZodOptional<z.ZodEnum<{
+        observed_at_office: "observed_at_office";
+        observed_brokerage: "observed_brokerage";
+        affiliated_with: "affiliated_with";
+        operates: "operates";
+        member_of: "member_of";
+    }>>;
+}, z.core.$strict>;
+export declare const DirectoryAssessmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    entity_id: z.ZodString;
+    comparison_id: z.ZodNullable<z.ZodString>;
+    task: z.ZodEnum<{
+        entity_match: "entity_match";
+        office_variant: "office_variant";
+        relationship_support: "relationship_support";
+        professional_category: "professional_category";
+    }>;
+    definition_version: z.ZodString;
+    evidence_hash: z.ZodString;
+    state: z.ZodEnum<{
+        stale: "stale";
+        failed: "failed";
+        running: "running";
+        succeeded: "succeeded";
+        queued: "queued";
+    }>;
+    provider: z.ZodString;
+    model: z.ZodString;
+    result: z.ZodNullable<z.ZodObject<{
+        decision: z.ZodEnum<{
+            unknown: "unknown";
+            supported: "supported";
+            conflicting: "conflicting";
+            not_established: "not_established";
+            consistent: "consistent";
+            distinct: "distinct";
+            residential: "residential";
+            commercial: "commercial";
+            rental: "rental";
+            mixed: "mixed";
+        }>;
+        evidence_refs: z.ZodArray<z.ZodString>;
+        confidence: z.ZodNumber;
+        authority: z.ZodLiteral<"semantic_assessment">;
+        changes_account_access: z.ZodLiteral<false>;
+    }, z.core.$strict>>;
+    error_code: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodISODateTime;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export declare const professionalIntelligenceOperations: {
+    readonly latestDirectoryAssessment: {
+        readonly input: z.ZodObject<{
+            dataset_id: z.ZodString;
+            entity_id: z.ZodString;
+            comparison_id: z.ZodOptional<z.ZodString>;
+            task: z.ZodEnum<{
+                entity_match: "entity_match";
+                office_variant: "office_variant";
+                relationship_support: "relationship_support";
+                professional_category: "professional_category";
+            }>;
+            relationship: z.ZodOptional<z.ZodEnum<{
+                observed_at_office: "observed_at_office";
+                observed_brokerage: "observed_brokerage";
+                affiliated_with: "affiliated_with";
+                operates: "operates";
+                member_of: "member_of";
+            }>>;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            state: z.ZodEnum<{
+                stale: "stale";
+                failed: "failed";
+                running: "running";
+                succeeded: "succeeded";
+                queued: "queued";
+                not_assessed: "not_assessed";
+            }>;
+            assessment: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                entity_id: z.ZodString;
+                comparison_id: z.ZodNullable<z.ZodString>;
+                task: z.ZodEnum<{
+                    entity_match: "entity_match";
+                    office_variant: "office_variant";
+                    relationship_support: "relationship_support";
+                    professional_category: "professional_category";
+                }>;
+                definition_version: z.ZodString;
+                evidence_hash: z.ZodString;
+                state: z.ZodEnum<{
+                    stale: "stale";
+                    failed: "failed";
+                    running: "running";
+                    succeeded: "succeeded";
+                    queued: "queued";
+                }>;
+                provider: z.ZodString;
+                model: z.ZodString;
+                result: z.ZodNullable<z.ZodObject<{
+                    decision: z.ZodEnum<{
+                        unknown: "unknown";
+                        supported: "supported";
+                        conflicting: "conflicting";
+                        not_established: "not_established";
+                        consistent: "consistent";
+                        distinct: "distinct";
+                        residential: "residential";
+                        commercial: "commercial";
+                        rental: "rental";
+                        mixed: "mixed";
+                    }>;
+                    evidence_refs: z.ZodArray<z.ZodString>;
+                    confidence: z.ZodNumber;
+                    authority: z.ZodLiteral<"semantic_assessment">;
+                    changes_account_access: z.ZodLiteral<false>;
+                }, z.core.$strict>>;
+                error_code: z.ZodNullable<z.ZodString>;
+                created_at: z.ZodISODateTime;
+                completed_at: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    };
+    readonly requestDirectoryAssessment: {
+        readonly input: z.ZodObject<{
+            dataset_id: z.ZodString;
+            entity_id: z.ZodString;
+            comparison_id: z.ZodOptional<z.ZodString>;
+            task: z.ZodEnum<{
+                entity_match: "entity_match";
+                office_variant: "office_variant";
+                relationship_support: "relationship_support";
+                professional_category: "professional_category";
+            }>;
+            relationship: z.ZodOptional<z.ZodEnum<{
+                observed_at_office: "observed_at_office";
+                observed_brokerage: "observed_brokerage";
+                affiliated_with: "affiliated_with";
+                operates: "operates";
+                member_of: "member_of";
+            }>>;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            entity_id: z.ZodString;
+            comparison_id: z.ZodNullable<z.ZodString>;
+            task: z.ZodEnum<{
+                entity_match: "entity_match";
+                office_variant: "office_variant";
+                relationship_support: "relationship_support";
+                professional_category: "professional_category";
+            }>;
+            definition_version: z.ZodString;
+            evidence_hash: z.ZodString;
+            state: z.ZodEnum<{
+                stale: "stale";
+                failed: "failed";
+                running: "running";
+                succeeded: "succeeded";
+                queued: "queued";
+            }>;
+            provider: z.ZodString;
+            model: z.ZodString;
+            result: z.ZodNullable<z.ZodObject<{
+                decision: z.ZodEnum<{
+                    unknown: "unknown";
+                    supported: "supported";
+                    conflicting: "conflicting";
+                    not_established: "not_established";
+                    consistent: "consistent";
+                    distinct: "distinct";
+                    residential: "residential";
+                    commercial: "commercial";
+                    rental: "rental";
+                    mixed: "mixed";
+                }>;
+                evidence_refs: z.ZodArray<z.ZodString>;
+                confidence: z.ZodNumber;
+                authority: z.ZodLiteral<"semantic_assessment">;
+                changes_account_access: z.ZodLiteral<false>;
+            }, z.core.$strict>>;
+            error_code: z.ZodNullable<z.ZodString>;
+            created_at: z.ZodISODateTime;
+            completed_at: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+    };
+    readonly getDirectoryAssessment: {
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            entity_id: z.ZodString;
+            comparison_id: z.ZodNullable<z.ZodString>;
+            task: z.ZodEnum<{
+                entity_match: "entity_match";
+                office_variant: "office_variant";
+                relationship_support: "relationship_support";
+                professional_category: "professional_category";
+            }>;
+            definition_version: z.ZodString;
+            evidence_hash: z.ZodString;
+            state: z.ZodEnum<{
+                stale: "stale";
+                failed: "failed";
+                running: "running";
+                succeeded: "succeeded";
+                queued: "queued";
+            }>;
+            provider: z.ZodString;
+            model: z.ZodString;
+            result: z.ZodNullable<z.ZodObject<{
+                decision: z.ZodEnum<{
+                    unknown: "unknown";
+                    supported: "supported";
+                    conflicting: "conflicting";
+                    not_established: "not_established";
+                    consistent: "consistent";
+                    distinct: "distinct";
+                    residential: "residential";
+                    commercial: "commercial";
+                    rental: "rental";
+                    mixed: "mixed";
+                }>;
+                evidence_refs: z.ZodArray<z.ZodString>;
+                confidence: z.ZodNumber;
+                authority: z.ZodLiteral<"semantic_assessment">;
+                changes_account_access: z.ZodLiteral<false>;
+            }, z.core.$strict>>;
+            error_code: z.ZodNullable<z.ZodString>;
+            created_at: z.ZodISODateTime;
+            completed_at: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+    };
+};
+export type DirectoryAssessmentInput = z.infer<typeof DirectoryAssessmentRequest>;
+export type DirectoryAssessment = z.infer<typeof DirectoryAssessmentSchema>;

package/contracts/src/professional-intelligence.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+const Id = z.string().min(1).max(256);
+export const DirectoryAssessmentTask = z.enum([
+    'entity_match',
+    'office_variant',
+    'relationship_support',
+    'professional_category',
+]);
+export const DirectoryAssessmentRequest = z
+    .strictObject({
+    dataset_id: Id,
+    entity_id: Id,
+    comparison_id: Id.optional(),
+    task: DirectoryAssessmentTask,
+    relationship: z
+        .enum([
+        'affiliated_with',
+        'operates',
+        'member_of',
+        'observed_at_office',
+        'observed_brokerage',
+    ])
+        .optional(),
+})
+    .superRefine((input, ctx) => {
+    if (input.task !== 'professional_category' && !input.comparison_id)
+        ctx.addIssue({ code: 'custom', message: 'Pair tasks require comparison_id.' });
+    if (input.comparison_id === input.entity_id)
+        ctx.addIssue({ code: 'custom', message: 'Compare distinct records.' });
+    if (input.task === 'professional_category' && input.comparison_id)
+        ctx.addIssue({ code: 'custom', message: 'Category tasks have one subject.' });
+    if (input.task === 'relationship_support' && !input.relationship)
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Relationship support requires an explicit relationship predicate.',
+        });
+    if (input.task !== 'relationship_support' && input.relationship)
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Only relationship-support tasks accept a relationship predicate.',
+        });
+});
+export const DirectoryAssessmentSchema = z.strictObject({
+    id: Id,
+    entity_id: Id,
+    comparison_id: Id.nullable(),
+    task: DirectoryAssessmentTask,
+    definition_version: z.string(),
+    evidence_hash: z.string(),
+    state: z.enum(['queued', 'running', 'succeeded', 'failed', 'stale']),
+    provider: z.string(),
+    model: z.string(),
+    result: z
+        .strictObject({
+        decision: z.enum([
+            'consistent',
+            'distinct',
+            'supported',
+            'not_established',
+            'conflicting',
+            'residential',
+            'commercial',
+            'rental',
+            'mixed',
+            'unknown',
+        ]),
+        evidence_refs: z.array(z.string()),
+        confidence: z.number().min(0).max(1),
+        authority: z.literal('semantic_assessment'),
+        changes_account_access: z.literal(false),
+    })
+        .nullable(),
+    error_code: z.string().nullable(),
+    created_at: z.iso.datetime({ offset: true }),
+    completed_at: z.iso.datetime({ offset: true }).nullable(),
+});
+export const professionalIntelligenceOperations = {
+    latestDirectoryAssessment: {
+        input: DirectoryAssessmentRequest,
+        output: z.strictObject({
+            state: z.enum(['not_assessed', 'queued', 'running', 'succeeded', 'failed', 'stale']),
+            assessment: DirectoryAssessmentSchema.nullable(),
+        }),
+    },
+    requestDirectoryAssessment: {
+        input: DirectoryAssessmentRequest,
+        output: DirectoryAssessmentSchema,
+    },
+    getDirectoryAssessment: { input: z.strictObject({ id: Id }), output: DirectoryAssessmentSchema },
+};

package/contracts/src/property-features.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+/** Stable product vocabulary. Availability describes an implemented inference path,
+ * not measured model accuracy or whether a particular feed supplies the field. */
+export declare const PROPERTY_DISCOVERY_REGISTRY_VERSION = "property-discovery-v1";
+export declare const PropertyFeatureDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    family: z.ZodNumber;
+    label: z.ZodString;
+    definition: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+    }>;
+    values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    synonyms: z.ZodArray<z.ZodString>;
+    applicability: z.ZodEnum<{
+        any: "any";
+        rental: "rental";
+        dwelling: "dwelling";
+        sale: "sale";
+    }>;
+    source_paths: z.ZodArray<z.ZodString>;
+    operators: z.ZodArray<z.ZodEnum<{
+        in: "in";
+        eq: "eq";
+        neq: "neq";
+        not_in: "not_in";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+    }>>;
+    availability: z.ZodEnum<{
+        source_and_interpretation: "source_and_interpretation";
+        source_only: "source_only";
+    }>;
+    consequence: z.ZodEnum<{
+        ordinary: "ordinary";
+        consequential: "consequential";
+    }>;
+    status: z.ZodLiteral<"experimental">;
+}, z.core.$strict>;
+export type PropertyFeatureDefinition = z.infer<typeof PropertyFeatureDefinitionSchema>;
+export declare const PropertyFeatureRegistrySchema: z.ZodObject<{
+    version: z.ZodLiteral<"property-discovery-v1">;
+    features: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        family: z.ZodNumber;
+        label: z.ZodString;
+        definition: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        synonyms: z.ZodArray<z.ZodString>;
+        applicability: z.ZodEnum<{
+            any: "any";
+            rental: "rental";
+            dwelling: "dwelling";
+            sale: "sale";
+        }>;
+        source_paths: z.ZodArray<z.ZodString>;
+        operators: z.ZodArray<z.ZodEnum<{
+            in: "in";
+            eq: "eq";
+            neq: "neq";
+            not_in: "not_in";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+        }>>;
+        availability: z.ZodEnum<{
+            source_and_interpretation: "source_and_interpretation";
+            source_only: "source_only";
+        }>;
+        consequence: z.ZodEnum<{
+            ordinary: "ordinary";
+            consequential: "consequential";
+        }>;
+        status: z.ZodLiteral<"experimental">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const PROPERTY_FEATURE_FAMILIES: {
+    id: number;
+    label: string;
+}[];
+/** Never reuse an existing ID for a narrower claim: the legacy coarse pantry,
+ * laundry and style definitions remain alongside precise discovery attributes. */
+export declare const PROPERTY_FEATURE_REGISTRY: readonly PropertyFeatureDefinition[];
+export declare function propertyFeature(id: string): PropertyFeatureDefinition | undefined;