@propertysimple/client 0.1.0 → 0.2.0

package/contracts/src/intelligence.js

@@ -1,157 +0,0 @@
-import { z } from 'zod';
-const Key = z.string().regex(/^[a-zA-Z0-9_-]{1,80}$/);
-const Text = z.string().min(1).max(4000);
-const Span = z.strictObject({ id: Key, text: Text });
-const Spans = z.array(Span).min(1).max(20);
-const Timestamp = z.iso.datetime({ offset: true });
-export const JudgmentTask = z.enum([
-    'claim_verification',
-    'meaningful_text_change',
-    'marketing_angle',
-    'preference_relevance',
-    'intent_routing',
-    'operational_triage',
-]);
-export const JudgmentRequest = z.discriminatedUnion('task', [
-    z.strictObject({
-        task: z.literal('claim_verification'),
-        claims: z.array(Span).min(1).max(10),
-        source_spans: Spans,
-    }),
-    z.strictObject({ task: z.literal('meaningful_text_change'), before: Text, after: Text }),
-    z.strictObject({
-        task: z.literal('marketing_angle'),
-        product_brief: z.string().min(1).max(1000),
-        candidates: z.array(Span).min(1).max(10),
-        source_spans: Spans,
-        previous_messages: z.array(Span).max(20),
-    }),
-    z.strictObject({
-        task: z.literal('preference_relevance'),
-        preferences: z
-            .array(z.strictObject({
-            id: Key,
-            text: z.string().min(1).max(1000),
-            importance: z.enum(['required', 'preferred']),
-        }))
-            .min(1)
-            .max(10),
-        candidates: z.array(Span).min(1).max(20),
-    }),
-    z.strictObject({ task: z.literal('intent_routing'), text: Text }),
-    z.strictObject({
-        task: z.literal('operational_triage'),
-        component: z.enum(['api', 'worker', 'source', 'model', 'database', 'unknown']),
-        sanitized_logs: z.array(Span).min(1).max(20),
-    }),
-]);
-const Verdict = z.enum(['supported', 'contradicted', 'not_established', 'conflicting']);
-const Intent = z.enum([
-    'billing',
-    'listing_correction',
-    'access_issue',
-    'marketing_question',
-    'technical_issue',
-    'tour_request',
-    'property_details',
-    'agent_help',
-    'unsubscribe',
-    'other',
-    'unknown',
-]);
-export const JudgmentDecision = z.discriminatedUnion('task', [
-    z.strictObject({
-        task: z.literal('claim_verification'),
-        claims: z
-            .array(z.strictObject({
-            id: Key,
-            verdict: Verdict,
-            evidence_refs: z.array(Key),
-            review_required: z.boolean(),
-        }))
-            .max(10),
-    }),
-    z.strictObject({
-        task: z.literal('meaningful_text_change'),
-        change: z.enum(['material', 'editorial', 'unchanged', 'uncertain']),
-        review_required: z.boolean(),
-    }),
-    z.strictObject({
-        task: z.literal('marketing_angle'),
-        selected_candidate_id: Key.nullable(),
-        repeat_status: z.enum(['novel', 'repetition', 'unknown']),
-        evidence_refs: z.array(Key),
-        review_required: z.boolean(),
-    }),
-    z.strictObject({
-        task: z.literal('preference_relevance'),
-        ranked: z
-            .array(z.strictObject({
-            candidate_id: Key,
-            score: z.number().min(0).max(3).nullable(),
-            relevance: z.enum(['relevant', 'not_relevant', 'unknown']),
-        }))
-            .max(20),
-        review_required: z.boolean(),
-    }),
-    z.strictObject({
-        task: z.literal('intent_routing'),
-        intent: Intent,
-        urgent: z.boolean().nullable(),
-        review_required: z.boolean(),
-    }),
-    z.strictObject({
-        task: z.literal('operational_triage'),
-        category: z.enum(['auth', 'source_format', 'rate_limit', 'transient_dependency', 'unknown']),
-        severity: z.enum(['informational', 'degraded', 'blocking', 'critical', 'unknown']),
-        recommended_check: z.enum([
-            'credential_configuration',
-            'source_contract',
-            'retry_budget',
-            'dependency_health',
-            'manual_review',
-        ]),
-        review_required: z.boolean(),
-    }),
-]);
-export const JudgmentProvenance = z.strictObject({
-    provider: z.enum(['openrouter', 'vercel_gateway', 'fixture', 'disabled']),
-    requested_model: z.string(),
-    resolved_model: z.string().nullable(),
-    model_policy: z.enum(['pinned', 'rolling_alias', 'fixture']),
-    policy_revision: z.string(),
-    adapter_version: z.string(),
-    /** A code-owned result retains the requested route but did not invoke it. */
-    execution: z.literal('deterministic_exact_comparison').optional(),
-});
-export const JudgmentSchema = z.strictObject({
-    id: z.string(),
-    task: JudgmentTask,
-    task_version: z.string(),
-    state: z.enum(['running', 'succeeded', 'failed', 'expired']),
-    input_fingerprint: z.string(),
-    source_trust: z.literal('caller_supplied'),
-    provenance: JudgmentProvenance,
-    result: JudgmentDecision.nullable(),
-    error_code: z.string().nullable(),
-    created_at: Timestamp,
-    completed_at: Timestamp.nullable(),
-    valid_until: Timestamp,
-    cached: z.boolean(),
-});
-export const IntelligenceCapabilitySchema = z.strictObject({
-    id: z.string(),
-    description: z.string(),
-    status: z.enum(['implemented', 'not_implemented']),
-    task_version: z.string().nullable(),
-    task_id: JudgmentTask.nullable(),
-    input_kind: z.string(),
-    limitations: z.array(z.string()),
-});
-export const IntelligenceCapabilitiesSchema = z.strictObject({
-    data: z.array(IntelligenceCapabilitySchema),
-    provider: JudgmentProvenance,
-    effects_enabled: z.boolean(),
-    catalog_model: z.string(),
-    taxonomy_version: z.string(),
-});

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

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

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

