@propertysimple/client 0.1.0

package/contracts/src/directory.js

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+// Directory contracts are additive: legacy agent IDs still identify source records.
+const Id = z.string().min(1).max(256);
+const Time = z.iso.datetime({ offset: true });
+export const DirectoryKind = z.enum(['professional', 'office', 'organization', 'team']);
+export const DirectoryPurpose = z.enum([
+    'display',
+    'contacts',
+    'sync',
+    'inference',
+    'internal_sales',
+]);
+export const DirectoryValue = z.union([z.string(), z.boolean(), z.number(), z.null()]);
+export const DirectoryFieldEvidenceSchema = z.strictObject({
+    state: z.enum(['supported', 'conflicting', 'withdrawn']),
+    // Bounded supporting examples. Internal immutable observations preserve complete evidence.
+    observation_ids: z.array(Id).max(8),
+    authority: z.enum(['source_listing', 'product_verified', 'operator_verified']),
+    source_modified_at: Time.nullable(),
+});
+export const DirectoryEntitySchema = z.strictObject({
+    id: Id,
+    kind: DirectoryKind,
+    source_identities: z.array(z.strictObject({
+        source: Id,
+        key: Id,
+        key_kind: z.enum(['source', 'derived_observation']),
+        legacy_agent_id: Id.nullable(),
+    })),
+    revision: z.string(),
+    name: z.string().nullable(),
+    fields: z.record(z.string(), DirectoryValue),
+    field_evidence: z.record(z.string(), DirectoryFieldEvidenceSchema),
+    resolution_state: z.enum(['source_identity', 'provisional']),
+    source_availability: z.enum(['present', 'unrepresented']),
+    first_seen_at: Time,
+    last_seen_at: Time,
+    updated_at: Time,
+});
+export const DirectoryRelationshipSchema = z.strictObject({
+    id: Id,
+    source: Id,
+    subject_id: Id,
+    object_id: Id,
+    relationship: z.enum([
+        'observed_at_office',
+        'observed_brokerage',
+        'affiliated_with',
+        'operates',
+        'member_of',
+    ]),
+    evidence_state: z.enum(['observed', 'verified']),
+    authority: z.enum(['source_listing', 'product_verified', 'operator_verified']),
+    revision: z.string(),
+    current: z.boolean(),
+    listing_id: Id.nullable(),
+    observed_at: Time,
+    effective_from: Time.nullable(),
+    effective_to: Time.nullable(),
+    evidence_ref: Id,
+});
+export const DirectoryContactSchema = z.strictObject({
+    id: Id,
+    type: z.enum(['email', 'phone', 'website']),
+    purpose: z.enum(['professional', 'office', 'organization', 'lead_routing']),
+    value: z.string(),
+    original: z.string(),
+    observation_ids: z.array(Id).max(8),
+    source_modified_at: Time.nullable(),
+    verified_ownership: z.boolean(),
+});
+export const DirectoryContactsSchema = z.strictObject({
+    entity_id: Id,
+    revision: z.string(),
+    state: z.enum(['available', 'not_established', 'conflicting', 'unrepresented']),
+    data: z.array(DirectoryContactSchema),
+});
+export const DirectoryMetricsSchema = z.strictObject({
+    entity_id: Id,
+    inventory_basis: z.literal('listing_representation'),
+    definition_version: z.literal('observed-inventory-v1'),
+    listing_count: z.number().int().nonnegative(),
+    active_listing_count: z.number().int().nonnegative(),
+    source_namespaces: z.array(Id),
+    coverage: z.literal('authorized_observed_listings'),
+    calculated_at: Time,
+});
+export const DirectoryPageQuery = z.strictObject({
+    dataset_id: Id.optional(),
+    cursor: z.string().max(4096).optional(),
+    limit: z.coerce.number().int().min(1).max(200).default(100),
+    q: z.string().min(1).max(200).optional(),
+    include_unrepresented: z.enum(['true', 'false']).default('false'),
+});
+export const DirectoryResourceQuery = z.strictObject({ id: Id, dataset_id: Id.optional() });
+export const DirectoryIdentityQuery = z.strictObject({
+    source: Id,
+    kind: DirectoryKind,
+    key: Id,
+    dataset_id: Id.optional(),
+});
+export const DirectoryRelationshipQuery = DirectoryPageQuery.extend({
+    subject_id: Id,
+    relationship: DirectoryRelationshipSchema.shape.relationship.optional(),
+});
+function page(schema) {
+    return z.strictObject({
+        data: z.array(schema),
+        next_cursor: z.string().nullable(),
+        has_more: z.boolean(),
+        meta: z.record(z.string(), z.json()),
+    });
+}
+export const DirectoryEntityPage = page(DirectoryEntitySchema);
+export const DirectoryProfessionalQuery = DirectoryPageQuery.extend({
+    include_inventory: z.enum(['true', 'false']).optional(),
+});
+export const DirectoryInventorySummary = z.strictObject({
+    entity_id: Id,
+    active_listing_count: z.number().int().nonnegative(),
+    // Attribution on the first represented active listing, not verified affiliation.
+    office_name: z.string().nullable(),
+});
+export const DirectoryProfessionalPage = DirectoryEntityPage.extend({
+    inventory_summaries: z.array(DirectoryInventorySummary).max(200).optional(),
+});
+export const DirectoryRelationshipPage = page(DirectoryRelationshipSchema);
+export const DirectoryContactInput = DirectoryContactSchema.pick({
+    type: true,
+    purpose: true,
+}).extend({ value: z.string().min(1).max(2048) });
+export const DirectoryProfileWrite = z.strictObject({
+    dataset_id: Id.optional(),
+    producer_id: Id,
+    source: Id,
+    kind: DirectoryKind,
+    key: Id,
+    subject_version: z.string().regex(/^[1-9]\d*$/),
+    observed_at: Time,
+    fields: z.record(z.string().max(100), DirectoryValue),
+    contacts: z.array(DirectoryContactInput).max(20).default([]),
+    withdrawn_fields: z.array(z.string().max(100)).max(50).default([]),
+    withdrawn_contacts: z.array(z.string().max(100)).max(20).default([]),
+});
+export const DirectoryRelationshipWrite = z.strictObject({
+    dataset_id: Id.optional(),
+    producer_id: Id,
+    subject_id: Id,
+    object_id: Id,
+    relationship: z.enum(['affiliated_with', 'operates', 'member_of']),
+    subject_version: z.string().regex(/^[1-9]\d*$/),
+    current: z.boolean(),
+    observed_at: Time,
+    effective_from: Time.nullable().default(null),
+    effective_to: Time.nullable().default(null),
+});
+export const directoryOperations = {
+    directoryListProfessionals: {
+        input: DirectoryProfessionalQuery,
+        output: DirectoryProfessionalPage,
+    },
+    directoryListOffices: { input: DirectoryPageQuery, output: DirectoryEntityPage },
+    directoryListOrganizations: { input: DirectoryPageQuery, output: DirectoryEntityPage },
+    directoryListTeams: { input: DirectoryPageQuery, output: DirectoryEntityPage },
+    directoryGetEntity: { input: DirectoryResourceQuery, output: DirectoryEntitySchema },
+    directoryResolveAgent: { input: DirectoryResourceQuery, output: DirectoryEntitySchema },
+    directoryResolveIdentity: { input: DirectoryIdentityQuery, output: DirectoryEntitySchema },
+    directoryListRelationships: {
+        input: DirectoryRelationshipQuery,
+        output: DirectoryRelationshipPage,
+    },
+    directoryGetContacts: { input: DirectoryResourceQuery, output: DirectoryContactsSchema },
+    directoryGetMetrics: { input: DirectoryResourceQuery, output: DirectoryMetricsSchema },
+    directoryRecordProfile: { input: DirectoryProfileWrite, output: DirectoryEntitySchema },
+    directoryRecordRelationship: {
+        input: DirectoryRelationshipWrite,
+        output: DirectoryRelationshipSchema,
+    },
+};

