@oxy.so/contracts 1.0.0

package/dist/types/protocol.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Generic "Oxy Protocol" record surface — the app-agnostic conventions every app
+ * follows to decentralize its own content on the shared signed-record substrate.
+ *
+ * The base `signedRecordEnvelopeSchema` (`./identity`) is the WIRE grammar: a
+ * signed envelope whose `type` is an open string and whose `record` is an opaque
+ * `Record<string, unknown>`. An app layers its own LEXICON on top of that
+ * grammar — a typed projection of the `record` payload, addressed by an
+ * AtProto-style `(collection, rkey)` key — WITHOUT forking the envelope schema.
+ *
+ * ## Recipe — defining an app lexicon record
+ *
+ * For each record kind an app wants to publish:
+ *
+ * 1. Define the `record` PAYLOAD schema as a `z.ZodType<XPayload>` (e.g.
+ *    `app.mention.feed.post` → `mentionPostRecordSchema: z.ZodType<MentionPost>`).
+ *    This validates ONLY the inner `record`, not the envelope.
+ * 2. Declare the `collection` NSID as a constant (e.g.
+ *    `export const MENTION_POST_COLLECTION = 'app.mention.feed.post'`).
+ * 3. Reuse the UNCHANGED {@link signedRecordEnvelopeSchema} for the envelope. The
+ *    base treats `record` as `z.record(z.unknown())`, so the app validates the
+ *    envelope with the base schema first, then parses `envelope.record` with its
+ *    own payload schema. {@link LexiconRecord} is the typed projection that pairs
+ *    the `(collection, rkey)` key with the parsed payload.
+ *
+ * The Oxy civic contracts (`./civic`) already follow this convention implicitly:
+ * each civic record (`real_life_attestation`, `personhood_vouch`, `credential`,
+ * …) ships a `record`-payload schema and is carried by the base envelope.
+ *
+ * ## Chain-wire shapes
+ *
+ * {@link ChainHeadResponse} and {@link LogPageResponse} are the shared response
+ * shapes every chain store exposes (Oxy's `GET /identity/records/:userId/chain/head`,
+ * `GET /identity/head/:userId`, `GET /identity/log/:userId`, and any app node's
+ * equivalents). They are defined ONCE here so producers and consumers (the API
+ * handlers, the SDK identity/nodes mixins, app nodes) cannot drift.
+ *
+ * Platform-agnostic — zod only, no react/react-native/expo, ESM-safe.
+ */
+import { z } from 'zod';
+import { type SignedRecordEnvelope } from './identity';
+/**
+ * The typed projection of a signed envelope's `record` payload, addressed by an
+ * AtProto-style `(collection, rkey)` key.
+ *
+ * - `collection` is the lexicon NSID (e.g. `app.mention.feed.post`) — the
+ *   envelope's `collection` field.
+ * - `rkey` is the record key within the collection (e.g. a post id) — the
+ *   envelope's `rkey` field.
+ * - `record` is the app-typed payload (`TPayload`) the app validated out of the
+ *   envelope's opaque `record`.
+ *
+ * This is a COMPILE-TIME convenience only: the wire shape is the base envelope.
+ * An app builds a `LexiconRecord<TPayload>` from a verified envelope by parsing
+ * `envelope.record` with its own `z.ZodType<TPayload>` payload schema.
+ */
+export interface LexiconRecord<TPayload> {
+    collection: string;
+    rkey: string;
+    record: TPayload;
+}
+/**
+ * The current head of a subject's per-subject hash chain.
+ *
+ * `headRecordId` is the content address of the latest record (or `null` when the
+ * subject has no chain yet); `seq` is its sequence number (`-1` when there is no
+ * chain — so the next record's coordinates are always `seq: head.seq + 1`,
+ * genesis `0`, and `prev: head.headRecordId`, genesis `null`); `recordCount` is
+ * the total number of records on the chain.
+ */
+export interface ChainHeadResponse {
+    headRecordId: string | null;
+    seq: number;
+    recordCount: number;
+}
+export declare const chainHeadResponseSchema: z.ZodType<ChainHeadResponse>;
+/**
+ * An ordered page of a subject's verified signed-record chain — the FULL
+ * envelopes (so a node or any verifier re-checks them independently). `count` is
+ * `records.length`, echoed for convenience.
+ */
+export interface LogPageResponse {
+    records: SignedRecordEnvelope[];
+    count: number;
+}
+export declare const logPageResponseSchema: z.ZodType<LogPageResponse>;

package/dist/types/recommendations.d.ts