@@ -1,44 +0,0 @@
-import { z } from 'zod';
-export declare const PublicationReportRequest: z.ZodObject<{
-    dataset_id: z.ZodString;
-    listing_id: z.ZodString;
-    sequence: z.ZodString;
-    state: z.ZodEnum<{
-        unavailable: "unavailable";
-        available: "available";
-    }>;
-    url: z.ZodNullable<z.ZodURL>;
-    listing_revision: z.ZodString;
-    listing_published_at: z.ZodISODateTime;
-    observed_at: z.ZodISODateTime;
-}, z.core.$strict>;
-export declare const PublicationReceipt: z.ZodObject<{
-    listing_id: z.ZodString;
-    product_id: z.ZodString;
-    sequence: z.ZodString;
-    state: z.ZodEnum<{
-        unavailable: "unavailable";
-        available: "available";
-    }>;
-    expires_at: z.ZodISODateTime;
-}, z.core.$strict>;
-export declare const DestinationQuery: z.ZodObject<{
-    id: z.ZodString;
-    dataset_id: z.ZodString;
-    product_id: z.ZodString;
-}, z.core.$strict>;
-export declare const DestinationResponse: z.ZodObject<{
-    listing_id: z.ZodString;
-    product_id: z.ZodString;
-    url: z.ZodNullable<z.ZodString>;
-    available: z.ZodBoolean;
-    reason: z.ZodEnum<{
-        unavailable: "unavailable";
-        expired: "expired";
-        available: "available";
-        not_reported: "not_reported";
-        listing_changed: "listing_changed";
-        source_stale: "source_stale";
-    }>;
-    checked_at: z.ZodISODateTime;
-}, z.core.$strict>;

package/contracts/src/publication.js

@@ -1,42 +0,0 @@
-import { z } from 'zod';
-// Products report their own publication state. This is not a license to publish a listing.
-const Identifier = z.string().min(1).max(256);
-export const PublicationReportRequest = z
-    .strictObject({
-    dataset_id: Identifier,
-    listing_id: Identifier,
-    sequence: z.string().regex(/^[1-9]\d{0,17}$/),
-    state: z.enum(['available', 'unavailable']),
-    url: z.url().max(2048).nullable(),
-    listing_revision: z.string().min(1).max(64),
-    listing_published_at: z.iso.datetime({ offset: true }),
-    observed_at: z.iso.datetime({ offset: true }),
-})
-    .refine((input) => (input.state === 'unavailable' ? input.url === null : input.url !== null), 'Available publications need a URL; unavailable publications must clear it.');
-export const PublicationReceipt = z.strictObject({
-    listing_id: Identifier,
-    product_id: Identifier,
-    sequence: z.string(),
-    state: z.enum(['available', 'unavailable']),
-    expires_at: z.iso.datetime({ offset: true }),
-});
-export const DestinationQuery = z.strictObject({
-    id: Identifier,
-    dataset_id: Identifier,
-    product_id: Identifier,
-});
-export const DestinationResponse = z.strictObject({
-    listing_id: Identifier,
-    product_id: Identifier,
-    url: z.string().nullable(),
-    available: z.boolean(),
-    reason: z.enum([
-        'available',
-        'not_reported',
-        'unavailable',
-        'expired',
-        'listing_changed',
-        'source_stale',
-    ]),
-    checked_at: z.iso.datetime({ offset: true }),
-});