package/contracts/src/index.d.ts

@@ -0,0 +1,18 @@
+export * from './schemas.js';
+export { operations } from './operations.js';
+export * from './catalog-inventory.js';
+export * from './platform-api.js';
+export * from './routes.js';
+export * from './openapi.js';
+export * from './publication.js';
+export * from './directory.js';
+export * from './smart-feed.js';
+export * from './professional-intelligence.js';
+export * from './location.js';
+export * from './location-serving.js';
+export * from './directory-sales.js';
+export * from './directory-identity.js';
+export * from './directory-execution.js';
+export * from './search.js';
+export * from './property-features.js';
+export * from './opportunity-events.js';

package/contracts/src/index.js

@@ -0,0 +1,18 @@
+export * from './schemas.js';
+export { operations } from './operations.js';
+export * from './catalog-inventory.js';
+export * from './platform-api.js';
+export * from './routes.js';
+export * from './openapi.js';
+export * from './publication.js';
+export * from './directory.js';
+export * from './smart-feed.js';
+export * from './professional-intelligence.js';
+export * from './location.js';
+export * from './location-serving.js';
+export * from './directory-sales.js';
+export * from './directory-identity.js';
+export * from './directory-execution.js';
+export * from './search.js';
+export * from './property-features.js';
+export * from './opportunity-events.js';

