@oxyhq/contracts 0.7.0 → 0.9.0

package/dist/types/deviceBoot.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Device-first bootstrap & token contracts (auth centralization, wave 1).
+ *
+ * SINGLE SOURCE OF TRUTH for the wire shape of the new device-first session
+ * bootstrap: the top-level `#oxy_boot=…` fragment the API hands back from
+ * `GET /auth/device/bootstrap`, the token bundle a boot code / web-session
+ * fast-path exchanges into, the persisted-refresh rotation, the native
+ * device-token issuance, the IdP chooser's device-resolve, and the first-party
+ * password login result (2FA arm vs. session arm). The API validates its OUTPUT
+ * against these schemas; every consumer (`@oxyhq/core`'s device-boot mixin, the
+ * SDK cold boot, the IdP chooser) validates its INPUT against the same
+ * definitions, so producer and consumers cannot drift.
+ *
+ * Design anchors (from the auth-centralization plan):
+ *  - The bootstrap fragment carries NO tokens and NO deviceId — only a
+ *    `state` echo (CSRF), a `reason`, a short-lived single-use `code`, and an
+ *    opaque `deviceToken`. Tokens are obtained by exchanging the `code` at
+ *    `POST /auth/device/exchange` (origin-bound GETDEL burn).
+ *  - Refresh is ONE rotating, single-use family shared by web and native.
+ *  - `loginResult` mirrors what `POST /auth/login` returns today
+ *    (`buildSessionAuthResponse` in the API's `session.controller.ts`): either a
+ *    2FA challenge (`{ twoFactorRequired: true, loginToken }`) or a session
+ *    payload. The session arm matches `SessionAuthResponse` EXACTLY, plus an
+ *    optional `refreshToken` the new server adds for the persisted-refresh lane.
+ *
+ * Nested-object response shapes are declared as explicit `interface`s with the
+ * runtime schema annotated `z.ZodType<Interface>` — the same rationale as
+ * `identity.ts` / `userResponse.ts`: a `z.infer<>` of a nested object schema can
+ * degrade to `{}` under a consumer's `moduleResolution: "node"` (node10), so the
+ * load-bearing shapes are pinned by literal interfaces. Flat request/response
+ * shapes (no nested-object hazard) are inferred via `z.infer<>`.
+ *
+ * Platform-agnostic — zod only, no react/react-native/expo. ESM-safe (no
+ * `require()`).
+ */
+import { z } from 'zod';
+import { type UserResponse } from './userResponse';
+/**
+ * Why the bootstrap hop resolved the way it did.
+ *  - `session` — the device cookie resolved an active session; a `code` is
+ *    present to exchange for tokens.
+ *  - `no_session` — the device is known but has no active session; no `code`.
+ *  - `new_device` — first contact; the cookie was just planted, no session yet.
+ */
+export declare const deviceBootReasonSchema: z.ZodEnum<["session", "no_session", "new_device"]>;
+export type DeviceBootReason = z.infer<typeof deviceBootReasonSchema>;
+/**
+ * The `#oxy_boot=<json>` fragment `GET /auth/device/bootstrap` appends to the
+ * `return_to` URL. Carries the CSRF `state` echo, the resolution `reason`, an
+ * optional single-use exchange `code` (present iff `reason === 'session'`), and
+ * the opaque `deviceToken`. NEVER carries tokens or a deviceId.
+ */
+export declare const deviceBootFragmentSchema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    state: z.ZodString;
+    reason: z.ZodEnum<["session", "no_session", "new_device"]>;
+    code: z.ZodOptional<z.ZodString>;
+    deviceToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    reason: "session" | "no_session" | "new_device";
+    v: 1;
+    state: string;
+    deviceToken: string;
+    code?: string | undefined;
+}, {
+    reason: "session" | "no_session" | "new_device";
+    v: 1;
+    state: string;
+    deviceToken: string;
+    code?: string | undefined;
+}>;
+export type DeviceBootFragment = z.infer<typeof deviceBootFragmentSchema>;
+/** Request body for `POST /auth/device/exchange` — the single-use boot code. */
+export declare const deviceExchangeRequestSchema: z.ZodObject<{
+    code: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+}, {
+    code: string;
+}>;
+export type DeviceExchangeRequest = z.infer<typeof deviceExchangeRequestSchema>;
+/**
+ * The token bundle returned by `POST /auth/device/exchange` and
+ * `POST /auth/device/web-session` — the freshly-minted access token, its
+ * rotating refresh-family head, the owning `sessionId`, and the full canonical
+ * user object. `expiresAt` is an ISO string.
+ */
+export interface AuthTokenBundle {
+    sessionId: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: string;
+    user: UserResponse;
+}
+export declare const authTokenBundleSchema: z.ZodType<AuthTokenBundle>;
+/** Request body for `POST /auth/refresh-token` — the current refresh token. */
+export declare const tokenRefreshRequestSchema: z.ZodObject<{
+    refreshToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    refreshToken: string;
+}, {
+    refreshToken: string;
+}>;
+export type TokenRefreshRequest = z.infer<typeof tokenRefreshRequestSchema>;
+/**
+ * Wire shape of `POST /auth/refresh-token`: the rotated (single-use) family —
+ * a new access token, the next refresh token, the new access-token expiry, and
+ * the owning session id. `expiresAt` is an ISO string.
+ */
+export declare const tokenRefreshResponseSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+    expiresAt: z.ZodString;
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    expiresAt: string;
+    accessToken: string;
+    sessionId: string;
+    refreshToken: string;
+}, {
+    expiresAt: string;
+    accessToken: string;
+    sessionId: string;
+    refreshToken: string;
+}>;
+export type TokenRefreshResponse = z.infer<typeof tokenRefreshResponseSchema>;
+/**
+ * Wire shape of `POST /auth/device/token` — issues (or rotates) the opaque
+ * device token for the native channel. The deviceId is taken from the bearer
+ * JWT claims server-side; only the token comes back.
+ */
+export declare const deviceTokenIssueResponseSchema: z.ZodObject<{
+    deviceToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    deviceToken: string;
+}, {
+    deviceToken: string;
+}>;
+export type DeviceTokenIssueResponse = z.infer<typeof deviceTokenIssueResponseSchema>;
+/**
+ * `POST /auth/login` when the account has 2FA enabled: a short-lived login
+ * token to be presented at the 2FA challenge, and no session yet.
+ */
+export interface LoginTwoFactorRequired {
+    twoFactorRequired: true;
+    loginToken: string;
+}
+/**
+ * `POST /auth/login` when authentication completed in one step. Matches the
+ * API's `SessionAuthResponse` EXACTLY (`buildSessionAuthResponse`), plus the
+ * optional `refreshToken` the persisted-refresh lane adds. `user` is the
+ * truncated session-user shape the login endpoint emits (NOT the full
+ * `userResponseSchema`).
+ */
+export interface LoginSessionResult {
+    sessionId: string;
+    deviceId: string;
+    expiresAt: string;
+    accessToken?: string;
+    refreshToken?: string;
+    user: {
+        id: string;
+        username?: string;
+        avatar?: string;
+    };
+}
+/** The discriminated outcome of `POST /auth/login`. */
+export type LoginResult = LoginTwoFactorRequired | LoginSessionResult;
+export declare const loginResultSchema: z.ZodType<LoginResult>;
+/**
+ * Request body for `POST /auth/device/resolve` (X-Oxy-Internal, called by the
+ * IdP chooser) — the device key the chooser read from the first-party
+ * `oxy_device` cookie.
+ */
+export declare const deviceResolveRequestSchema: z.ZodObject<{
+    deviceKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    deviceKey: string;
+}, {
+    deviceKey: string;
+}>;
+export type DeviceResolveRequest = z.infer<typeof deviceResolveRequestSchema>;
+/** One account resolved for the IdP chooser from a device's session set. */
+export interface DeviceResolveAccount {
+    user: UserResponse;
+    sessionId: string;
+    accessToken: string;
+    expiresAt: string;
+}
+/**
+ * Wire shape of `POST /auth/device/resolve` — the device's active account id
+ * (or `null` when signed out of all) plus every account signed in on the
+ * device. Replaces the IdP's `/auth/refresh-all` chooser feed.
+ */
+export interface DeviceResolveResponse {
+    activeAccountId: string | null;
+    accounts: DeviceResolveAccount[];
+}
+export declare const deviceResolveResponseSchema: z.ZodType<DeviceResolveResponse>;

