@oxyhq/contracts 0.6.0 → 0.8.0

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, {
+    accountId: string;
+    sessionId: string;
+    authuser: number;
+    operatedByUserId?: string | undefined;
+}, {
+    accountId: string;
+    sessionId: string;
+    authuser: number;
+    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, {
+        accountId: string;
+        sessionId: string;
+        authuser: number;
+        operatedByUserId?: string | undefined;
+    }, {
+        accountId: string;
+        sessionId: string;
+        authuser: number;
+        operatedByUserId?: string | undefined;
+    }>, "many">;
+    activeAccountId: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    updatedAt: number;
+    deviceId: string;
+    accounts: {
+        accountId: string;
+        sessionId: string;
+        authuser: number;
+        operatedByUserId?: string | undefined;
+    }[];
+    activeAccountId: string | null;
+    revision: number;
+}, {
+    updatedAt: number;
+    deviceId: string;
+    accounts: {
+        accountId: string;
+        sessionId: string;
+        authuser: number;
+        operatedByUserId?: string | undefined;
+    }[];
+    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, {
+            accountId: string;
+            sessionId: string;
+            authuser: number;
+            operatedByUserId?: string | undefined;
+        }, {
+            accountId: string;
+            sessionId: string;
+            authuser: number;
+            operatedByUserId?: string | undefined;
+        }>, "many">;
+        activeAccountId: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        updatedAt: number;
+        deviceId: string;
+        accounts: {
+            accountId: string;
+            sessionId: string;
+            authuser: number;
+            operatedByUserId?: string | undefined;
+        }[];
+        activeAccountId: string | null;
+        revision: number;
+    }, {
+        updatedAt: number;
+        deviceId: string;
+        accounts: {
+            accountId: string;
+            sessionId: string;
+            authuser: number;
+            operatedByUserId?: string | undefined;
+        }[];
+        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;
+        deviceId: string;
+        accounts: {
+            accountId: string;
+            sessionId: string;
+            authuser: number;
+            operatedByUserId?: string | undefined;
+        }[];
+        activeAccountId: string | null;
+        revision: number;
+    };
+    activeToken: {
+        expiresAt: string;
+        accessToken: string;
+    } | null;
+}, {
+    state: {
+        updatedAt: number;
+        deviceId: string;
+        accounts: {
+            accountId: string;
+            sessionId: string;
+            authuser: number;
+            operatedByUserId?: string | undefined;
+        }[];
+        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
@@ -85,14 +140,6 @@ export interface DidDocument {
     service: DidService[];
 }
 export declare const didDocumentSchema: z.ZodType<DidDocument>;
-/**
- * The category of a signed record. v1 only ever carried `identity` / `profile`
- * (already in production); v2 widens the union with the civic record types
- * (reputation attestations, real-life / peer validations, personhood vouches,
- * verifiable credentials) and the user-node registration record. The signing
- * input includes `type`, so this union is part of the signed bytes.
- */
-export type SignedRecordType = 'identity' | 'profile' | 'reputation_attestation' | 'real_life_attestation' | 'validation_verdict' | 'personhood_vouch' | 'credential' | 'node';
 /**
  * A signed record envelope. `record` is the arbitrary payload; the signing
  * input is the canonical-JSON of every envelope field EXCEPT `publicKey` and
@@ -100,6 +147,18 @@ export type SignedRecordType = 'identity' | 'profile' | 'reputation_attestation'
  * and the signer's DID — equal for self-issued records, `OXY_DID` for a
  * custodial provenance attestation). `issuedAt` is epoch milliseconds.
  *
+ * ## `type` — open by design
+ *
+ * `type` is an OPEN, non-empty string: it is the application-defined category of
+ * the record (e.g. Oxy's `identity`/`profile`/civic types, or `app.mention.*`'s
+ * `app_record`). The base envelope is app-agnostic, so it cannot enumerate every
+ * app's record categories — each app re-narrows `type` to its own closed set on
+ * the way INTO its own store (Oxy via {@link OxySignedRecordType}; an app via
+ * its own constant). Widening `type` from a closed enum to a string is
+ * canonical-bytes-safe: {@link signedRecordSigningInput} serializes `type` as the
+ * same JSON string either way, so every record already signed in production
+ * verifies byte-for-byte.
+ *
  * ## Versioning
  *
  * - **v1** is the original shape (`{version, type, subject, issuer, record,
@@ -121,7 +180,8 @@ export type SignedRecordType = 'identity' | 'profile' | 'reputation_attestation'
  */
 export interface SignedRecordEnvelope {
     version: 1 | 2;
-    type: SignedRecordType;
+    /** App-defined record category (open string); each store re-narrows it. */
+    type: string;
     subject: string;
     issuer: string;
     record: Record<string, unknown>;

package/dist/types/index.d.ts

@@ -18,8 +18,14 @@ 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 { verificationMethodSchema, didServiceSchema, didDocumentSchema, signedRecordEnvelopeSchema, verifiedDomainSchema, domainVerificationRequestSchema, domainVerificationInstructionsSchema, authMethodEntrySchema, authMethodsResponseSchema, exportAttestationSchema, exportBundleSchema, } from './identity';
-export type { VerificationMethod, DidService, DidDocument, SignedRecordEnvelope, SignedRecordType, 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';
+export type { LexiconRecord, ChainHeadResponse, LogPageResponse, } from './protocol';
 export { publicCardSchema, signedPublicCardSchema, realLifeAttestationRecordSchema, realLifeAttestationResultSchema, validationVerdictRecordSchema, validationOpenRequestSchema, validationOpenResultSchema, validationRequestSummarySchema, validationVoteResultSchema, personhoodVouchRecordSchema, personhoodBreakdownSchema, personhoodStatusResultSchema, vouchResultSchema, credentialRecordSchema, verifiableCredentialResponseSchema, credentialIssueResultSchema, credentialListResultSchema, credentialVerifyResultSchema, } from './civic';
 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';

package/dist/types/oxyRecordTypes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Oxy-scoped signed-record types.
+ *
+ * The base `signedRecordEnvelopeSchema` (`./identity`) now treats `type` as an
+ * OPEN, non-empty string so ANY Oxy app may define its own record categories
+ * (e.g. `app.mention.*`'s `app_record`) on the shared envelope grammar. The Oxy
+ * identity/civic/node STORE, however, accepts ONLY the closed set of categories
+ * it knows how to verify and materialize — this module is that closed set.
+ *
+ * `oxySignedRecordTypeSchema` is the runtime gate the Oxy store re-narrows with
+ * (the API's `verifyEnvelope` rejects any `type` outside it; the Mongoose
+ * `SignedRecord.type` enum is derived from `.options`); `OxySignedRecordType` is
+ * the matching compile-time union the SDK identity/civic mixins type against.
+ *
+ * The signing input INCLUDES `type`, so this set is part of the signed bytes —
+ * a record cannot have its category swapped after signing.
+ *
+ * v1 only ever carried `identity` / `profile` (already in production); v2 added
+ * the civic record types (reputation attestations, real-life / peer validations,
+ * personhood vouches, verifiable credentials) and the user-node registration
+ * record. Every value here is an Oxy `app.oxy.*` (or legacy v1) category — an
+ * app's own `type` (e.g. `app_record`) is intentionally NOT in this set and is
+ * rejected by the Oxy store.
+ *
+ * Platform-agnostic — zod only, no react/react-native/expo, ESM-safe.
+ */
+import { z } from 'zod';
+export declare const oxySignedRecordTypeSchema: z.ZodEnum<["identity", "profile", "reputation_attestation", "real_life_attestation", "validation_verdict", "personhood_vouch", "credential", "node"]>;
+/**
+ * The closed set of record categories the Oxy identity/civic/node store accepts.
+ * The base envelope `type` is an open string; this is what the Oxy store
+ * re-narrows it to.
+ */
+export type OxySignedRecordType = z.infer<typeof oxySignedRecordTypeSchema>;

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/sessionStatus.d.ts

@@ -64,8 +64,8 @@ export declare const publicApplicationSchema: z.ZodObject<{
     scopes: z.ZodArray<z.ZodString, "many">;
     developerName: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    type: "first_party" | "third_party" | "internal" | "system";
     id: string;
+    type: "first_party" | "third_party" | "internal" | "system";
     name: string;
     isOfficial: boolean;
     isInternal: boolean;
@@ -75,8 +75,8 @@ export declare const publicApplicationSchema: z.ZodObject<{
     websiteUrl?: string | undefined;
     developerName?: string | undefined;
 }, {
-    type: "first_party" | "third_party" | "internal" | "system";
     id: string;
+    type: "first_party" | "third_party" | "internal" | "system";
     name: string;
     isOfficial: boolean;
     isInternal: boolean;
@@ -122,8 +122,8 @@ export declare const sessionStatusSchema: z.ZodObject<{
         scopes: z.ZodArray<z.ZodString, "many">;
         developerName: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        type: "first_party" | "third_party" | "internal" | "system";
         id: string;
+        type: "first_party" | "third_party" | "internal" | "system";
         name: string;
         isOfficial: boolean;
         isInternal: boolean;
@@ -133,8 +133,8 @@ export declare const sessionStatusSchema: z.ZodObject<{
         websiteUrl?: string | undefined;
         developerName?: string | undefined;
     }, {
-        type: "first_party" | "third_party" | "internal" | "system";
         id: string;
+        type: "first_party" | "third_party" | "internal" | "system";
         name: string;
         isOfficial: boolean;
         isInternal: boolean;
@@ -157,8 +157,8 @@ export declare const sessionStatusSchema: z.ZodObject<{
     authorized?: boolean | undefined;
     sessionToken?: string | undefined;
     application?: {
-        type: "first_party" | "third_party" | "internal" | "system";
         id: string;
+        type: "first_party" | "third_party" | "internal" | "system";
         name: string;
         isOfficial: boolean;
         isInternal: boolean;
@@ -177,8 +177,8 @@ export declare const sessionStatusSchema: z.ZodObject<{
     authorized?: boolean | undefined;
     sessionToken?: string | undefined;
     application?: {
-        type: "first_party" | "third_party" | "internal" | "system";
         id: string;
+        type: "first_party" | "third_party" | "internal" | "system";
         name: string;
         isOfficial: boolean;
         isInternal: boolean;

package/dist/types/userResponse.d.ts

@@ -419,9 +419,9 @@ export declare const refreshAllAccountSchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">>;
 }, "strip", z.ZodTypeAny, {
     expiresAt: string;
+    sessionId: string;
     authuser: number;
     accessToken: string;
-    sessionId: string;
     user: {
         name: UserNameResponse;
         id?: string | undefined;
@@ -443,9 +443,9 @@ export declare const refreshAllAccountSchema: z.ZodObject<{
     };
 }, {
     expiresAt: string;
+    sessionId: string;
     authuser: number;
     accessToken: string;
-    sessionId: string;
     user: {
         name: UserNameResponse;
         id?: string | undefined;
@@ -568,9 +568,9 @@ export declare const refreshAllResponseSchema: z.ZodObject<{
         }, z.ZodTypeAny, "passthrough">>;
     }, "strip", z.ZodTypeAny, {
         expiresAt: string;
+        sessionId: string;
         authuser: number;
         accessToken: string;
-        sessionId: string;
         user: {
             name: UserNameResponse;
             id?: string | undefined;
@@ -592,9 +592,9 @@ export declare const refreshAllResponseSchema: z.ZodObject<{
         };
     }, {
         expiresAt: string;
+        sessionId: string;
         authuser: number;
         accessToken: string;
-        sessionId: string;
         user: {
             name: UserNameResponse;
             id?: string | undefined;
@@ -618,9 +618,9 @@ export declare const refreshAllResponseSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     accounts: {
         expiresAt: string;
+        sessionId: string;
         authuser: number;
         accessToken: string;
-        sessionId: string;
         user: {
             name: UserNameResponse;
             id?: string | undefined;
@@ -644,9 +644,9 @@ export declare const refreshAllResponseSchema: z.ZodObject<{
 }, {
     accounts: {
         expiresAt: string;
+        sessionId: string;
         authuser: number;
         accessToken: string;
-        sessionId: string;
         user: {
             name: UserNameResponse;
             id?: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxyhq/contracts",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "OxyHQ API contracts — single source of truth for request/response Zod schemas and inferred types, shared by the backend and the client SDKs",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",