@@ -0,0 +1,542 @@
+/**
+ * Recommendation-engine API contracts.
+ *
+ * SINGLE SOURCE OF TRUTH for the wire shape of the reputation-weighted
+ * profile-recommendation surface (`POST /profiles/recommendations`) and the
+ * cross-app signal-ingest endpoint (`POST /app-signals/ingest`). The API
+ * validates its INPUT/OUTPUT against these schemas; consumer SDKs validate the
+ * same definitions, so the producer and every consumer cannot drift.
+ *
+ * Platform-agnostic — zod is the only runtime dependency (no react / react-native
+ * / expo, ESM-safe).
+ */
+import { z } from 'zod';
+/** User-type filters a caller may exclude from the recommendation surface. */
+export declare const recommendationExcludeTypeSchema: z.ZodEnum<["federated", "agent", "automated"]>;
+export type RecommendationExcludeType = z.infer<typeof recommendationExcludeTypeSchema>;
+/**
+ * A caller-supplied editorial boost. `userIds` are nudged up (or down, for a
+ * negative weight) in the ranking; the optional `reason` is for audit/telemetry
+ * only and never surfaced to end users. Boost members still pass the eligibility
+ * gate — a boost cannot resurrect a private/restricted/ineligible account.
+ */
+export declare const recommendationBoostSchema: z.ZodObject<{
+    userIds: z.ZodArray<z.ZodString, "many">;
+    weight: z.ZodNumber;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    userIds: string[];
+    weight: number;
+    reason?: string | undefined;
+}, {
+    userIds: string[];
+    weight: number;
+    reason?: string | undefined;
+}>;
+export type RecommendationBoost = z.infer<typeof recommendationBoostSchema>;
+/**
+ * Per-request overrides for the scoring signal weights. Every key is optional
+ * and clamped server-side to the resolved weight profile's allowed range — a
+ * caller can re-weight signals but never escape the profile's bounds.
+ */
+export declare const recommendationSignalWeightsSchema: z.ZodObject<{
+    graph: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    completeness: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    verified: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    curation: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    interest: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    appBoost: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    repCandidate: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    affinity: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    verified?: number | undefined;
+    graph?: number | undefined;
+    completeness?: number | undefined;
+    curation?: number | undefined;
+    interest?: number | undefined;
+    appBoost?: number | undefined;
+    repCandidate?: number | undefined;
+    affinity?: number | undefined;
+}, {
+    verified?: number | undefined;
+    graph?: number | undefined;
+    completeness?: number | undefined;
+    curation?: number | undefined;
+    interest?: number | undefined;
+    appBoost?: number | undefined;
+    repCandidate?: number | undefined;
+    affinity?: number | undefined;
+}>;
+export type RecommendationSignalWeights = z.infer<typeof recommendationSignalWeightsSchema>;
+/**
+ * Request body for `POST /profiles/recommendations`.
+ *
+ * `clientId` selects the per-app weight profile (the Application `_id`); when
+ * omitted the default profile is used. `excludeIds` removes accounts the caller
+ * has already seen/handled; `boosts` and `signalWeights` let the caller bias the
+ * ranking within server-enforced bounds.
+ */
+export declare const recommendationRequestSchema: z.ZodObject<{
+    clientId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    excludeTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["federated", "agent", "automated"]>, "many">>;
+    excludeIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    boosts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        userIds: z.ZodArray<z.ZodString, "many">;
+        weight: z.ZodNumber;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        userIds: string[];
+        weight: number;
+        reason?: string | undefined;
+    }, {
+        userIds: string[];
+        weight: number;
+        reason?: string | undefined;
+    }>, "many">>;
+    signalWeights: z.ZodOptional<z.ZodObject<{
+        graph: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        completeness: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        verified: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        curation: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        interest: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        appBoost: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        repCandidate: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        affinity: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        verified?: number | undefined;
+        graph?: number | undefined;
+        completeness?: number | undefined;
+        curation?: number | undefined;
+        interest?: number | undefined;
+        appBoost?: number | undefined;
+        repCandidate?: number | undefined;
+        affinity?: number | undefined;
+    }, {
+        verified?: number | undefined;
+        graph?: number | undefined;
+        completeness?: number | undefined;
+        curation?: number | undefined;
+        interest?: number | undefined;
+        appBoost?: number | undefined;
+        repCandidate?: number | undefined;
+        affinity?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    clientId?: string | undefined;
+    offset?: number | undefined;
+    excludeTypes?: ("agent" | "federated" | "automated")[] | undefined;
+    excludeIds?: string[] | undefined;
+    boosts?: {
+        userIds: string[];
+        weight: number;
+        reason?: string | undefined;
+    }[] | undefined;
+    signalWeights?: {
+        verified?: number | undefined;
+        graph?: number | undefined;
+        completeness?: number | undefined;
+        curation?: number | undefined;
+        interest?: number | undefined;
+        appBoost?: number | undefined;
+        repCandidate?: number | undefined;
+        affinity?: number | undefined;
+    } | undefined;
+}, {
+    limit?: number | undefined;
+    clientId?: string | undefined;
+    offset?: number | undefined;
+    excludeTypes?: ("agent" | "federated" | "automated")[] | undefined;
+    excludeIds?: string[] | undefined;
+    boosts?: {
+        userIds: string[];
+        weight: number;
+        reason?: string | undefined;
+    }[] | undefined;
+    signalWeights?: {
+        verified?: number | undefined;
+        graph?: number | undefined;
+        completeness?: number | undefined;
+        curation?: number | undefined;
+        interest?: number | undefined;
+        appBoost?: number | undefined;
+        repCandidate?: number | undefined;
+        affinity?: number | undefined;
+    } | undefined;
+}>;
+export type RecommendationRequest = z.infer<typeof recommendationRequestSchema>;
+/** Follower/following counts attached to a recommendation item. */
+export declare const recommendationCountSchema: z.ZodObject<{
+    followers: z.ZodNumber;
+    following: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    following: number;
+    followers: number;
+}, {
+    following: number;
+    followers: number;
+}>;
+export type RecommendationCount = z.infer<typeof recommendationCountSchema>;
+/**
+ * A single recommended profile.
+ *
+ * `name` reuses the canonical {@link userNameSchema} so `name.displayName` is the
+ * already-resolved server-side value. `score` and `matchedSignals` are present
+ * only on the scored (v2) path; `mutualCount` and `_count` are always present.
+ */
+export declare const recommendationItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    username: z.ZodOptional<z.ZodString>;
+    name: z.ZodType<import("./userResponse").UserNameResponse, z.ZodTypeDef, import("./userResponse").UserNameResponse>;
+    avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    trustTier: z.ZodOptional<z.ZodString>;
+    mutualCount: z.ZodNumber;
+    score: z.ZodOptional<z.ZodNumber>;
+    matchedSignals: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isFederated: z.ZodOptional<z.ZodBoolean>;
+    isAgent: z.ZodOptional<z.ZodBoolean>;
+    isAutomated: z.ZodOptional<z.ZodBoolean>;
+    instance: z.ZodOptional<z.ZodString>;
+    _count: z.ZodObject<{
+        followers: z.ZodNumber;
+        following: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        following: number;
+        followers: number;
+    }, {
+        following: number;
+        followers: number;
+    }>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    username: z.ZodOptional<z.ZodString>;
+    name: z.ZodType<import("./userResponse").UserNameResponse, z.ZodTypeDef, import("./userResponse").UserNameResponse>;
+    avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    trustTier: z.ZodOptional<z.ZodString>;
+    mutualCount: z.ZodNumber;
+    score: z.ZodOptional<z.ZodNumber>;
+    matchedSignals: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isFederated: z.ZodOptional<z.ZodBoolean>;
+    isAgent: z.ZodOptional<z.ZodBoolean>;
+    isAutomated: z.ZodOptional<z.ZodBoolean>;
+    instance: z.ZodOptional<z.ZodString>;
+    _count: z.ZodObject<{
+        followers: z.ZodNumber;
+        following: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        following: number;
+        followers: number;
+    }, {
+        following: number;
+        followers: number;
+    }>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    username: z.ZodOptional<z.ZodString>;
+    name: z.ZodType<import("./userResponse").UserNameResponse, z.ZodTypeDef, import("./userResponse").UserNameResponse>;
+    avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    trustTier: z.ZodOptional<z.ZodString>;
+    mutualCount: z.ZodNumber;
+    score: z.ZodOptional<z.ZodNumber>;
+    matchedSignals: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isFederated: z.ZodOptional<z.ZodBoolean>;
+    isAgent: z.ZodOptional<z.ZodBoolean>;
+    isAutomated: z.ZodOptional<z.ZodBoolean>;
+    instance: z.ZodOptional<z.ZodString>;
+    _count: z.ZodObject<{
+        followers: z.ZodNumber;
+        following: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        following: number;
+        followers: number;
+    }, {
+        following: number;
+        followers: number;
+    }>;
+}, z.ZodTypeAny, "passthrough">>;
+export type RecommendationItem = z.infer<typeof recommendationItemSchema>;
+/** Wire shape of the recommendation response — an array of items. */
+export declare const recommendationResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    username: z.ZodOptional<z.ZodString>;
+    name: z.ZodType<import("./userResponse").UserNameResponse, z.ZodTypeDef, import("./userResponse").UserNameResponse>;
+    avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    trustTier: z.ZodOptional<z.ZodString>;
+    mutualCount: z.ZodNumber;
+    score: z.ZodOptional<z.ZodNumber>;
+    matchedSignals: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isFederated: z.ZodOptional<z.ZodBoolean>;
+    isAgent: z.ZodOptional<z.ZodBoolean>;
+    isAutomated: z.ZodOptional<z.ZodBoolean>;
+    instance: z.ZodOptional<z.ZodString>;
+    _count: z.ZodObject<{
+        followers: z.ZodNumber;
+        following: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        following: number;
+        followers: number;
+    }, {
+        following: number;
+        followers: number;
+    }>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    username: z.ZodOptional<z.ZodString>;
+    name: z.ZodType<import("./userResponse").UserNameResponse, z.ZodTypeDef, import("./userResponse").UserNameResponse>;
+    avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    trustTier: z.ZodOptional<z.ZodString>;
+    mutualCount: z.ZodNumber;
+    score: z.ZodOptional<z.ZodNumber>;
+    matchedSignals: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isFederated: z.ZodOptional<z.ZodBoolean>;
+    isAgent: z.ZodOptional<z.ZodBoolean>;
+    isAutomated: z.ZodOptional<z.ZodBoolean>;
+    instance: z.ZodOptional<z.ZodString>;
+    _count: z.ZodObject<{
+        followers: z.ZodNumber;
+        following: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        following: number;
+        followers: number;
+    }, {
+        following: number;
+        followers: number;
+    }>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    username: z.ZodOptional<z.ZodString>;
+    name: z.ZodType<import("./userResponse").UserNameResponse, z.ZodTypeDef, import("./userResponse").UserNameResponse>;
+    avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    trustTier: z.ZodOptional<z.ZodString>;
+    mutualCount: z.ZodNumber;
+    score: z.ZodOptional<z.ZodNumber>;
+    matchedSignals: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isFederated: z.ZodOptional<z.ZodBoolean>;
+    isAgent: z.ZodOptional<z.ZodBoolean>;
+    isAutomated: z.ZodOptional<z.ZodBoolean>;
+    instance: z.ZodOptional<z.ZodString>;
+    _count: z.ZodObject<{
+        followers: z.ZodNumber;
+        following: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        following: number;
+        followers: number;
+    }, {
+        following: number;
+        followers: number;
+    }>;
+}, z.ZodTypeAny, "passthrough">>, "many">;
+export type RecommendationResponse = z.infer<typeof recommendationResponseSchema>;
+/** One endorsement edge an app reports: `ownerId` endorses `memberId`. */
+export declare const appEndorsementInputSchema: z.ZodObject<{
+    ownerId: z.ZodString;
+    memberId: z.ZodString;
+    op: z.ZodDefault<z.ZodEnum<["add", "remove"]>>;
+    sourceId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    ownerId: string;
+    memberId: string;
+    op: "add" | "remove";
+    sourceId?: string | undefined;
+}, {
+    ownerId: string;
+    memberId: string;
+    op?: "add" | "remove" | undefined;
+    sourceId?: string | undefined;
+}>;
+export type AppEndorsementInput = z.infer<typeof appEndorsementInputSchema>;
+/** One interest signal an app reports: how interested `userId` is in a topic. */
+export declare const appInterestInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    interestScore: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    interestScore: number;
+}, {
+    userId: string;
+    interestScore: number;
+}>;
+export type AppInterestInput = z.infer<typeof appInterestInputSchema>;
+/**
+ * Request body for `POST /app-signals/ingest` (service token, `signals:write`).
+ *
+ * At least one of `endorsements` / `interests` must be non-empty — an ingest
+ * with neither is a no-op and rejected so a misconfigured caller is surfaced
+ * rather than silently succeeding.
+ */
+export declare const appUserSignalIngestSchema: z.ZodEffects<z.ZodObject<{
+    endorsements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ownerId: z.ZodString;
+        memberId: z.ZodString;
+        op: z.ZodDefault<z.ZodEnum<["add", "remove"]>>;
+        sourceId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        ownerId: string;
+        memberId: string;
+        op: "add" | "remove";
+        sourceId?: string | undefined;
+    }, {
+        ownerId: string;
+        memberId: string;
+        op?: "add" | "remove" | undefined;
+        sourceId?: string | undefined;
+    }>, "many">>;
+    interests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        interestScore: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+        interestScore: number;
+    }, {
+        userId: string;
+        interestScore: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    endorsements?: {
+        ownerId: string;
+        memberId: string;
+        op: "add" | "remove";
+        sourceId?: string | undefined;
+    }[] | undefined;
+    interests?: {
+        userId: string;
+        interestScore: number;
+    }[] | undefined;
+}, {
+    endorsements?: {
+        ownerId: string;
+        memberId: string;
+        op?: "add" | "remove" | undefined;
+        sourceId?: string | undefined;
+    }[] | undefined;
+    interests?: {
+        userId: string;
+        interestScore: number;
+    }[] | undefined;
+}>, {
+    endorsements?: {
+        ownerId: string;
+        memberId: string;
+        op: "add" | "remove";
+        sourceId?: string | undefined;
+    }[] | undefined;
+    interests?: {
+        userId: string;
+        interestScore: number;
+    }[] | undefined;
+}, {
+    endorsements?: {
+        ownerId: string;
+        memberId: string;
+        op?: "add" | "remove" | undefined;
+        sourceId?: string | undefined;
+    }[] | undefined;
+    interests?: {
+        userId: string;
+        interestScore: number;
+    }[] | undefined;
+}>;
+export type AppUserSignalIngest = z.infer<typeof appUserSignalIngestSchema>;
+/**
+ * The directed interaction types a consuming app may report between two users.
+ * Each type carries a server-side default weight (see the API's
+ * `AFFINITY_EVENT_WEIGHTS`); a caller may override the applied weight per event.
+ */
+export declare const appAffinityEventTypeSchema: z.ZodEnum<["like", "reply", "boost", "follow", "mention", "profile_view", "quote", "repost"]>;
+export type AppAffinityEventType = z.infer<typeof appAffinityEventTypeSchema>;
+/**
+ * One directed interaction event: `fromUserId` interacted with `toUserId`
+ * (`type`) at `occurredAt`. The Oxy affinity-graph folds these into a per-app,
+ * time-decayed directed affinity edge (`fromUserId → toUserId`).
+ *
+ * - `weight` (optional) overrides the per-type default weight for this event.
+ * - `occurredAt` (optional, ISO) is the event time; absent means "now" at ingest.
+ * - `eventId` (optional) makes an event idempotent — a repeated `eventId` for the
+ *   same application is folded at most once (bounded dedup window).
+ */
+export declare const appAffinityEventSchema: z.ZodObject<{
+    fromUserId: z.ZodString;
+    toUserId: z.ZodString;
+    type: z.ZodEnum<["like", "reply", "boost", "follow", "mention", "profile_view", "quote", "repost"]>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    occurredAt: z.ZodOptional<z.ZodString>;
+    eventId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+    fromUserId: string;
+    toUserId: string;
+    eventId?: string | undefined;
+    occurredAt?: string | undefined;
+    weight?: number | undefined;
+}, {
+    type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+    fromUserId: string;
+    toUserId: string;
+    eventId?: string | undefined;
+    occurredAt?: string | undefined;
+    weight?: number | undefined;
+}>;
+export type AppAffinityEvent = z.infer<typeof appAffinityEventSchema>;
+/**
+ * Request body for `POST /app-signals/events` (service token, `signals:write`).
+ *
+ * A non-empty batch (1..1000) of directed interaction events for the requesting
+ * application. Self-edges (`fromUserId === toUserId`) are dropped server-side.
+ */
+export declare const appAffinityEventsIngestSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        fromUserId: z.ZodString;
+        toUserId: z.ZodString;
+        type: z.ZodEnum<["like", "reply", "boost", "follow", "mention", "profile_view", "quote", "repost"]>;
+        weight: z.ZodOptional<z.ZodNumber>;
+        occurredAt: z.ZodOptional<z.ZodString>;
+        eventId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+        fromUserId: string;
+        toUserId: string;
+        eventId?: string | undefined;
+        occurredAt?: string | undefined;
+        weight?: number | undefined;
+    }, {
+        type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+        fromUserId: string;
+        toUserId: string;
+        eventId?: string | undefined;
+        occurredAt?: string | undefined;
+        weight?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    events: {
+        type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+        fromUserId: string;
+        toUserId: string;
+        eventId?: string | undefined;
+        occurredAt?: string | undefined;
+        weight?: number | undefined;
+    }[];
+}, {
+    events: {
+        type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+        fromUserId: string;
+        toUserId: string;
+        eventId?: string | undefined;
+        occurredAt?: string | undefined;
+        weight?: number | undefined;
+    }[];
+}>;
+export type AppAffinityEventsIngest = z.infer<typeof appAffinityEventsIngestSchema>;