package/contracts/src/intelligence.d.ts

@@ -0,0 +1,366 @@
+import { z } from 'zod';
+export declare const JudgmentTask: z.ZodEnum<{
+    claim_verification: "claim_verification";
+    meaningful_text_change: "meaningful_text_change";
+    marketing_angle: "marketing_angle";
+    preference_relevance: "preference_relevance";
+    intent_routing: "intent_routing";
+    operational_triage: "operational_triage";
+}>;
+export declare const JudgmentRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    task: z.ZodLiteral<"claim_verification">;
+    claims: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    source_spans: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"meaningful_text_change">;
+    before: z.ZodString;
+    after: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"marketing_angle">;
+    product_brief: z.ZodString;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    source_spans: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    previous_messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"preference_relevance">;
+    preferences: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        importance: z.ZodEnum<{
+            required: "required";
+            preferred: "preferred";
+        }>;
+    }, z.core.$strict>>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"intent_routing">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"operational_triage">;
+    component: z.ZodEnum<{
+        source: "source";
+        unknown: "unknown";
+        api: "api";
+        worker: "worker";
+        model: "model";
+        database: "database";
+    }>;
+    sanitized_logs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "task">;
+export declare const JudgmentDecision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    task: z.ZodLiteral<"claim_verification">;
+    claims: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        verdict: z.ZodEnum<{
+            supported: "supported";
+            conflicting: "conflicting";
+            contradicted: "contradicted";
+            not_established: "not_established";
+        }>;
+        evidence_refs: z.ZodArray<z.ZodString>;
+        review_required: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"meaningful_text_change">;
+    change: z.ZodEnum<{
+        material: "material";
+        editorial: "editorial";
+        unchanged: "unchanged";
+        uncertain: "uncertain";
+    }>;
+    review_required: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"marketing_angle">;
+    selected_candidate_id: z.ZodNullable<z.ZodString>;
+    repeat_status: z.ZodEnum<{
+        unknown: "unknown";
+        novel: "novel";
+        repetition: "repetition";
+    }>;
+    evidence_refs: z.ZodArray<z.ZodString>;
+    review_required: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"preference_relevance">;
+    ranked: z.ZodArray<z.ZodObject<{
+        candidate_id: z.ZodString;
+        score: z.ZodNullable<z.ZodNumber>;
+        relevance: z.ZodEnum<{
+            unknown: "unknown";
+            relevant: "relevant";
+            not_relevant: "not_relevant";
+        }>;
+    }, z.core.$strict>>;
+    review_required: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"intent_routing">;
+    intent: z.ZodEnum<{
+        unknown: "unknown";
+        property_details: "property_details";
+        billing: "billing";
+        listing_correction: "listing_correction";
+        access_issue: "access_issue";
+        marketing_question: "marketing_question";
+        technical_issue: "technical_issue";
+        tour_request: "tour_request";
+        agent_help: "agent_help";
+        unsubscribe: "unsubscribe";
+        other: "other";
+    }>;
+    urgent: z.ZodNullable<z.ZodBoolean>;
+    review_required: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    task: z.ZodLiteral<"operational_triage">;
+    category: z.ZodEnum<{
+        unknown: "unknown";
+        auth: "auth";
+        source_format: "source_format";
+        rate_limit: "rate_limit";
+        transient_dependency: "transient_dependency";
+    }>;
+    severity: z.ZodEnum<{
+        unknown: "unknown";
+        informational: "informational";
+        degraded: "degraded";
+        blocking: "blocking";
+        critical: "critical";
+    }>;
+    recommended_check: z.ZodEnum<{
+        credential_configuration: "credential_configuration";
+        source_contract: "source_contract";
+        retry_budget: "retry_budget";
+        dependency_health: "dependency_health";
+        manual_review: "manual_review";
+    }>;
+    review_required: z.ZodBoolean;
+}, z.core.$strict>], "task">;
+export declare const JudgmentProvenance: z.ZodObject<{
+    provider: z.ZodEnum<{
+        openrouter: "openrouter";
+        vercel_gateway: "vercel_gateway";
+        fixture: "fixture";
+        disabled: "disabled";
+    }>;
+    requested_model: z.ZodString;
+    resolved_model: z.ZodNullable<z.ZodString>;
+    model_policy: z.ZodEnum<{
+        fixture: "fixture";
+        pinned: "pinned";
+        rolling_alias: "rolling_alias";
+    }>;
+    policy_revision: z.ZodString;
+    adapter_version: z.ZodString;
+    execution: z.ZodOptional<z.ZodLiteral<"deterministic_exact_comparison">>;
+}, z.core.$strict>;
+export declare const JudgmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    task: z.ZodEnum<{
+        claim_verification: "claim_verification";
+        meaningful_text_change: "meaningful_text_change";
+        marketing_angle: "marketing_angle";
+        preference_relevance: "preference_relevance";
+        intent_routing: "intent_routing";
+        operational_triage: "operational_triage";
+    }>;
+    task_version: z.ZodString;
+    state: z.ZodEnum<{
+        expired: "expired";
+        failed: "failed";
+        running: "running";
+        succeeded: "succeeded";
+    }>;
+    input_fingerprint: z.ZodString;
+    source_trust: z.ZodLiteral<"caller_supplied">;
+    provenance: z.ZodObject<{
+        provider: z.ZodEnum<{
+            openrouter: "openrouter";
+            vercel_gateway: "vercel_gateway";
+            fixture: "fixture";
+            disabled: "disabled";
+        }>;
+        requested_model: z.ZodString;
+        resolved_model: z.ZodNullable<z.ZodString>;
+        model_policy: z.ZodEnum<{
+            fixture: "fixture";
+            pinned: "pinned";
+            rolling_alias: "rolling_alias";
+        }>;
+        policy_revision: z.ZodString;
+        adapter_version: z.ZodString;
+        execution: z.ZodOptional<z.ZodLiteral<"deterministic_exact_comparison">>;
+    }, z.core.$strict>;
+    result: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        task: z.ZodLiteral<"claim_verification">;
+        claims: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            verdict: z.ZodEnum<{
+                supported: "supported";
+                conflicting: "conflicting";
+                contradicted: "contradicted";
+                not_established: "not_established";
+            }>;
+            evidence_refs: z.ZodArray<z.ZodString>;
+            review_required: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        task: z.ZodLiteral<"meaningful_text_change">;
+        change: z.ZodEnum<{
+            material: "material";
+            editorial: "editorial";
+            unchanged: "unchanged";
+            uncertain: "uncertain";
+        }>;
+        review_required: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        task: z.ZodLiteral<"marketing_angle">;
+        selected_candidate_id: z.ZodNullable<z.ZodString>;
+        repeat_status: z.ZodEnum<{
+            unknown: "unknown";
+            novel: "novel";
+            repetition: "repetition";
+        }>;
+        evidence_refs: z.ZodArray<z.ZodString>;
+        review_required: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        task: z.ZodLiteral<"preference_relevance">;
+        ranked: z.ZodArray<z.ZodObject<{
+            candidate_id: z.ZodString;
+            score: z.ZodNullable<z.ZodNumber>;
+            relevance: z.ZodEnum<{
+                unknown: "unknown";
+                relevant: "relevant";
+                not_relevant: "not_relevant";
+            }>;
+        }, z.core.$strict>>;
+        review_required: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        task: z.ZodLiteral<"intent_routing">;
+        intent: z.ZodEnum<{
+            unknown: "unknown";
+            property_details: "property_details";
+            billing: "billing";
+            listing_correction: "listing_correction";
+            access_issue: "access_issue";
+            marketing_question: "marketing_question";
+            technical_issue: "technical_issue";
+            tour_request: "tour_request";
+            agent_help: "agent_help";
+            unsubscribe: "unsubscribe";
+            other: "other";
+        }>;
+        urgent: z.ZodNullable<z.ZodBoolean>;
+        review_required: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        task: z.ZodLiteral<"operational_triage">;
+        category: z.ZodEnum<{
+            unknown: "unknown";
+            auth: "auth";
+            source_format: "source_format";
+            rate_limit: "rate_limit";
+            transient_dependency: "transient_dependency";
+        }>;
+        severity: z.ZodEnum<{
+            unknown: "unknown";
+            informational: "informational";
+            degraded: "degraded";
+            blocking: "blocking";
+            critical: "critical";
+        }>;
+        recommended_check: z.ZodEnum<{
+            credential_configuration: "credential_configuration";
+            source_contract: "source_contract";
+            retry_budget: "retry_budget";
+            dependency_health: "dependency_health";
+            manual_review: "manual_review";
+        }>;
+        review_required: z.ZodBoolean;
+    }, z.core.$strict>], "task">>;
+    error_code: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodISODateTime;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+    valid_until: z.ZodISODateTime;
+    cached: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const IntelligenceCapabilitySchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+        implemented: "implemented";
+        not_implemented: "not_implemented";
+    }>;
+    task_version: z.ZodNullable<z.ZodString>;
+    task_id: z.ZodNullable<z.ZodEnum<{
+        claim_verification: "claim_verification";
+        meaningful_text_change: "meaningful_text_change";
+        marketing_angle: "marketing_angle";
+        preference_relevance: "preference_relevance";
+        intent_routing: "intent_routing";
+        operational_triage: "operational_triage";
+    }>>;
+    input_kind: z.ZodString;
+    limitations: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const IntelligenceCapabilitiesSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        status: z.ZodEnum<{
+            implemented: "implemented";
+            not_implemented: "not_implemented";
+        }>;
+        task_version: z.ZodNullable<z.ZodString>;
+        task_id: z.ZodNullable<z.ZodEnum<{
+            claim_verification: "claim_verification";
+            meaningful_text_change: "meaningful_text_change";
+            marketing_angle: "marketing_angle";
+            preference_relevance: "preference_relevance";
+            intent_routing: "intent_routing";
+            operational_triage: "operational_triage";
+        }>>;
+        input_kind: z.ZodString;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    provider: z.ZodObject<{
+        provider: z.ZodEnum<{
+            openrouter: "openrouter";
+            vercel_gateway: "vercel_gateway";
+            fixture: "fixture";
+            disabled: "disabled";
+        }>;
+        requested_model: z.ZodString;
+        resolved_model: z.ZodNullable<z.ZodString>;
+        model_policy: z.ZodEnum<{
+            fixture: "fixture";
+            pinned: "pinned";
+            rolling_alias: "rolling_alias";
+        }>;
+        policy_revision: z.ZodString;
+        adapter_version: z.ZodString;
+        execution: z.ZodOptional<z.ZodLiteral<"deterministic_exact_comparison">>;
+    }, z.core.$strict>;
+    effects_enabled: z.ZodBoolean;
+    catalog_model: z.ZodString;
+    taxonomy_version: z.ZodString;
+}, z.core.$strict>;
+export type JudgmentInput = z.infer<typeof JudgmentRequest>;
+export type JudgmentResult = z.infer<typeof JudgmentSchema>;