@solarpunkltd/swarm-id 0.0.0-stage → 0.8.1

package/dist/schemas.d.ts

@@ -0,0 +1,671 @@
+/**
+ * Entity Schemas with Zod
+ *
+ * Defines Zod schemas for storage entities with transforms to convert
+ * serialized primitives to bee-js runtime types. Types are derived using
+ * z.infer to guarantee schema/type consistency.
+ */
+import { z } from "zod";
+import { EthAddress, BatchId as BeeBatchId, PrivateKey as BeePrivateKey } from "@ethersphere/bee-js";
+export declare const DEFAULT_BEE_NODE_URL = "https://api.gateway.ethswarm.org/";
+export declare const DEFAULT_GNOSIS_RPC_URL = "https://xdai.fairdatasociety.org/";
+export declare const ReferenceSchema: z.ZodString;
+export declare const BatchIdSchema: z.ZodString;
+export declare const AddressSchema: z.ZodString;
+export declare const PrivateKeySchema: z.ZodString;
+export declare const CompressedPublicKeySchema: z.ZodString;
+export declare const EncryptionKeySchema: z.ZodString;
+export declare const IdentifierSchema: z.ZodString;
+export declare const SignatureSchema: z.ZodString;
+export declare const ChunkAddressSchema: z.ZodString;
+/** Batch id, index, timestamp and signature: 113 bytes, as Bee's `swarm-postage-stamp` header takes them */
+export declare const MarshaledStampSchema: z.ZodString;
+export declare const TimestampSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+export declare const FeedIndexSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+export type Reference = z.infer<typeof ReferenceSchema>;
+export type BatchId = z.infer<typeof BatchIdSchema>;
+export type Address = z.infer<typeof AddressSchema>;
+export type PrivateKey = z.infer<typeof PrivateKeySchema>;
+export type CompressedPublicKey = z.infer<typeof CompressedPublicKeySchema>;
+export type Identifier = z.infer<typeof IdentifierSchema>;
+export type Signature = z.infer<typeof SignatureSchema>;
+export type Timestamp = z.infer<typeof TimestampSchema>;
+export type FeedIndex = z.infer<typeof FeedIndexSchema>;
+/**
+ * Device Schema V1
+ * Tracks devices that have accessed an account for multi-device support.
+ */
+export declare const DeviceSchemaV1: z.ZodObject<{
+    deviceId: z.ZodString;
+    createdAt: z.ZodNumber;
+    lastSignedInAt: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+    nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+    removedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Longer than any binding message can be: four short lines around a site
+ * origin, whose host is at most 253 characters. A bound on what is stored and
+ * carried, not a check of the format, which `verifyChatBinding` does.
+ */
+export declare const CHAT_BINDING_MAX_LENGTH = 512;
+/**
+ * The account's signed statement that the chat address on one site is its
+ * own (`utils/chat-binding.ts`, docs/Chat-Binding.md). Public, and true on
+ * every device of the account, so it travels with its connection rather than
+ * staying device-local like the app secret.
+ */
+export declare const ChatBindingSchema: z.ZodObject<{
+    message: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Connected App Schema V1.
+ *
+ * Account-owned: keyed by `appUrl` within its owning account (the `identityId`
+ * pointer was removed when the identity tier was collapsed into the account).
+ */
+export declare const ConnectedAppSchemaV1: z.ZodObject<{
+    appUrl: z.ZodString;
+    appName: z.ZodString;
+    lastConnectedAt: z.ZodNumber;
+    appIcon: z.ZodOptional<z.ZodString>;
+    appDescription: z.ZodOptional<z.ZodString>;
+    connectedUntil: z.ZodOptional<z.ZodNumber>;
+    appSecret: z.ZodOptional<z.ZodString>;
+    postageStampBatchID: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>>;
+    postageStampBatchIDAt: z.ZodOptional<z.ZodNumber>;
+    revokedAt: z.ZodOptional<z.ZodNumber>;
+    disconnectedAt: z.ZodOptional<z.ZodNumber>;
+    chatBinding: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Postage Stamp Schema V1
+ */
+export declare const PostageStampSchemaV1: z.ZodObject<{
+    batchID: z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>;
+    signerKey: z.ZodPipe<z.ZodString, z.ZodTransform<BeePrivateKey, string>>;
+    name: z.ZodOptional<z.ZodString>;
+    nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+    utilization: z.ZodNumber;
+    usable: z.ZodBoolean;
+    depth: z.ZodNumber;
+    amount: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+    bucketDepth: z.ZodNumber;
+    blockNumber: z.ZodNumber;
+    immutableFlag: z.ZodBoolean;
+    exists: z.ZodBoolean;
+    batchTTL: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodOptional<z.ZodNumber>;
+    deletedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Access Method Schema V1
+ *
+ * Every account is a BIP-39 seed account; the access method is simply HOW that
+ * seed is protected/encrypted at rest on this device (and thus how it is
+ * unlocked). Fields are device-local crypto material (plain hex / numbers) —
+ * never bee-js byte classes — so they round-trip as-is. Paired with
+ * `encryptedSeed` on the account.
+ *
+ * The eth-wallet method stores only the encryption salt — NOT the wallet
+ * address: a wrong wallet simply fails to decrypt the seed, and the account's
+ * own `id` is already the address of its (BIP-39) key, so a separate wallet
+ * address would be redundant.
+ */
+export declare const AccessMethodSchemaV1: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"passkey">;
+    credentialId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"eth-wallet">;
+    encryptionSalt: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"password">;
+    kdfSalt: z.ZodString;
+    kdfIterations: z.ZodNumber;
+}, z.core.$strip>], "type">;
+/**
+ * Local Vault Schema V1
+ *
+ * The device-local seed vault. Every account is a BIP-39 seed account: `access`
+ * records how the seed is protected/unlocked on THIS device (passkey /
+ * eth-wallet / password) and `encryptedSeed` is that seed encrypted at rest
+ * under the key the access method derives (hex: IV || ciphertext — width varies
+ * with the seed size: 12-word seed → 88 chars, 24-word → 120, so no fixed
+ * length). The vault never leaves the device: `SyncedAccountSchemaV1` has no
+ * vault fields. A sign-out RETAINS the vault (it is encrypted at rest) while
+ * stripping the synced data, so signing back in only takes the access method.
+ */
+export declare const LocalVaultSchemaV1: z.ZodObject<{
+    access: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"passkey">;
+        credentialId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"eth-wallet">;
+        encryptionSalt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"password">;
+        kdfSalt: z.ZodString;
+        kdfIterations: z.ZodNumber;
+    }, z.core.$strip>], "type">;
+    encryptedSeed: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Synced Account Schema V1
+ *
+ * The single, unified account model. There is exactly one kind of account: a
+ * BIP-39 seed account. What used to be distinct `type`s (passkey / ethereum /
+ * agent) were really just different ways of protecting the seed — now expressed
+ * uniformly by the device-local vault (`LocalVaultSchemaV1`). No `type`
+ * discriminant remains.
+ *
+ * This is the portable projection of the account — every field that may travel
+ * off the device, and nothing device-local. Backup files serialize/parse it
+ * directly and the sync feed carries the same shape (serialize with
+ * `serializeSyncedAccount`, which additionally strips the live per-app session
+ * material). What localStorage holds is `LocalAccountSchemaV1` = this plus the
+ * device-local tail.
+ *
+ * The account is the single-level aggregate root (the identity tier was
+ * collapsed into it). It is the app-facing identity: `id` is the address apps
+ * connect to and `publicKey` is surfaced to dApps. Apps receive a per-app
+ * DERIVED key (`deriveSecret(masterKey, appOrigin)` → app key) — never the
+ * account private key, which is the mnemonic-equivalent root and is exposed only
+ * after an explicit permission/signing request. The account OWNS its connected
+ * apps and postage stamps as nested collections rather than via foreign-key
+ * pointers.
+ */
+export declare const SyncedAccountSchemaV1: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+    name: z.ZodString;
+    createdAt: z.ZodNumber;
+    derivationKey: z.ZodString;
+    publicKey: z.ZodString;
+    defaultPostageStampBatchID: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>>;
+    devices: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodString;
+        createdAt: z.ZodNumber;
+        lastSignedInAt: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+        nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+        removedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    connectedApps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        appUrl: z.ZodString;
+        appName: z.ZodString;
+        lastConnectedAt: z.ZodNumber;
+        appIcon: z.ZodOptional<z.ZodString>;
+        appDescription: z.ZodOptional<z.ZodString>;
+        connectedUntil: z.ZodOptional<z.ZodNumber>;
+        appSecret: z.ZodOptional<z.ZodString>;
+        postageStampBatchID: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>>;
+        postageStampBatchIDAt: z.ZodOptional<z.ZodNumber>;
+        revokedAt: z.ZodOptional<z.ZodNumber>;
+        disconnectedAt: z.ZodOptional<z.ZodNumber>;
+        chatBinding: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            signature: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    postageStamps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        batchID: z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>;
+        signerKey: z.ZodPipe<z.ZodString, z.ZodTransform<BeePrivateKey, string>>;
+        name: z.ZodOptional<z.ZodString>;
+        nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+        utilization: z.ZodNumber;
+        usable: z.ZodBoolean;
+        depth: z.ZodNumber;
+        amount: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+        bucketDepth: z.ZodNumber;
+        blockNumber: z.ZodNumber;
+        immutableFlag: z.ZodBoolean;
+        exists: z.ZodBoolean;
+        batchTTL: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodOptional<z.ZodNumber>;
+        deletedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        appSessionDuration: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    accountNameAt: z.ZodOptional<z.ZodNumber>;
+    defaultStampAt: z.ZodOptional<z.ZodNumber>;
+    settingsAt: z.ZodOptional<z.ZodNumber>;
+    lastModified: z.ZodOptional<z.ZodNumber>;
+    partitionCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Signed-in variant: the synced data plus the device vault. `signedOutAt` is
+ * declared undefined-only (not merely omitted) so a record carrying BOTH a
+ * vault and a sign-out marker fails this variant — and the signed-out one —
+ * and is quarantined at load, instead of silently parsing as signed-in and
+ * dropping the marker.
+ */
+declare const SignedInAccountSchemaV1: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+    name: z.ZodString;
+    createdAt: z.ZodNumber;
+    derivationKey: z.ZodString;
+    publicKey: z.ZodString;
+    defaultPostageStampBatchID: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>>;
+    devices: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodString;
+        createdAt: z.ZodNumber;
+        lastSignedInAt: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+        nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+        removedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    connectedApps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        appUrl: z.ZodString;
+        appName: z.ZodString;
+        lastConnectedAt: z.ZodNumber;
+        appIcon: z.ZodOptional<z.ZodString>;
+        appDescription: z.ZodOptional<z.ZodString>;
+        connectedUntil: z.ZodOptional<z.ZodNumber>;
+        appSecret: z.ZodOptional<z.ZodString>;
+        postageStampBatchID: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>>;
+        postageStampBatchIDAt: z.ZodOptional<z.ZodNumber>;
+        revokedAt: z.ZodOptional<z.ZodNumber>;
+        disconnectedAt: z.ZodOptional<z.ZodNumber>;
+        chatBinding: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            signature: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    postageStamps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        batchID: z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>;
+        signerKey: z.ZodPipe<z.ZodString, z.ZodTransform<BeePrivateKey, string>>;
+        name: z.ZodOptional<z.ZodString>;
+        nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+        utilization: z.ZodNumber;
+        usable: z.ZodBoolean;
+        depth: z.ZodNumber;
+        amount: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+        bucketDepth: z.ZodNumber;
+        blockNumber: z.ZodNumber;
+        immutableFlag: z.ZodBoolean;
+        exists: z.ZodBoolean;
+        batchTTL: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodOptional<z.ZodNumber>;
+        deletedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        appSessionDuration: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    accountNameAt: z.ZodOptional<z.ZodNumber>;
+    defaultStampAt: z.ZodOptional<z.ZodNumber>;
+    settingsAt: z.ZodOptional<z.ZodNumber>;
+    lastModified: z.ZodOptional<z.ZodNumber>;
+    partitionCount: z.ZodOptional<z.ZodNumber>;
+    signedOutAt: z.ZodOptional<z.ZodUndefined>;
+    access: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"passkey">;
+        credentialId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"eth-wallet">;
+        encryptionSalt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"password">;
+        kdfSalt: z.ZodString;
+        kdfIterations: z.ZodNumber;
+    }, z.core.$strip>], "type">;
+    encryptedSeed: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Signed-out variant: the minimal remnant of a sign-out. The vault SURVIVES
+ * (it is encrypted at rest, so retaining it matches the sign-out security
+ * posture) and lets the user sign back in with the existing access method —
+ * no recovery phrase. The synced state (collections, settings, clocks, and
+ * the secret `derivationKey`) is stripped from disk as PLAINTEXT but kept as
+ * `encryptedState`: an AES-GCM snapshot keyed off the derivation-key chain,
+ * decrypted and restored on sign-back-in so a sign-out can never lose data —
+ * even offline or when the Swarm copy is gone. Absent only on a record signed
+ * out because its sealed keys could not be opened on this device (the
+ * wrapping key was lost), where sign-back-in restores from Swarm. The display
+ * fields (`name`, `createdAt`) stay so the account chooser can list the row.
+ * Being a plain object (not a `SyncedAccountSchemaV1` extension), parsing a
+ * pre-shrink record under this arm strips its plaintext synced fields.
+ */
+declare const SignedOutAccountSchemaV1: z.ZodObject<{
+    encryptedState: z.ZodOptional<z.ZodString>;
+    storageWarning: z.ZodOptional<z.ZodBoolean>;
+    soonestDriveExpiry: z.ZodOptional<z.ZodNumber>;
+    signedOutAt: z.ZodNumber;
+    access: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"passkey">;
+        credentialId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"eth-wallet">;
+        encryptionSalt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"password">;
+        kdfSalt: z.ZodString;
+        kdfIterations: z.ZodNumber;
+    }, z.core.$strip>], "type">;
+    encryptedSeed: z.ZodString;
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+    name: z.ZodString;
+    createdAt: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Local Account Schema V1 — parse entrypoint for stored account records (what
+ * localStorage holds), modeled as a union so the signed-in/signed-out states
+ * are encoded in the data itself: a signed-in account is the synced projection
+ * plus the vault and no `signedOutAt`; a signed-out one is the minimal remnant
+ * (display fields + vault) with `signedOutAt` set. Both carry the vault —
+ * `signedOutAt` presence alone discriminates; vault-less records (the
+ * pre-retention sign-out shape) fail both arms and are quarantined.
+ *
+ * This only validates at parse (load) time — the accounts loader SKIPS a
+ * violating record rather than failing the document — but unlike a refinement
+ * the union also carries into the TYPE system: `Account` is a discriminated
+ * union (discriminate on `signedOutAt` presence, or narrow with
+ * `isSignedOutAccount`), so writers can't produce a half-signed-out record
+ * without a type error.
+ */
+export declare const LocalAccountSchemaV1: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+    name: z.ZodString;
+    createdAt: z.ZodNumber;
+    derivationKey: z.ZodString;
+    publicKey: z.ZodString;
+    defaultPostageStampBatchID: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>>;
+    devices: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodString;
+        createdAt: z.ZodNumber;
+        lastSignedInAt: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+        nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+        removedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    connectedApps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        appUrl: z.ZodString;
+        appName: z.ZodString;
+        lastConnectedAt: z.ZodNumber;
+        appIcon: z.ZodOptional<z.ZodString>;
+        appDescription: z.ZodOptional<z.ZodString>;
+        connectedUntil: z.ZodOptional<z.ZodNumber>;
+        appSecret: z.ZodOptional<z.ZodString>;
+        postageStampBatchID: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>>;
+        postageStampBatchIDAt: z.ZodOptional<z.ZodNumber>;
+        revokedAt: z.ZodOptional<z.ZodNumber>;
+        disconnectedAt: z.ZodOptional<z.ZodNumber>;
+        chatBinding: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            signature: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    postageStamps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        batchID: z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>;
+        signerKey: z.ZodPipe<z.ZodString, z.ZodTransform<BeePrivateKey, string>>;
+        name: z.ZodOptional<z.ZodString>;
+        nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+        utilization: z.ZodNumber;
+        usable: z.ZodBoolean;
+        depth: z.ZodNumber;
+        amount: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+        bucketDepth: z.ZodNumber;
+        blockNumber: z.ZodNumber;
+        immutableFlag: z.ZodBoolean;
+        exists: z.ZodBoolean;
+        batchTTL: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodOptional<z.ZodNumber>;
+        deletedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        appSessionDuration: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    accountNameAt: z.ZodOptional<z.ZodNumber>;
+    defaultStampAt: z.ZodOptional<z.ZodNumber>;
+    settingsAt: z.ZodOptional<z.ZodNumber>;
+    lastModified: z.ZodOptional<z.ZodNumber>;
+    partitionCount: z.ZodOptional<z.ZodNumber>;
+    signedOutAt: z.ZodOptional<z.ZodUndefined>;
+    access: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"passkey">;
+        credentialId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"eth-wallet">;
+        encryptionSalt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"password">;
+        kdfSalt: z.ZodString;
+        kdfIterations: z.ZodNumber;
+    }, z.core.$strip>], "type">;
+    encryptedSeed: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    encryptedState: z.ZodOptional<z.ZodString>;
+    storageWarning: z.ZodOptional<z.ZodBoolean>;
+    soonestDriveExpiry: z.ZodOptional<z.ZodNumber>;
+    signedOutAt: z.ZodNumber;
+    access: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"passkey">;
+        credentialId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"eth-wallet">;
+        encryptionSalt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"password">;
+        kdfSalt: z.ZodString;
+        kdfIterations: z.ZodNumber;
+    }, z.core.$strip>], "type">;
+    encryptedSeed: z.ZodString;
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+    name: z.ZodString;
+    createdAt: z.ZodNumber;
+}, z.core.$strip>]>;
+/**
+ * Account Metadata Schema V1
+ */
+export declare const AccountMetadataSchemaV1: z.ZodObject<{
+    accountName: z.ZodString;
+    defaultPostageStampBatchID: z.ZodOptional<z.ZodString>;
+    publicKey: z.ZodString;
+    settings: z.ZodOptional<z.ZodObject<{
+        appSessionDuration: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    accountNameAt: z.ZodOptional<z.ZodNumber>;
+    defaultStampAt: z.ZodOptional<z.ZodNumber>;
+    settingsAt: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodNumber;
+    lastModified: z.ZodNumber;
+    devices: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodString;
+        createdAt: z.ZodNumber;
+        lastSignedInAt: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+        nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+        removedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    partitionCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Unified account state snapshot schema used by both file export and Swarm sync.
+ *
+ * Wire/export projection of the nested account: metadata (non-secret account
+ * fields) plus the account-owned `connectedApps` and `postageStamps`. Account
+ * secrets (`derivationKey`, `credentialId`, ethereum encrypted fields) are
+ * deliberately excluded — only `metadata` + the nested collections travel.
+ */
+export declare const AccountStateSnapshotSchemaV1: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    timestamp: z.ZodNumber;
+    accountId: z.ZodString;
+    metadata: z.ZodObject<{
+        accountName: z.ZodString;
+        defaultPostageStampBatchID: z.ZodOptional<z.ZodString>;
+        publicKey: z.ZodString;
+        settings: z.ZodOptional<z.ZodObject<{
+            appSessionDuration: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        accountNameAt: z.ZodOptional<z.ZodNumber>;
+        defaultStampAt: z.ZodOptional<z.ZodNumber>;
+        settingsAt: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodNumber;
+        lastModified: z.ZodNumber;
+        devices: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodString;
+            createdAt: z.ZodNumber;
+            lastSignedInAt: z.ZodNumber;
+            name: z.ZodOptional<z.ZodString>;
+            nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+            removedAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        partitionCount: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    connectedApps: z.ZodArray<z.ZodObject<{
+        appUrl: z.ZodString;
+        appName: z.ZodString;
+        lastConnectedAt: z.ZodNumber;
+        appIcon: z.ZodOptional<z.ZodString>;
+        appDescription: z.ZodOptional<z.ZodString>;
+        connectedUntil: z.ZodOptional<z.ZodNumber>;
+        appSecret: z.ZodOptional<z.ZodString>;
+        postageStampBatchID: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>>;
+        postageStampBatchIDAt: z.ZodOptional<z.ZodNumber>;
+        revokedAt: z.ZodOptional<z.ZodNumber>;
+        disconnectedAt: z.ZodOptional<z.ZodNumber>;
+        chatBinding: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            signature: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    postageStamps: z.ZodArray<z.ZodObject<{
+        batchID: z.ZodPipe<z.ZodString, z.ZodTransform<BeeBatchId, string>>;
+        signerKey: z.ZodPipe<z.ZodString, z.ZodTransform<BeePrivateKey, string>>;
+        name: z.ZodOptional<z.ZodString>;
+        nameUpdatedAt: z.ZodOptional<z.ZodNumber>;
+        utilization: z.ZodNumber;
+        usable: z.ZodBoolean;
+        depth: z.ZodNumber;
+        amount: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+        bucketDepth: z.ZodNumber;
+        blockNumber: z.ZodNumber;
+        immutableFlag: z.ZodBoolean;
+        exists: z.ZodBoolean;
+        batchTTL: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodOptional<z.ZodNumber>;
+        deletedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Device = z.infer<typeof DeviceSchemaV1>;
+export type AccessMethod = z.infer<typeof AccessMethodSchemaV1>;
+export type LocalVault = z.infer<typeof LocalVaultSchemaV1>;
+export type SyncedAccount = z.infer<typeof SyncedAccountSchemaV1>;
+export type SignedInAccount = z.infer<typeof SignedInAccountSchemaV1>;
+export type SignedOutAccount = z.infer<typeof SignedOutAccountSchemaV1>;
+/** The local (on-device) account record: `SignedInAccount | SignedOutAccount`. */
+export type Account = z.infer<typeof LocalAccountSchemaV1>;
+export type ConnectedApp = z.infer<typeof ConnectedAppSchemaV1>;
+export type PostageStamp = z.infer<typeof PostageStampSchemaV1>;
+export type AccountMetadata = z.infer<typeof AccountMetadataSchemaV1>;
+export type AccountStateSnapshot = z.infer<typeof AccountStateSnapshotSchemaV1>;
+/**
+ * An account is "signed out" on this device when `signedOutAt` is set: the
+ * synced data was stripped from disk, but the encrypted vault survives, so the
+ * user signs back in with the existing access method (which re-derives and
+ * re-folds the rest). Narrows: the true branch exposes `signedOutAt` as a
+ * number; the vault fields are non-optional on BOTH branches.
+ */
+export declare function isSignedOutAccount(account: Account): account is SignedOutAccount;
+/**
+ * Fencing token for the partition lock. Two writers with equal `timestampMs`
+ * are ordered by `tiebreaker` (hex of the first 8 bytes of
+ * `keccak256(deviceId)`).
+ */
+export declare const PartitionLockGenerationSchemaV1: z.ZodObject<{
+    timestampMs: z.ZodNumber;
+    tiebreaker: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Payload stored (as encrypted JSON) in a partition-lock SOC. The format is
+ * versioned by the SOC identifier domain (`swarm-id-partition-lock-v1`), so no
+ * in-payload version field is needed. `holderDeviceId` is `""` for the
+ * `NO_HOLDER_DEVICE_ID` sentinel (e.g. after an explicit release).
+ */
+export declare const PartitionLockPayloadSchemaV1: z.ZodObject<{
+    holderDeviceId: z.ZodString;
+    generation: z.ZodObject<{
+        timestampMs: z.ZodNumber;
+        tiebreaker: z.ZodString;
+    }, z.core.$strip>;
+    acquiredAt: z.ZodNumber;
+    leasedUntil: z.ZodNumber;
+}, z.core.$strip>;
+export type PartitionLockGeneration = z.infer<typeof PartitionLockGenerationSchemaV1>;
+export type PartitionLockPayload = z.infer<typeof PartitionLockPayloadSchemaV1>;
+/**
+ * Payload stored (as encrypted JSON) in a per-device partition-INTENT SOC,
+ * which doubles as a holder PRESENCE BEACON. Written before a fresh claim so
+ * rival contenders agree on a single winner by `generation`, AND re-published
+ * by the holder on every refresh tick so a later joiner can detect the live
+ * holder — both via a fresh per-epoch address that forces a network retrieval
+ * (bypassing the gateway's frozen lock-SOC cache). `deviceId` is carried for
+ * diagnostics (the address already encodes it). `leasedUntil` is present on a
+ * heartbeat so a reader can apply the same `leasedUntil > now` liveness test
+ * the lock SOC uses; it is omitted on a legacy pre-claim intent (then the
+ * reader falls back to epoch-bucket freshness).
+ */
+export declare const PartitionIntentPayloadSchemaV1: z.ZodObject<{
+    deviceId: z.ZodString;
+    generation: z.ZodObject<{
+        timestampMs: z.ZodNumber;
+        tiebreaker: z.ZodString;
+    }, z.core.$strip>;
+    leasedUntil: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PartitionIntentPayload = z.infer<typeof PartitionIntentPayloadSchemaV1>;
+/**
+ * Network Settings Schema V1
+ * Stores user-configurable network endpoints (Bee node and Gnosis RPC)
+ */
+export declare const NetworkSettingsSchemaV1: z.ZodObject<{
+    beeNodeUrl: z.ZodString;
+    gnosisRpcUrl: z.ZodString;
+}, z.core.$strip>;
+export type NetworkSettings = z.infer<typeof NetworkSettingsSchemaV1>;
+/**
+ * A Bee address a site gives the frame for its own session (`beeApiUrl` on
+ * `parentIdentify` and `setBeeApiUrl`). Never stored: it lives in the frame
+ * that site embeds, and only while it is open.
+ */
+export declare const BeeApiUrlSchema: z.ZodString;
+/**
+ * Bucket update entry for cross-tab synchronization
+ */
+export declare const BucketUpdateSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    value: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Utilization update broadcast on the account bus after a write.
+ *
+ * `buckets` carry the writer's PER-PARTITION counter `j`, not an absolute slot
+ * — the physical slot is `partitionCount + partition + partitionCount·j`
+ * (`dataSlot`, `utils/batch-utilization.ts`). So a delta is only foldable by a
+ * context bound to the SAME lane, and the lane travels with the message: the
+ * bus reaches other devices, which hold other partitions of the same batch, and
+ * folding their `j` in would skip the receiver past its own unused slots.
+ * Legacy single-partition writers publish `partition: 0, partitionCount: 1`.
+ */
+export declare const UtilizationUpdateMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"utilization-updated">;
+    batchId: z.ZodString;
+    partition: z.ZodNumber;
+    partitionCount: z.ZodNumber;
+    buckets: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        value: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BucketUpdate = z.infer<typeof BucketUpdateSchema>;
+export type UtilizationUpdateMessage = z.infer<typeof UtilizationUpdateMessageSchema>;
+export {};