@propertysimple/client 0.1.0

package/contracts/src/schemas.js

@@ -0,0 +1,674 @@
+import { z } from 'zod';
+import { CatalogInventoryStatusSchema } from './catalog-inventory.js';
+import { LocationSchema } from './location.js';
+import { redactListingAddress } from './location-serving.js';
+import { SharedListingFields, SourceFieldsSchema, ProfessionalContactsSchema, } from './catalog-fields.js';
+export * from './catalog-fields.js';
+export * from './intelligence.js';
+/** Wire types are intentionally independent of database rows and provider payloads. */
+export const Id = z.string().min(1).max(256);
+export const Timestamp = z.iso.datetime({ offset: true });
+export const DateOnly = z.iso.date();
+export const Json = z.json();
+export const Empty = z.strictObject({});
+export const PrincipalSchema = z.strictObject({
+    subject_id: Id,
+    tenant_id: Id,
+    product_id: Id,
+    environment: z.enum(['development', 'test', 'production']),
+    scopes: z.array(z.string()),
+    dataset_ids: z.array(Id),
+    profile_ids: z.array(Id),
+    audience_ids: z.array(Id),
+    account_ids: z.array(Id),
+    producer_ids: z.array(Id),
+});
+export const ProblemSchema = z.strictObject({
+    type: z.string(),
+    title: z.string(),
+    status: z.number().int(),
+    detail: z.string(),
+    code: z.string(),
+    request_id: z.string(),
+    retryable: z.boolean(),
+    details: Json.optional(),
+});
+export const PageQuery = z.strictObject({
+    cursor: z.string().min(1).max(4096).optional(),
+    limit: z.coerce.number().int().min(1).max(200).default(100),
+});
+export const ResourceQuery = z.strictObject({ id: Id });
+export const ResourcePageQuery = PageQuery.extend({ id: Id });
+export const DatasetPageQuery = PageQuery.extend({ dataset_id: Id.optional() });
+export const MarketStatus = z.enum([
+    'active',
+    'active_under_contract',
+    'pending',
+    'sold',
+    'withdrawn',
+    'expired',
+    'unknown',
+]);
+export const Money = z.strictObject({
+    amount: z.string().regex(/^\d+(?:\.\d{1,2})?$/),
+    currency: z.string().regex(/^[A-Z]{3}$/),
+    period: z.string().nullable(),
+});
+export const Address = z.strictObject({
+    street: z.string().nullable(),
+    unit: z.string().nullable(),
+    city: z.string().nullable(),
+    region: z.string().nullable(),
+    postal_code: z.string().nullable(),
+    country: z.string().nullable(),
+});
+export const AttributeAssessment = z.strictObject({
+    attribute: Id,
+    value: z.union([z.string(), z.boolean(), z.number(), z.null()]),
+    evidence_state: z.enum(['supported', 'explicitly_absent', 'not_stated', 'conflicting']),
+    origin: z.enum(['source_structured', 'source_text_interpreted']),
+    evidence_refs: z.array(z.string()),
+    input_fingerprint: z.string(),
+    taxonomy_version: z.string(),
+    evaluation_id: Id,
+    freshness: z.enum(['current', 'invalidated', 'pending', 'failed']),
+});
+/** Public attribution excludes email and private lead-routing destinations. */
+export const ImageRenditionSchema = z.strictObject({
+    url: z.url(),
+    // Bounding dimensions, not the actual dimensions: the CDN preserves aspect
+    // ratio and never upscales. Consumers must not treat these as srcset widths.
+    max_width: z.number().int().positive(),
+    max_height: z.number().int().positive(),
+});
+export const ListingMediaSchema = z.strictObject({
+    url: z.url(),
+    order: z.number().int().nonnegative(),
+    caption: z.string().nullable(),
+    width: z.number().int().positive().nullable(),
+    height: z.number().int().positive().nullable(),
+    modified_at: Timestamp.nullable(),
+    delivery: z.enum(['source_url', 'hosted']),
+    renditions: z
+        .strictObject({
+        thumbnail: ImageRenditionSchema,
+        map: ImageRenditionSchema,
+        card: ImageRenditionSchema,
+        gallery: ImageRenditionSchema,
+    })
+        .optional(),
+});
+export const ListingAttributionSchema = z.strictObject({
+    agent_name: z.string().nullable(),
+    agent_license: z.string().nullable().optional(),
+    office_name: z.string().nullable(),
+    office_key: z.string().nullable(),
+    office_phone: z.string().nullable(),
+    office_website: z.url().nullable(),
+    broker_name: z.string().nullable(),
+    broker_phone: z.string().nullable().optional(),
+    originating_system: z.string().nullable(),
+});
+export const PropertyDetailsSchema = z.strictObject({
+    category: z.string().nullable(),
+    sub_type: z.string().nullable(),
+    bathrooms_full: z.number().nonnegative().nullable(),
+    bathrooms_half: z.number().nonnegative().nullable(),
+    bathrooms_one_quarter: z.number().nonnegative().nullable().optional(),
+    bathrooms_three_quarter: z.number().nonnegative().nullable().optional(),
+    stories: z.number().nonnegative().nullable(),
+    garage_spaces: z.number().nonnegative().nullable(),
+    parking_total: z.number().nonnegative().nullable(),
+    county: z.string().nullable(),
+    subdivision: z.string().nullable(),
+    features: z.record(z.string(), z.array(z.string())),
+    // Additive source detail fields: old snapshots remain readable. False is a
+    // supplied assertion; a missing key is unknown, never an inferred negative.
+    source_flags: z
+        .partialRecord(z.enum([
+        'AssociationYN',
+        'AttachedGarageYN',
+        'BasementYN',
+        'CarportYN',
+        'CoolingYN',
+        'ElectricOnPropertyYN',
+        'FireplaceYN',
+        'GarageYN',
+        'HeatingYN',
+        'NewConstructionYN',
+        'PoolPrivateYN',
+        'SpaYN',
+        'WaterfrontYN',
+        'AccessibleElevatorInstalled',
+        'Dock',
+    ]), z.boolean())
+        .optional(),
+    association_fees: z
+        .array(z.strictObject({
+        kind: z.enum(['association', 'association_secondary']),
+        amount: z
+            .string()
+            .regex(/^\d+(?:\.\d{1,2})?$/)
+            .nullable(),
+        amount_state: z.enum(['supported', 'not_stated', 'unknown']),
+        currency: z
+            .string()
+            .regex(/^[A-Z]{3}$/)
+            .nullable(),
+        currency_source: z.enum(['field', 'source_default']).nullable(),
+        currency_state: z.enum(['supported', 'not_stated', 'unknown']),
+        period: z
+            .enum(['day', 'week', 'month', 'quarter', 'half_year', 'year', 'one_time'])
+            .nullable(),
+        period_state: z.enum(['supported', 'not_stated', 'unknown']),
+        source_paths: z.array(z.string()),
+    }))
+        .optional(),
+    rooms: z
+        .array(z.strictObject({
+        type: z.string().nullable(),
+        level: z.string().nullable(),
+        features: z.array(z.string()),
+        dimensions: z.string().nullable(),
+        length: z.number().nonnegative().nullable(),
+        width: z.number().nonnegative().nullable(),
+        unit: z.string().nullable(),
+        source_paths: z.array(z.string()),
+    }))
+        .optional(),
+    year_built_effective: z.number().int().nonnegative().nullable().optional(),
+    units_total: z.number().int().nonnegative().nullable().optional(),
+    entry_level: z.number().nonnegative().nullable().optional(),
+});
+export const CatalogProfile = z.enum(['catalog', 'portal_active']);
+export const ListingDetailQuery = ResourceQuery.extend({
+    profile: CatalogProfile.optional(),
+    dataset_id: Id.optional(),
+});
+const ListingWireSchema = z.strictObject({
+    ...SharedListingFields,
+    id: Id,
+    episode_id: Id,
+    revision: z.string(),
+    property_id: Id.nullable().optional(),
+    source_identities: z.array(z.strictObject({ source: Id, key: Id })),
+    market_status: MarketStatus,
+    source_availability: z.enum(['present', 'removed_unknown']),
+    display_eligibility: z.boolean(),
+    price: Money.nullable(),
+    // Optional so historical snapshots remain readable by the coordinated SDK.
+    // Unknown/conflicting source evidence never becomes an inferred sale or rental.
+    transaction_type: z.enum(['for_sale', 'for_rent', 'unknown', 'conflicting']).optional(),
+    price_period_state: z.enum(['supported', 'not_stated', 'unknown', 'conflicting']).optional(),
+    address: Address,
+    listing_agent_ids: z.array(Id),
+    description: z.string().nullable(),
+    photos: z.array(z.string()),
+    /** Total gallery size. Search hits contain only a cover; detail/feed contain all photos. */
+    photo_count: z.number().int().nonnegative().optional(),
+    media: z.array(ListingMediaSchema).optional(),
+    attribution: ListingAttributionSchema.optional(),
+    property_details: PropertyDetailsSchema.optional(),
+    raw_status: z.string().nullable().optional(),
+    property_type: z.string().nullable(),
+    bedrooms: z.number().nullable(),
+    bathrooms: z.number().nullable(),
+    living_area: z.number().nullable(),
+    living_area_unit: z.string().nullable().optional(),
+    lot_size: z.number().nullable().optional(),
+    lot_size_unit: z.string().nullable().optional(),
+    year_built: z.number().int().nullable().optional(),
+    latitude: z.number().min(-90).max(90).nullable().optional(),
+    longitude: z.number().min(-180).max(180).nullable().optional(),
+    location: LocationSchema.optional(),
+    mls_number: z.string().nullable().optional(),
+    source_url: z.string().nullable(),
+    listed_date: z.string().nullable(),
+    listed_precision: z.enum(['date', 'instant', 'unknown']),
+    open_houses: z.array(z.strictObject({
+        id: Id,
+        start_at: z.string(),
+        end_at: z.string().nullable(),
+        timezone: z.string().nullable(),
+        status: z.enum(['scheduled', 'cancelled']),
+    })),
+    classifications: z.array(AttributeAssessment),
+    display: z.strictObject({ address_allowed: z.boolean(), disclaimer: z.string().nullable() }),
+    freshness: z.strictObject({
+        last_seen_at: Timestamp,
+        published_at: Timestamp,
+        source_modified_at: Timestamp.nullable(),
+    }),
+});
+// Strict validation runs first. Redaction also protects older stored payloads at
+// the API/SDK boundary without changing identities, revisions or listing status.
+export const ListingSchema = ListingWireSchema.overwrite(redactListingAddress);
+/** Contact routing is server-only and never embedded in public listing projections. */
+export const ListingContactsSchema = z.strictObject({
+    professionals: ProfessionalContactsSchema.optional(),
+    source_fields: SourceFieldsSchema.optional(),
+    listing_id: Id,
+    agent_name: z.string().nullable(),
+    agent_email: z.email().nullable(),
+    agent_phone: z.string().nullable(),
+    agent_license: z.string().nullable(),
+    agent_website: z.url().nullable(),
+    lead_routing_email: z.email().nullable(),
+    preferred_email: z.email().nullable(),
+});
+export const AgentSchema = z.strictObject({
+    id: Id,
+    source_identities: z.array(z.strictObject({ source: Id, key: Id })),
+    name: z.string().nullable(),
+    first_name: z.string().nullable().optional(),
+    last_name: z.string().nullable().optional(),
+    email: z.email().nullable().optional(),
+    office_phone: z.string().nullable().optional(),
+    primary_contact_phone: z.string().nullable().optional(),
+    website_url: z.string().nullable().optional(),
+    listings_count_total: z.number().int().nullable().optional(),
+    listings_count_active: z.number().int().nullable().optional(),
+    mls_id: z.string().nullable().optional(),
+    license: z.string().nullable().optional(),
+    fax: z.string().nullable().optional(),
+    profile_observation: z
+        .strictObject({
+        observed_at: Timestamp,
+        source_modified_at: Timestamp.nullable(),
+        basis: z.literal('retained_source_profile'),
+    })
+        .optional(),
+    inventory: z
+        .strictObject({
+        as_of: Timestamp,
+        source: Id,
+        basis: z.literal('current_visible_catalog'),
+        coverage: z.literal('imported_inventory_only'),
+    })
+        .optional(),
+});
+const ListingQueryFields = DatasetPageQuery.extend({
+    transaction_type: z.enum(['for_sale', 'for_rent']).optional(),
+    price_period: z.string().min(1).max(40).optional(),
+    profile: CatalogProfile.optional(),
+    sort: z
+        .enum(['id', 'price_asc', 'price_desc', 'newest', 'bedrooms_desc', 'source_modified_desc'])
+        .optional(),
+    include_total: z.union([z.boolean(), z.enum(['true', 'false'])]).optional(),
+    city: z.string().min(1).max(200).optional(),
+    region: z.string().min(1).max(100).optional(),
+    postal_code: z.string().min(1).max(30).optional(),
+    property_type: z.string().min(1).max(100).optional(),
+    currency: z
+        .string()
+        .regex(/^[A-Z]{3}$/)
+        .optional(),
+    max_bedrooms: z.coerce.number().min(0).max(100).optional(),
+    min_bathrooms: z.coerce.number().min(0).max(100).optional(),
+    max_bathrooms: z.coerce.number().min(0).max(100).optional(),
+    min_living_area: z.coerce.number().min(0).max(100000000).optional(),
+    max_living_area: z.coerce.number().min(0).max(100000000).optional(),
+    living_area_unit: z.enum(['sqft', 'sqm']).optional(),
+    q: z.string().min(1).max(500).optional(),
+    address_q: z.string().trim().min(2).max(500).optional(),
+    market_status: MarketStatus.optional(),
+    agent_id: Id.optional(),
+    party_id: Id.optional(),
+    inventory_basis: z.literal('listing_representation').optional(),
+    mls_number: z.string().max(128).optional(),
+    modified_since: Timestamp.optional(),
+    source_modified_since: Timestamp.optional(),
+    min_price: z
+        .string()
+        .regex(/^\d+(?:\.\d{1,2})?$/)
+        .optional(),
+    max_price: z
+        .string()
+        .regex(/^\d+(?:\.\d{1,2})?$/)
+        .optional(),
+    min_bedrooms: z.coerce.number().min(0).max(100).optional(),
+    features: z.array(z.string().min(1).max(80)).max(20).optional(),
+    bbox: z
+        .string()
+        .max(128)
+        .refine((value) => {
+        if (!/^-?\d+(?:\.\d+)?,-?\d+(?:\.\d+)?,-?\d+(?:\.\d+)?,-?\d+(?:\.\d+)?$/.test(value))
+            return false;
+        const parts = value.split(',').map(Number);
+        return (parts.length === 4 &&
+            parts.every(Number.isFinite) &&
+            parts[0] >= -180 &&
+            parts[2] <= 180 &&
+            parts[1] >= -90 &&
+            parts[3] <= 90 &&
+            parts[0] <= parts[2] &&
+            parts[1] <= parts[3]);
+    }, 'Use west,south,east,north within geographic bounds, without crossing the antimeridian.')
+        .optional(),
+});
+const explicitPartyInventory = (query) => Boolean(query.party_id) === Boolean(query.inventory_basis);
+const partyInventoryMessage = {
+    message: 'party_id and inventory_basis=listing_representation must be supplied together.',
+};
+export const ListingQuery = ListingQueryFields.refine(explicitPartyInventory, partyInventoryMessage);
+export const IdentityQuery = z.strictObject({ source: Id, key: Id });
+export const IdentitySchema = z.strictObject({
+    source: Id,
+    key: Id,
+    listing_id: Id,
+    episode_id: Id,
+});
+export const AgentIdentitySchema = z.strictObject({ source: Id, key: Id, agent_id: Id });
+export function page(item) {
+    return z.strictObject({
+        data: z.array(item),
+        next_cursor: z.string().nullable(),
+        has_more: z.boolean(),
+        meta: z.record(z.string(), Json),
+    });
+}
+/** Operational source health is live metadata; immutable listing snapshots keep their original observation times. */
+export const CatalogSourceFreshnessSchema = z.strictObject({
+    source: Id,
+    last_completed_enumeration_at: Timestamp.nullable(),
+    last_full_enumeration_at: Timestamp.nullable(),
+    state: z.enum(['fresh', 'stale', 'never_completed']),
+    freshness_window_seconds: z.number().int().positive(),
+    /** Continuous sources separate change-scan freshness from withdrawal coverage. */
+    full_enumeration_window_seconds: z.number().int().positive().optional(),
+    /** A provider response is not proof that enumeration or withdrawals completed. */
+    last_contact_at: Timestamp.nullable().optional(),
+    last_contact_status: z.number().int().min(100).max(599).nullable().optional(),
+    refresh: z
+        .strictObject({
+        state: z.enum(['on_schedule', 'delayed', 'blocked']),
+        cadence_seconds: z.number().int().positive(),
+        next_due_at: Timestamp,
+        phase: z.string().nullable(),
+        last_attempt_at: Timestamp.nullable(),
+        last_progress_at: Timestamp.nullable(),
+        last_error_at: Timestamp.nullable(),
+        error_code: z.string().nullable(),
+        consecutive_failures: z.number().int().nonnegative(),
+    })
+        .optional(),
+});
+export const CatalogHealthQuery = z.strictObject({ dataset_id: Id });
+export const CatalogHealthSchema = z.strictObject({
+    dataset_id: Id,
+    source_freshness: z.array(CatalogSourceFreshnessSchema),
+    inventory: CatalogInventoryStatusSchema.optional(),
+    checked_at: Timestamp,
+});
+export const ListingPage = page(ListingSchema);
+export const ListingMapQuery = ListingQueryFields.omit({
+    cursor: true,
+    limit: true,
+    sort: true,
+    include_total: true,
+})
+    .extend({
+    bbox: ListingQueryFields.shape.bbox.unwrap(),
+    limit: z.coerce.number().int().min(1).max(1000).default(500),
+})
+    .refine(explicitPartyInventory, partyInventoryMessage);
+export const ListingMapSchema = z.strictObject({
+    data: z.array(z.strictObject({
+        id: Id,
+        latitude: z.number(),
+        longitude: z.number(),
+        price: Money.nullable(),
+        property_type: z.string().nullable(),
+        market_status: MarketStatus,
+    })),
+    total: z.number().int().nonnegative(),
+    truncated: z.boolean(),
+    meta: z.record(z.string(), Json),
+});
+export const SimilarListingQuery = z.strictObject({
+    id: Id,
+    dataset_id: Id.optional(),
+    profile: CatalogProfile.optional(),
+    limit: z.coerce.number().int().min(1).max(20).default(6),
+});
+export const SimilarListingsSchema = z.strictObject({
+    data: z.array(z.strictObject({
+        listing: ListingSchema,
+        score: z.number().min(0).max(100),
+        reasons: z.array(z.string()),
+    })),
+    method: z.literal('facts_similarity_v1'),
+    candidate_count: z.number().int().nonnegative(),
+    candidates_truncated: z.boolean(),
+});
+export const SnapshotRequest = z.strictObject({ dataset_id: Id });
+export const SnapshotSchema = z.strictObject({
+    id: Id,
+    dataset_id: Id,
+    status: z.enum(['building', 'ready', 'failed', 'expired']),
+    schema_version: z.string(),
+    snapshot_sequence: z.string(),
+    replay_cursor: z.string(),
+    created_at: Timestamp,
+    expires_at: Timestamp,
+    count: z.number().int().nonnegative().optional(),
+});
+export const CatalogChangeSchema = z.strictObject({
+    id: Id,
+    sequence: z.string(),
+    listing_id: Id,
+    revision: z.string(),
+    operation: z.enum(['upsert', 'remove']),
+    listing: ListingSchema.nullable(),
+    published_at: Timestamp,
+});
+export const DomainEventSchema = z.strictObject({
+    id: Id,
+    sequence: z.string(),
+    listing_id: Id,
+    episode_id: Id,
+    type: z.string(),
+    occurred_at: Timestamp,
+    observed_at: Timestamp,
+    evidence: z.record(z.string(), Json),
+});
+export const ClassificationDefinitionSchema = z.strictObject({
+    taxonomy_version: z.string(),
+    attributes: z.array(z.strictObject({
+        id: Id,
+        description: z.string(),
+        type: z.enum(['boolean', 'string', 'number']),
+        values: z.array(z.string()).optional(),
+    })),
+});
+export const ActionProfileSchema = z.strictObject({
+    id: Id,
+    family: Id,
+    purpose: z.string(),
+    owner_product: Id,
+    channel: z.enum(['email', 'social', 'ads']),
+    target_unit: z.enum(['contact_actions', 'content_actions', 'ad_candidates']),
+    timezone: z.string(),
+    policy_revision: z.string(),
+    required_context: z.array(z.string()),
+    enabled: z.boolean(),
+});
+export const OpportunityQuery = PageQuery.extend({
+    profile_id: Id,
+    account_id: Id.optional(),
+    agent_id: Id.optional(),
+});
+export const OpportunitySchema = z.strictObject({
+    id: Id,
+    profile_id: Id,
+    listing_id: Id,
+    episode_id: Id,
+    recipient_id: Id,
+    intent_id: Id,
+    primary_angle: z.string(),
+    trigger_event_ids: z.array(Id),
+    supporting_evidence_refs: z.array(z.string()),
+    reason_codes: z.array(z.string()),
+    priority_index: z.number(),
+    valid_until: Timestamp,
+    decision_revision: z.string(),
+});
+export const PlanRequest = z.strictObject({
+    profile_id: Id,
+    business_date: DateOnly,
+    audience_id: Id,
+    target: z.strictObject({
+        count: z.number().int().min(1).max(100000),
+        unit: z.enum(['contact_actions', 'content_actions', 'ad_candidates']),
+    }),
+    run_slot: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[a-z0-9_-]+$/),
+});
+export const PlanSchema = z.strictObject({
+    id: Id,
+    profile_id: Id,
+    business_date: DateOnly,
+    timezone: z.string(),
+    status: z.enum(['queued', 'building', 'ready', 'failed', 'cancelled', 'expired']),
+    requested_count: z.number().int().nonnegative(),
+    selected_count: z.number().int().nonnegative(),
+    unique_recipients: z.number().int().nonnegative(),
+    reserve_count: z.number().int().nonnegative(),
+    shortfall: z.number().int().nonnegative(),
+    completeness: z.enum(['pending', 'complete', 'partial']),
+    decision_mode: z.enum(['jev', 'cached_jev', 'fixture']),
+    created_at: Timestamp,
+    expires_at: Timestamp,
+    policy_revision: z.string(),
+    exclusions: z.record(z.string(), z.number().int().nonnegative()),
+    cutoffs: z.record(z.string(), z.string()),
+    execution_counts: z.record(z.string(), z.number().int().nonnegative()).optional(),
+});
+export const ActionState = z.enum([
+    'unclaimed',
+    'reserved',
+    'dispatching',
+    'accepted',
+    'delivered',
+    'rejected',
+    'invalidated',
+    'unknown',
+]);
+export const PlanItemReplacementSchema = z.strictObject({
+    item_id: Id,
+    opportunity_id: Id,
+    listing_id: Id,
+    recipient_id: Id,
+    reason: z.string(),
+    replaced_at: Timestamp,
+});
+export const PlanItemSchema = z.strictObject({
+    id: Id,
+    slot: z.number().int(),
+    rank: z.number().int(),
+    opportunity_id: Id,
+    listing_id: Id,
+    episode_id: Id,
+    recipient_id: Id,
+    primary_angle: z.string(),
+    trigger_event_ids: z.array(Id),
+    supporting_evidence_refs: z.array(z.string()),
+    reason_codes: z.array(z.string()),
+    valid_until: Timestamp,
+    execution_state: ActionState,
+    action_id: Id.nullable(),
+    // Selection facts remain the original snapshot; this names the reserve executing its logical slot.
+    replacement: PlanItemReplacementSchema.optional(),
+});
+export const DispatchRequest = z.strictObject({
+    plan_id: Id,
+    limit: z.number().int().min(1).max(100),
+    worker_id: Id,
+});
+export const DispatchActionSchema = z.strictObject({
+    id: Id,
+    plan_item_id: Id,
+    listing_id: Id,
+    recipient_id: Id,
+    action_kind: z.string(),
+    lease_token: z.string(),
+    lease_expires_at: Timestamp,
+    endpoint: z.string(),
+    payload: z.record(z.string(), Json),
+});
+export const DispatchBatchSchema = z.strictObject({
+    id: Id,
+    plan_id: Id,
+    actions: z.array(DispatchActionSchema),
+    exhausted: z.boolean(),
+});
+export const AttemptRequest = z.strictObject({ id: Id, lease_token: z.string().min(1).max(1024) });
+export const AttemptSchema = z.strictObject({
+    id: Id,
+    action_id: Id,
+    provider_idempotency_key: z.string(),
+    state: z.literal('dispatching'),
+    started_at: Timestamp,
+    replayed: z.boolean(),
+});
+export const ActionOutcomeSchema = z.strictObject({
+    event_id: Id,
+    action_id: Id,
+    attempt_id: Id,
+    provider: Id,
+    provider_event_id: Id,
+    outcome: z.enum(['accepted', 'delivered', 'rejected', 'unknown', 'bounced', 'complained']),
+    occurred_at: Timestamp,
+    details: z.record(z.string(), Json).optional(),
+});
+export const OutcomesRequest = z.strictObject({
+    outcomes: z.array(ActionOutcomeSchema).min(1).max(100),
+});
+export const ProductContextEventSchema = z.strictObject({
+    event_id: Id,
+    producer_id: Id,
+    stream_epoch: Id,
+    coverage_id: Id,
+    subject_id: Id,
+    subject_type: Id,
+    subject_version: z.number().int().nonnegative(),
+    stream_sequence: z.number().int().nonnegative(),
+    type: z.string().min(1).max(128),
+    occurred_at: Timestamp,
+    payload: z.record(z.string(), Json),
+});
+export const ContextEventsRequest = z.strictObject({
+    events: z.array(ProductContextEventSchema).min(1).max(100),
+});
+export const BatchResultSchema = z.strictObject({
+    results: z.array(z.strictObject({
+        event_id: Id,
+        status: z.enum(['accepted', 'duplicate', 'rejected']),
+        code: z.string().nullable(),
+    })),
+});
+export const WebhookRequest = z.strictObject({
+    url: z.url(),
+    dataset_id: Id,
+    event_types: z.array(z.string()).min(1).max(20),
+});
+export const WebhookSchema = z.strictObject({
+    id: Id,
+    url: z.string(),
+    status: z.enum(['pending_verification', 'active', 'disabled']),
+});
+export const CapabilitiesSchema = z.strictObject({
+    api_version: z.literal('v1'),
+    dataset_ids: z.array(Id),
+    profile_ids: z.array(Id),
+    features: z.array(z.string()),
+    limits: z.record(z.string(), z.number()),
+});
+export const ReadinessSchema = z.strictObject({
+    ready: z.boolean(),
+    mode: z.string(),
+    checks: z.array(z.strictObject({ name: z.string(), ready: z.boolean(), detail: z.string() })),
+});