@propertysimple/client 0.1.0 → 0.2.0

package/contracts/src/directory.js

@@ -1,179 +0,0 @@
-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/intelligence.d.ts

@@ -1,366 +0,0 @@
-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>;