package/dist/types/deviceSession.d.ts

@@ -0,0 +1,165 @@
+import { z } from 'zod';
+export declare const sessionAccountSchema: z.ZodObject<{
+    accountId: z.ZodString;
+    sessionId: z.ZodString;
+    authuser: z.ZodNumber;
+    operatedByUserId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    authuser: number;
+    sessionId: string;
+    accountId: string;
+    operatedByUserId?: string | undefined;
+}, {
+    authuser: number;
+    sessionId: string;
+    accountId: string;
+    operatedByUserId?: string | undefined;
+}>;
+export declare const deviceSessionStateSchema: z.ZodObject<{
+    deviceId: z.ZodString;
+    accounts: z.ZodArray<z.ZodObject<{
+        accountId: z.ZodString;
+        sessionId: z.ZodString;
+        authuser: z.ZodNumber;
+        operatedByUserId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        authuser: number;
+        sessionId: string;
+        accountId: string;
+        operatedByUserId?: string | undefined;
+    }, {
+        authuser: number;
+        sessionId: string;
+        accountId: string;
+        operatedByUserId?: string | undefined;
+    }>, "many">;
+    activeAccountId: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    updatedAt: number;
+    accounts: {
+        authuser: number;
+        sessionId: string;
+        accountId: string;
+        operatedByUserId?: string | undefined;
+    }[];
+    deviceId: string;
+    activeAccountId: string | null;
+    revision: number;
+}, {
+    updatedAt: number;
+    accounts: {
+        authuser: number;
+        sessionId: string;
+        accountId: string;
+        operatedByUserId?: string | undefined;
+    }[];
+    deviceId: string;
+    activeAccountId: string | null;
+    revision: number;
+}>;
+export declare const activeTokenSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    expiresAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    expiresAt: string;
+    accessToken: string;
+}, {
+    expiresAt: string;
+    accessToken: string;
+}>;
+export declare const deviceSessionSyncSchema: z.ZodObject<{
+    state: z.ZodObject<{
+        deviceId: z.ZodString;
+        accounts: z.ZodArray<z.ZodObject<{
+            accountId: z.ZodString;
+            sessionId: z.ZodString;
+            authuser: z.ZodNumber;
+            operatedByUserId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            authuser: number;
+            sessionId: string;
+            accountId: string;
+            operatedByUserId?: string | undefined;
+        }, {
+            authuser: number;
+            sessionId: string;
+            accountId: string;
+            operatedByUserId?: string | undefined;
+        }>, "many">;
+        activeAccountId: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        updatedAt: number;
+        accounts: {
+            authuser: number;
+            sessionId: string;
+            accountId: string;
+            operatedByUserId?: string | undefined;
+        }[];
+        deviceId: string;
+        activeAccountId: string | null;
+        revision: number;
+    }, {
+        updatedAt: number;
+        accounts: {
+            authuser: number;
+            sessionId: string;
+            accountId: string;
+            operatedByUserId?: string | undefined;
+        }[];
+        deviceId: string;
+        activeAccountId: string | null;
+        revision: number;
+    }>;
+    activeToken: z.ZodNullable<z.ZodObject<{
+        accessToken: z.ZodString;
+        expiresAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        expiresAt: string;
+        accessToken: string;
+    }, {
+        expiresAt: string;
+        accessToken: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    state: {
+        updatedAt: number;
+        accounts: {
+            authuser: number;
+            sessionId: string;
+            accountId: string;
+            operatedByUserId?: string | undefined;
+        }[];
+        deviceId: string;
+        activeAccountId: string | null;
+        revision: number;
+    };
+    activeToken: {
+        expiresAt: string;
+        accessToken: string;
+    } | null;
+}, {
+    state: {
+        updatedAt: number;
+        accounts: {
+            authuser: number;
+            sessionId: string;
+            accountId: string;
+            operatedByUserId?: string | undefined;
+        }[];
+        deviceId: string;
+        activeAccountId: string | null;
+        revision: number;
+    };
+    activeToken: {
+        expiresAt: string;
+        accessToken: string;
+    } | null;
+}>;
+export type SessionAccount = z.infer<typeof sessionAccountSchema>;
+export type DeviceSessionState = z.infer<typeof deviceSessionStateSchema>;
+export type ActiveToken = z.infer<typeof activeTokenSchema>;
+export type DeviceSessionSync = z.infer<typeof deviceSessionSyncSchema>;

package/dist/types/fedcmToken.d.ts

@@ -41,6 +41,13 @@ export declare const fedcmTokenPayloadSchema: z.ZodObject<{
     exp: z.ZodOptional<z.ZodNumber>;
     iat: z.ZodOptional<z.ZodNumber>;
     nonce: z.ZodOptional<z.ZodString>;
+    /**
+     * An explicit central deviceId minted by the IdP, threaded through so the
+     * RP session can inherit a unified device id instead of deriving one from
+     * the (userId, RP origin) stableDeviceKey. Optional and additive — omitted
+     * tokens fall back to the existing stableDeviceKey/UA-IP derivation.
+     */
+    deviceId: z.ZodOptional<z.ZodString>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     iss: z.ZodOptional<z.ZodString>;
     sub: z.ZodOptional<z.ZodString>;
@@ -48,6 +55,13 @@ export declare const fedcmTokenPayloadSchema: z.ZodObject<{
     exp: z.ZodOptional<z.ZodNumber>;
     iat: z.ZodOptional<z.ZodNumber>;
     nonce: z.ZodOptional<z.ZodString>;
+    /**
+     * An explicit central deviceId minted by the IdP, threaded through so the
+     * RP session can inherit a unified device id instead of deriving one from
+     * the (userId, RP origin) stableDeviceKey. Optional and additive — omitted
+     * tokens fall back to the existing stableDeviceKey/UA-IP derivation.
+     */
+    deviceId: z.ZodOptional<z.ZodString>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     iss: z.ZodOptional<z.ZodString>;
     sub: z.ZodOptional<z.ZodString>;
@@ -55,5 +69,12 @@ export declare const fedcmTokenPayloadSchema: z.ZodObject<{
     exp: z.ZodOptional<z.ZodNumber>;
     iat: z.ZodOptional<z.ZodNumber>;
     nonce: z.ZodOptional<z.ZodString>;
+    /**
+     * An explicit central deviceId minted by the IdP, threaded through so the
+     * RP session can inherit a unified device id instead of deriving one from
+     * the (userId, RP origin) stableDeviceKey. Optional and additive — omitted
+     * tokens fall back to the existing stableDeviceKey/UA-IP derivation.
+     */
+    deviceId: z.ZodOptional<z.ZodString>;
 }, z.ZodTypeAny, "passthrough">>;
 export type FedcmTokenPayload = z.infer<typeof fedcmTokenPayloadSchema>;

package/dist/types/identity.d.ts

@@ -39,19 +39,74 @@
  */
 import { z } from 'zod';
 /**
- * A single DID verification method. Mirrors the secp256k1 key entries the API
- * derives from `User.publicKey` + each `authMethods[]` of type `identity`.
- * `id` is a fragment reference within the DID document (e.g.
- * `did:web:oxy.so:u:<id>#key-1`); `controller` is the controlling DID;
- * `publicKeyHex` is the uncompressed/compressed secp256k1 public key in hex.
+ * A `EcdsaSecp256k1VerificationKey2019` verification method — the canonical Oxy
+ * key form. Mirrors the secp256k1 key entries the API derives from
+ * `User.publicKey` + each `authMethods[]` of type `identity`. `id` is a fragment
+ * reference within the DID document (e.g. `did:web:oxy.so:u:<id>#key-1`);
+ * `controller` is the controlling DID; `publicKeyHex` is the (uncompressed)
+ * secp256k1 public key in hex.
  */
-export interface VerificationMethod {
+export interface Secp256k1VerificationMethod {
     id: string;
     type: 'EcdsaSecp256k1VerificationKey2019';
     controller: string;
     publicKeyHex: string;
 }
-export declare const verificationMethodSchema: z.ZodType<VerificationMethod>;
+/**
+ * A `Multikey` verification method — the AtProto/Bluesky key form. The SAME
+ * secp256k1 key as an account's {@link Secp256k1VerificationMethod}, re-encoded
+ * the way atproto expects: `publicKeyMultibase` is the `did:key`-style multibase
+ * (`base58btc`, leading `z`) of the multicodec-prefixed (`0xe7 0x01`, secp256k1)
+ * COMPRESSED public key. This is the verification method a foreign Bluesky
+ * AppView reads when it routes to the user's bridge PDS; it is additive and only
+ * present for atproto-bridged self-sovereign accounts.
+ */
+export interface MultikeyVerificationMethod {
+    id: string;
+    type: 'Multikey';
+    controller: string;
+    publicKeyMultibase: string;
+}
+/**
+ * A single DID verification method — either the canonical Oxy secp256k1 form
+ * ({@link Secp256k1VerificationMethod}) or the atproto `Multikey` form
+ * ({@link MultikeyVerificationMethod}). Discriminated on `type`, so an
+ * `EcdsaSecp256k1VerificationKey2019` entry keeps its exact `publicKeyHex` shape
+ * (every document already served verifies byte-identically) and the `Multikey`
+ * entry carries `publicKeyMultibase`.
+ */
+export type VerificationMethod = Secp256k1VerificationMethod | MultikeyVerificationMethod;
+export declare const verificationMethodSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"EcdsaSecp256k1VerificationKey2019">;
+    controller: z.ZodString;
+    publicKeyHex: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "EcdsaSecp256k1VerificationKey2019";
+    controller: string;
+    publicKeyHex: string;
+}, {
+    id: string;
+    type: "EcdsaSecp256k1VerificationKey2019";
+    controller: string;
+    publicKeyHex: string;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"Multikey">;
+    controller: z.ZodString;
+    publicKeyMultibase: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "Multikey";
+    controller: string;
+    publicKeyMultibase: string;
+}, {
+    id: string;
+    type: "Multikey";
+    controller: string;
+    publicKeyMultibase: string;
+}>]>;
 /**
  * A DID service entry (the `service[]` array). Oxy publishes its API root and
  * profile endpoints here so a resolver can discover where to fetch the user's

package/dist/types/index.d.ts

@@ -15,10 +15,10 @@ export { applicationTypeSchema, publicApplicationSchema, sessionStatusSchema, }
 export type { ApplicationTypeContract, PublicApplicationResponse, SessionStatusResponse, } from './sessionStatus';
 export { fedcmTokenPayloadSchema, } from './fedcmToken';
 export type { FedcmTokenPayload, } from './fedcmToken';
-export { recommendationExcludeTypeSchema, recommendationBoostSchema, recommendationSignalWeightsSchema, recommendationRequestSchema, recommendationCountSchema, recommendationItemSchema, recommendationResponseSchema, appEndorsementInputSchema, appInterestInputSchema, appUserSignalIngestSchema, } from './recommendations';
-export type { RecommendationExcludeType, RecommendationBoost, RecommendationSignalWeights, RecommendationRequest, RecommendationCount, RecommendationItem, RecommendationResponse, AppEndorsementInput, AppInterestInput, AppUserSignalIngest, } from './recommendations';
+export { recommendationExcludeTypeSchema, recommendationBoostSchema, recommendationSignalWeightsSchema, recommendationRequestSchema, recommendationCountSchema, recommendationItemSchema, recommendationResponseSchema, appEndorsementInputSchema, appInterestInputSchema, appUserSignalIngestSchema, appAffinityEventTypeSchema, appAffinityEventSchema, appAffinityEventsIngestSchema, } from './recommendations';
+export type { RecommendationExcludeType, RecommendationBoost, RecommendationSignalWeights, RecommendationRequest, RecommendationCount, RecommendationItem, RecommendationResponse, AppEndorsementInput, AppInterestInput, AppUserSignalIngest, AppAffinityEventType, AppAffinityEvent, AppAffinityEventsIngest, } from './recommendations';
 export { verificationMethodSchema, didServiceSchema, didDocumentSchema, signedRecordEnvelopeSchema, verifiedDomainSchema, domainVerificationRequestSchema, domainVerificationInstructionsSchema, authMethodEntrySchema, authMethodsResponseSchema, exportAttestationSchema, exportBundleSchema, } from './identity';
-export type { VerificationMethod, DidService, DidDocument, SignedRecordEnvelope, VerifiedDomain, DomainVerificationRequest, DomainVerificationInstructions, AuthMethodEntry, AuthMethodsResponse, ExportAttestation, ExportBundle, } from './identity';
+export type { VerificationMethod, Secp256k1VerificationMethod, MultikeyVerificationMethod, DidService, DidDocument, SignedRecordEnvelope, VerifiedDomain, DomainVerificationRequest, DomainVerificationInstructions, AuthMethodEntry, AuthMethodsResponse, ExportAttestation, ExportBundle, } from './identity';
 export { oxySignedRecordTypeSchema, } from './oxyRecordTypes';
 export type { OxySignedRecordType, } from './oxyRecordTypes';
 export { chainHeadResponseSchema, logPageResponseSchema, } from './protocol';
@@ -27,3 +27,7 @@ export { publicCardSchema, signedPublicCardSchema, realLifeAttestationRecordSche
 export type { CardTrustTier, PersonhoodStatus, PublicCard, SignedPublicCard, RealLifeAttestationRecord, RealLifeAttestationResult, ValidationVerdict, ValidationRequestStatus, ValidationVerdictRecord, ValidationOpenRequest, ValidationOpenResult, ValidationRequestSummary, ValidationVoteResult, PersonhoodVouchRecord, PersonhoodBreakdown, PersonhoodStatusResult, VouchResult, CredentialStatus, CredentialRecord, VerifiableCredentialResponse, CredentialIssueResult, CredentialListResult, CredentialVerifyResult, } from './civic';
 export { linkPreviewSchema, linkPreviewBatchRequestSchema, linkPreviewBatchResponseSchema, linkPreviewResponseSchema, } from './links';
 export type { LinkPreviewStatus, LinkPreview, LinkPreviewBatchRequest, LinkPreviewBatchResponse, } from './links';
+export { sessionAccountSchema, deviceSessionStateSchema, activeTokenSchema, deviceSessionSyncSchema, } from './deviceSession';
+export type { SessionAccount, DeviceSessionState, ActiveToken, DeviceSessionSync, } from './deviceSession';
+export { deviceBootReasonSchema, deviceBootFragmentSchema, deviceExchangeRequestSchema, authTokenBundleSchema, tokenRefreshRequestSchema, tokenRefreshResponseSchema, deviceTokenIssueResponseSchema, loginResultSchema, deviceResolveRequestSchema, deviceResolveResponseSchema, } from './deviceBoot';
+export type { DeviceBootReason, DeviceBootFragment, DeviceExchangeRequest, AuthTokenBundle, TokenRefreshRequest, TokenRefreshResponse, DeviceTokenIssueResponse, LoginTwoFactorRequired, LoginSessionResult, LoginResult, DeviceResolveRequest, DeviceResolveAccount, DeviceResolveResponse, } from './deviceBoot';

package/dist/types/recommendations.d.ts

@@ -47,6 +47,7 @@ export declare const recommendationSignalWeightsSchema: z.ZodObject<{
     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;
@@ -55,6 +56,7 @@ export declare const recommendationSignalWeightsSchema: z.ZodObject<{
     interest?: number | undefined;
     appBoost?: number | undefined;
     repCandidate?: number | undefined;
+    affinity?: number | undefined;
 }, {
     verified?: number | undefined;
     graph?: number | undefined;
@@ -63,6 +65,7 @@ export declare const recommendationSignalWeightsSchema: z.ZodObject<{
     interest?: number | undefined;
     appBoost?: number | undefined;
     repCandidate?: number | undefined;
+    affinity?: number | undefined;
 }>;
 export type RecommendationSignalWeights = z.infer<typeof recommendationSignalWeightsSchema>;
 /**
@@ -100,6 +103,7 @@ export declare const recommendationRequestSchema: z.ZodObject<{
         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;
@@ -108,6 +112,7 @@ export declare const recommendationRequestSchema: z.ZodObject<{
         interest?: number | undefined;
         appBoost?: number | undefined;
         repCandidate?: number | undefined;
+        affinity?: number | undefined;
     }, {
         verified?: number | undefined;
         graph?: number | undefined;
@@ -116,6 +121,7 @@ export declare const recommendationRequestSchema: z.ZodObject<{
         interest?: number | undefined;
         appBoost?: number | undefined;
         repCandidate?: number | undefined;
+        affinity?: number | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     clientId?: string | undefined;
@@ -136,6 +142,7 @@ export declare const recommendationRequestSchema: z.ZodObject<{
         interest?: number | undefined;
         appBoost?: number | undefined;
         repCandidate?: number | undefined;
+        affinity?: number | undefined;
     } | undefined;
 }, {
     clientId?: string | undefined;
@@ -156,6 +163,7 @@ export declare const recommendationRequestSchema: z.ZodObject<{
         interest?: number | undefined;
         appBoost?: number | undefined;
         repCandidate?: number | undefined;
+        affinity?: number | undefined;
     } | undefined;
 }>;
 export type RecommendationRequest = z.infer<typeof recommendationRequestSchema>;
@@ -443,3 +451,92 @@ export declare const appUserSignalIngestSchema: z.ZodEffects<z.ZodObject<{
     }[] | 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;
+    weight?: number | undefined;
+    occurredAt?: string | undefined;
+    eventId?: string | undefined;
+}, {
+    type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+    fromUserId: string;
+    toUserId: string;
+    weight?: number | undefined;
+    occurredAt?: string | undefined;
+    eventId?: string | 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;
+        weight?: number | undefined;
+        occurredAt?: string | undefined;
+        eventId?: string | undefined;
+    }, {
+        type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+        fromUserId: string;
+        toUserId: string;
+        weight?: number | undefined;
+        occurredAt?: string | undefined;
+        eventId?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    events: {
+        type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+        fromUserId: string;
+        toUserId: string;
+        weight?: number | undefined;
+        occurredAt?: string | undefined;
+        eventId?: string | undefined;
+    }[];
+}, {
+    events: {
+        type: "like" | "reply" | "boost" | "follow" | "mention" | "profile_view" | "quote" | "repost";
+        fromUserId: string;
+        toUserId: string;
+        weight?: number | undefined;
+        occurredAt?: string | undefined;
+        eventId?: string | undefined;
+    }[];
+}>;
+export type AppAffinityEventsIngest = z.infer<typeof appAffinityEventsIngestSchema>;