@chillwhales/lsp29 0.1.1

package/dist/index.d.mts

@@ -0,0 +1,1875 @@
+import { z } from 'zod';
+import * as _chillwhales_lsp2 from '@chillwhales/lsp2';
+import { Hex } from 'viem';
+
+/**
+ * LSP29 Encrypted Assets Constants
+ *
+ * ERC725Y data keys, encryption providers, access control methods,
+ * storage backends, and UI metadata for the LSP29 standard.
+ *
+ * @see LSP-29-EncryptedAssets.md for full specification
+ */
+/**
+ * ERC725Y data key prefixes for LSP29 encrypted asset storage
+ *
+ * - `LSP29EncryptedAssets[]`: Array of encrypted asset entries (index + length)
+ * - `LSP29EncryptedAssetsMap`: Mapping prefix for content ID → array index
+ * - `LSP29EncryptedAssetRevisionCount`: Mapping prefix for content ID → revision count
+ */
+declare const LSP29DataKeys: {
+    readonly "LSP29EncryptedAssets[]": {
+        readonly index: "0x1965f98377ddff08e78c93d820cc8de4";
+        readonly length: "0x1965f98377ddff08e78c93d820cc8de4eeb331e684b7724bce0debb1958386c3";
+    };
+    readonly LSP29EncryptedAssetsMap: "0x2b9a7a38a67cedc507c2";
+    readonly LSP29EncryptedAssetRevisionCount: "0xb41f63e335c22bded814";
+};
+/**
+ * Separator used in ERC725Y mapping key construction (2 bytes)
+ * Used between the mapping prefix and the key-specific suffix
+ */
+declare const MAPPING_SEPARATOR: "0x0000";
+/**
+ * Supported encryption providers
+ *
+ * - `taco`: Threshold Access Control (TACo) — current primary provider
+ * - `lit`: Lit Protocol — legacy provider (no longer active)
+ */
+declare const LSP29_PROVIDERS: readonly ["taco", "lit"];
+/**
+ * Provider-agnostic access control method identifiers
+ *
+ * These method names are independent of the encryption provider.
+ * The provider field determines which network handles the encryption;
+ * the method field determines which on-chain condition is checked.
+ *
+ * - `digital-asset-balance`: Require holding a minimum balance of LSP7 tokens or LSP8 NFTs
+ * - `lsp8-ownership`: Require owning a specific LSP8 NFT by token ID
+ * - `lsp26-follower`: Require following specific Universal Profiles on-chain
+ * - `time-locked`: Content unlocks after a specific date/time
+ */
+declare const LSP29_METHODS: readonly ["digital-asset-balance", "lsp8-ownership", "lsp26-follower", "time-locked"];
+/**
+ * Closed set of supported storage backends for encrypted content chunks
+ *
+ * Matches LSP30's backend set by convention (not by import).
+ * Adding a backend requires a schema update.
+ */
+declare const LSP29_BACKENDS: readonly ["ipfs", "s3", "lumera", "arweave"];
+/**
+ * Human-readable metadata for each access control method
+ *
+ * Keyed by provider-agnostic method name (not the old compound `taco-*-v1` strings).
+ * Used for displaying method information in the UI.
+ */
+declare const ENCRYPTION_METHOD_METADATA: {
+    readonly "digital-asset-balance": {
+        readonly label: "Digital Asset Balance";
+        readonly description: "Require holding a minimum balance of LSP7 tokens or LSP8 NFTs";
+    };
+    readonly "lsp8-ownership": {
+        readonly label: "LSP8 NFT Ownership";
+        readonly description: "Require owning a specific NFT by token ID";
+    };
+    readonly "lsp26-follower": {
+        readonly label: "On-Chain Follower";
+        readonly description: "Require following specific Universal Profiles";
+    };
+    readonly "time-locked": {
+        readonly label: "Time-Locked";
+        readonly description: "Content unlocks after a specific date/time";
+    };
+};
+
+/**
+ * File metadata schema
+ * Technical metadata about the encrypted file
+ */
+declare const lsp29FileSchema: z.ZodObject<{
+    /** MIME type of the original file (e.g., "video/mp4") */
+    type: z.ZodString;
+    /** Original filename */
+    name: z.ZodString;
+    /** Original file size in bytes (before encryption) */
+    size: z.ZodNumber;
+    /** Unix timestamp (ms) of file's last modification */
+    lastModified: z.ZodOptional<z.ZodNumber>;
+    /** Hash of the original file content (SHA-256, hex) */
+    hash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    size: number;
+    hash: string;
+    lastModified?: number | undefined;
+}, {
+    type: string;
+    name: string;
+    size: number;
+    hash: string;
+    lastModified?: number | undefined;
+}>;
+/**
+ * IPFS chunk references
+ * Array of Content Identifiers (CIDs) for encrypted content chunks
+ */
+declare const lsp29IpfsChunksSchema: z.ZodObject<{
+    cids: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    cids: string[];
+}, {
+    cids: string[];
+}>;
+/**
+ * Lumera/Pastel Cascade chunk references
+ * Array of Cascade action IDs for encrypted content chunks
+ */
+declare const lsp29LumeraChunksSchema: z.ZodObject<{
+    actionIds: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    actionIds: string[];
+}, {
+    actionIds: string[];
+}>;
+/**
+ * S3 chunk references
+ * Array of S3 object keys plus bucket and region identifiers
+ */
+declare const lsp29S3ChunksSchema: z.ZodObject<{
+    keys: z.ZodArray<z.ZodString, "many">;
+    bucket: z.ZodString;
+    region: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    keys: string[];
+    bucket: string;
+    region: string;
+}, {
+    keys: string[];
+    bucket: string;
+    region: string;
+}>;
+/**
+ * Arweave chunk references
+ * Array of Arweave transaction IDs for encrypted content chunks
+ */
+declare const lsp29ArweaveChunksSchema: z.ZodObject<{
+    transactionIds: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    transactionIds: string[];
+}, {
+    transactionIds: string[];
+}>;
+/**
+ * LSP29 chunks schema — per-backend arrays of chunk references
+ *
+ * Each backend stores its own array of chunk identifiers independently.
+ * Chunk counts MAY differ between backends (backends may chunk differently).
+ * At least one backend must have chunk entries.
+ *
+ * @example
+ * ```typescript
+ * const chunks = {
+ *   ipfs: { cids: ['QmX...', 'QmY...'] },
+ *   lumera: { actionIds: ['abc123'] },
+ *   iv: 'base64-iv-string',
+ *   totalSize: 1048576,
+ * };
+ * ```
+ */
+declare const lsp29ChunksSchema: z.ZodEffects<z.ZodObject<{
+    /** IPFS chunk references */
+    ipfs: z.ZodOptional<z.ZodObject<{
+        cids: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        cids: string[];
+    }, {
+        cids: string[];
+    }>>;
+    /** Lumera/Pastel Cascade chunk references */
+    lumera: z.ZodOptional<z.ZodObject<{
+        actionIds: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        actionIds: string[];
+    }, {
+        actionIds: string[];
+    }>>;
+    /** S3 chunk references */
+    s3: z.ZodOptional<z.ZodObject<{
+        keys: z.ZodArray<z.ZodString, "many">;
+        bucket: z.ZodString;
+        region: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        keys: string[];
+        bucket: string;
+        region: string;
+    }, {
+        keys: string[];
+        bucket: string;
+        region: string;
+    }>>;
+    /** Arweave chunk references */
+    arweave: z.ZodOptional<z.ZodObject<{
+        transactionIds: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        transactionIds: string[];
+    }, {
+        transactionIds: string[];
+    }>>;
+    /** Initialization vector for symmetric encryption (base64) */
+    iv: z.ZodString;
+    /** Total size of encrypted content in bytes */
+    totalSize: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    iv: string;
+    totalSize: number;
+    ipfs?: {
+        cids: string[];
+    } | undefined;
+    s3?: {
+        keys: string[];
+        bucket: string;
+        region: string;
+    } | undefined;
+    lumera?: {
+        actionIds: string[];
+    } | undefined;
+    arweave?: {
+        transactionIds: string[];
+    } | undefined;
+}, {
+    iv: string;
+    totalSize: number;
+    ipfs?: {
+        cids: string[];
+    } | undefined;
+    s3?: {
+        keys: string[];
+        bucket: string;
+        region: string;
+    } | undefined;
+    lumera?: {
+        actionIds: string[];
+    } | undefined;
+    arweave?: {
+        transactionIds: string[];
+    } | undefined;
+}>, {
+    iv: string;
+    totalSize: number;
+    ipfs?: {
+        cids: string[];
+    } | undefined;
+    s3?: {
+        keys: string[];
+        bucket: string;
+        region: string;
+    } | undefined;
+    lumera?: {
+        actionIds: string[];
+    } | undefined;
+    arweave?: {
+        transactionIds: string[];
+    } | undefined;
+}, {
+    iv: string;
+    totalSize: number;
+    ipfs?: {
+        cids: string[];
+    } | undefined;
+    s3?: {
+        keys: string[];
+        bucket: string;
+        region: string;
+    } | undefined;
+    lumera?: {
+        actionIds: string[];
+    } | undefined;
+    arweave?: {
+        transactionIds: string[];
+    } | undefined;
+}>;
+/**
+ * Digital Asset Balance encryption parameters
+ * Require holding a minimum balance of LSP7 tokens or LSP8 NFTs
+ */
+declare const lsp29DigitalAssetBalanceParamsSchema: z.ZodObject<{
+    method: z.ZodLiteral<"digital-asset-balance">;
+    /** Digital asset contract address (LSP7 or LSP8) */
+    tokenAddress: z.ZodString;
+    /** Required balance as string (for BigInt compatibility), must be > 0 */
+    requiredBalance: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    method: "digital-asset-balance";
+    tokenAddress: string;
+    requiredBalance: string;
+}, {
+    method: "digital-asset-balance";
+    tokenAddress: string;
+    requiredBalance: string;
+}>;
+/**
+ * LSP8 Ownership encryption parameters
+ * Require owning a specific LSP8 NFT by token ID
+ */
+declare const lsp29Lsp8OwnershipParamsSchema: z.ZodObject<{
+    method: z.ZodLiteral<"lsp8-ownership">;
+    /** LSP8 token contract address */
+    tokenAddress: z.ZodString;
+    /** Required token ID as string */
+    requiredTokenId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    method: "lsp8-ownership";
+    tokenAddress: string;
+    requiredTokenId: string;
+}, {
+    method: "lsp8-ownership";
+    tokenAddress: string;
+    requiredTokenId: string;
+}>;
+/**
+ * LSP26 Follower encryption parameters
+ * Require following specific Universal Profiles on-chain
+ */
+declare const lsp29Lsp26FollowerParamsSchema: z.ZodObject<{
+    method: z.ZodLiteral<"lsp26-follower">;
+    /** Array of Universal Profile addresses that must be followed */
+    followedAddresses: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    method: "lsp26-follower";
+    followedAddresses: string[];
+}, {
+    method: "lsp26-follower";
+    followedAddresses: string[];
+}>;
+/**
+ * Time-Locked encryption parameters
+ * Content unlocks after a specific date/time
+ */
+declare const lsp29TimeLockedParamsSchema: z.ZodObject<{
+    method: z.ZodLiteral<"time-locked">;
+    /** Unix timestamp (seconds) when content becomes accessible */
+    unlockTimestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    method: "time-locked";
+    unlockTimestamp: string;
+}, {
+    method: "time-locked";
+    unlockTimestamp: string;
+}>;
+/**
+ * Encryption parameters discriminated union
+ *
+ * The `method` field serves as the discriminator for type narrowing.
+ * Each variant contains method-specific parameters needed for access control verification.
+ *
+ * @example
+ * ```typescript
+ * const params = {
+ *   method: 'digital-asset-balance' as const,
+ *   tokenAddress: '0x1234...',
+ *   requiredBalance: '1000000',
+ * };
+ * ```
+ */
+declare const lsp29EncryptionParamsSchema: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+    method: z.ZodLiteral<"digital-asset-balance">;
+    /** Digital asset contract address (LSP7 or LSP8) */
+    tokenAddress: z.ZodString;
+    /** Required balance as string (for BigInt compatibility), must be > 0 */
+    requiredBalance: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    method: "digital-asset-balance";
+    tokenAddress: string;
+    requiredBalance: string;
+}, {
+    method: "digital-asset-balance";
+    tokenAddress: string;
+    requiredBalance: string;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"lsp8-ownership">;
+    /** LSP8 token contract address */
+    tokenAddress: z.ZodString;
+    /** Required token ID as string */
+    requiredTokenId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    method: "lsp8-ownership";
+    tokenAddress: string;
+    requiredTokenId: string;
+}, {
+    method: "lsp8-ownership";
+    tokenAddress: string;
+    requiredTokenId: string;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"lsp26-follower">;
+    /** Array of Universal Profile addresses that must be followed */
+    followedAddresses: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    method: "lsp26-follower";
+    followedAddresses: string[];
+}, {
+    method: "lsp26-follower";
+    followedAddresses: string[];
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"time-locked">;
+    /** Unix timestamp (seconds) when content becomes accessible */
+    unlockTimestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    method: "time-locked";
+    unlockTimestamp: string;
+}, {
+    method: "time-locked";
+    unlockTimestamp: string;
+}>]>;
+/**
+ * LSP29 encryption schema — provider-first structure
+ *
+ * Separates the encryption provider from the access control method,
+ * enabling provider-agnostic method definitions and extensibility.
+ *
+ * - `provider`: Which encryption network (taco, lit)
+ * - `method`: Which access control check (digital-asset-balance, lsp8-ownership, etc.)
+ * - `params`: User-facing parameters for the method (token address, balance, etc.)
+ * - `condition`: Full provider-native condition object, stored as-is for external dApp interop
+ * - `encryptedKey`: Provider-specific encrypted key data (messageKit for TACo, etc.)
+ *
+ * @example
+ * ```typescript
+ * const encryption = {
+ *   provider: 'taco',
+ *   method: 'digital-asset-balance',
+ *   params: { method: 'digital-asset-balance', tokenAddress: '0x...', requiredBalance: '100' },
+ *   condition: { /* TACo CompoundCondition * / },
+ *   encryptedKey: { messageKit: '0x...' },
+ * };
+ * ```
+ */
+declare const lsp29EncryptionSchema: z.ZodEffects<z.ZodObject<{
+    /** Encryption provider network */
+    provider: z.ZodEnum<["taco", "lit"]>;
+    /** Access control method (provider-agnostic) */
+    method: z.ZodEnum<["digital-asset-balance", "lsp8-ownership", "lsp26-follower", "time-locked"]>;
+    /** Method-specific parameters for access control verification */
+    params: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+        method: z.ZodLiteral<"digital-asset-balance">;
+        /** Digital asset contract address (LSP7 or LSP8) */
+        tokenAddress: z.ZodString;
+        /** Required balance as string (for BigInt compatibility), must be > 0 */
+        requiredBalance: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        method: "digital-asset-balance";
+        tokenAddress: string;
+        requiredBalance: string;
+    }, {
+        method: "digital-asset-balance";
+        tokenAddress: string;
+        requiredBalance: string;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"lsp8-ownership">;
+        /** LSP8 token contract address */
+        tokenAddress: z.ZodString;
+        /** Required token ID as string */
+        requiredTokenId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        method: "lsp8-ownership";
+        tokenAddress: string;
+        requiredTokenId: string;
+    }, {
+        method: "lsp8-ownership";
+        tokenAddress: string;
+        requiredTokenId: string;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"lsp26-follower">;
+        /** Array of Universal Profile addresses that must be followed */
+        followedAddresses: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        method: "lsp26-follower";
+        followedAddresses: string[];
+    }, {
+        method: "lsp26-follower";
+        followedAddresses: string[];
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"time-locked">;
+        /** Unix timestamp (seconds) when content becomes accessible */
+        unlockTimestamp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        method: "time-locked";
+        unlockTimestamp: string;
+    }, {
+        method: "time-locked";
+        unlockTimestamp: string;
+    }>]>;
+    /** Provider-native condition object (stored as-is for external interop) */
+    condition: z.ZodUnknown;
+    /** Provider-specific encrypted key data */
+    encryptedKey: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        method: "digital-asset-balance";
+        tokenAddress: string;
+        requiredBalance: string;
+    } | {
+        method: "lsp8-ownership";
+        tokenAddress: string;
+        requiredTokenId: string;
+    } | {
+        method: "lsp26-follower";
+        followedAddresses: string[];
+    } | {
+        method: "time-locked";
+        unlockTimestamp: string;
+    };
+    method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+    provider: "taco" | "lit";
+    encryptedKey: Record<string, unknown>;
+    condition?: unknown;
+}, {
+    params: {
+        method: "digital-asset-balance";
+        tokenAddress: string;
+        requiredBalance: string;
+    } | {
+        method: "lsp8-ownership";
+        tokenAddress: string;
+        requiredTokenId: string;
+    } | {
+        method: "lsp26-follower";
+        followedAddresses: string[];
+    } | {
+        method: "time-locked";
+        unlockTimestamp: string;
+    };
+    method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+    provider: "taco" | "lit";
+    encryptedKey: Record<string, unknown>;
+    condition?: unknown;
+}>, {
+    params: {
+        method: "digital-asset-balance";
+        tokenAddress: string;
+        requiredBalance: string;
+    } | {
+        method: "lsp8-ownership";
+        tokenAddress: string;
+        requiredTokenId: string;
+    } | {
+        method: "lsp26-follower";
+        followedAddresses: string[];
+    } | {
+        method: "time-locked";
+        unlockTimestamp: string;
+    };
+    method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+    provider: "taco" | "lit";
+    encryptedKey: Record<string, unknown>;
+    condition?: unknown;
+}, {
+    params: {
+        method: "digital-asset-balance";
+        tokenAddress: string;
+        requiredBalance: string;
+    } | {
+        method: "lsp8-ownership";
+        tokenAddress: string;
+        requiredTokenId: string;
+    } | {
+        method: "lsp26-follower";
+        followedAddresses: string[];
+    } | {
+        method: "time-locked";
+        unlockTimestamp: string;
+    };
+    method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+    provider: "taco" | "lit";
+    encryptedKey: Record<string, unknown>;
+    condition?: unknown;
+}>;
+/**
+ * LSP29 encrypted asset inner schema (v2.0.0)
+ *
+ * Contains all metadata fields for an encrypted asset.
+ * Version bumped to 2.0.0 due to breaking schema changes
+ * (provider-first encryption, per-backend chunks).
+ */
+declare const lsp29EncryptedAssetInnerSchema: z.ZodObject<{
+    /** Schema version — 2.0.0 for new encryption + chunks structure */
+    version: z.ZodLiteral<"2.0.0">;
+    /** Unique content identifier chosen by creator */
+    id: z.ZodString;
+    /** Human-readable title for the content */
+    title: z.ZodString;
+    /** Human-readable description of the content */
+    description: z.ZodOptional<z.ZodString>;
+    /** Version number starting at 1, incremented for each update */
+    revision: z.ZodNumber;
+    /** Social feed images for content preview (LSP4 images format) */
+    images: z.ZodArray<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        verification: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+            data: z.ZodString;
+            method: z.ZodEnum<[_chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES, _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8]>;
+        }, "strip", z.ZodTypeAny, {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+            data: string;
+        }, {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+            data: string;
+        }>, z.ZodObject<{
+            method: z.ZodEnum<[_chillwhales_lsp2.VERIFICATION_METHODS.ECDSA]>;
+            data: z.ZodString;
+            source: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+            data: string;
+            source: string;
+        }, {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+            data: string;
+            source: string;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        width: number;
+        height: number;
+        verification: {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+            data: string;
+        } | {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+            data: string;
+            source: string;
+        };
+    }, {
+        url: string;
+        width: number;
+        height: number;
+        verification: {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+            data: string;
+        } | {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+            data: string;
+            source: string;
+        };
+    }>, "many">, "many">;
+    /** Technical metadata about the encrypted file */
+    file: z.ZodObject<{
+        /** MIME type of the original file (e.g., "video/mp4") */
+        type: z.ZodString;
+        /** Original filename */
+        name: z.ZodString;
+        /** Original file size in bytes (before encryption) */
+        size: z.ZodNumber;
+        /** Unix timestamp (ms) of file's last modification */
+        lastModified: z.ZodOptional<z.ZodNumber>;
+        /** Hash of the original file content (SHA-256, hex) */
+        hash: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        name: string;
+        size: number;
+        hash: string;
+        lastModified?: number | undefined;
+    }, {
+        type: string;
+        name: string;
+        size: number;
+        hash: string;
+        lastModified?: number | undefined;
+    }>;
+    /** Encryption metadata for decryption */
+    encryption: z.ZodEffects<z.ZodObject<{
+        /** Encryption provider network */
+        provider: z.ZodEnum<["taco", "lit"]>;
+        /** Access control method (provider-agnostic) */
+        method: z.ZodEnum<["digital-asset-balance", "lsp8-ownership", "lsp26-follower", "time-locked"]>;
+        /** Method-specific parameters for access control verification */
+        params: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+            method: z.ZodLiteral<"digital-asset-balance">;
+            /** Digital asset contract address (LSP7 or LSP8) */
+            tokenAddress: z.ZodString;
+            /** Required balance as string (for BigInt compatibility), must be > 0 */
+            requiredBalance: z.ZodEffects<z.ZodString, string, string>;
+        }, "strip", z.ZodTypeAny, {
+            method: "digital-asset-balance";
+            tokenAddress: string;
+            requiredBalance: string;
+        }, {
+            method: "digital-asset-balance";
+            tokenAddress: string;
+            requiredBalance: string;
+        }>, z.ZodObject<{
+            method: z.ZodLiteral<"lsp8-ownership">;
+            /** LSP8 token contract address */
+            tokenAddress: z.ZodString;
+            /** Required token ID as string */
+            requiredTokenId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            method: "lsp8-ownership";
+            tokenAddress: string;
+            requiredTokenId: string;
+        }, {
+            method: "lsp8-ownership";
+            tokenAddress: string;
+            requiredTokenId: string;
+        }>, z.ZodObject<{
+            method: z.ZodLiteral<"lsp26-follower">;
+            /** Array of Universal Profile addresses that must be followed */
+            followedAddresses: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            method: "lsp26-follower";
+            followedAddresses: string[];
+        }, {
+            method: "lsp26-follower";
+            followedAddresses: string[];
+        }>, z.ZodObject<{
+            method: z.ZodLiteral<"time-locked">;
+            /** Unix timestamp (seconds) when content becomes accessible */
+            unlockTimestamp: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            method: "time-locked";
+            unlockTimestamp: string;
+        }, {
+            method: "time-locked";
+            unlockTimestamp: string;
+        }>]>;
+        /** Provider-native condition object (stored as-is for external interop) */
+        condition: z.ZodUnknown;
+        /** Provider-specific encrypted key data */
+        encryptedKey: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            method: "digital-asset-balance";
+            tokenAddress: string;
+            requiredBalance: string;
+        } | {
+            method: "lsp8-ownership";
+            tokenAddress: string;
+            requiredTokenId: string;
+        } | {
+            method: "lsp26-follower";
+            followedAddresses: string[];
+        } | {
+            method: "time-locked";
+            unlockTimestamp: string;
+        };
+        method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+        provider: "taco" | "lit";
+        encryptedKey: Record<string, unknown>;
+        condition?: unknown;
+    }, {
+        params: {
+            method: "digital-asset-balance";
+            tokenAddress: string;
+            requiredBalance: string;
+        } | {
+            method: "lsp8-ownership";
+            tokenAddress: string;
+            requiredTokenId: string;
+        } | {
+            method: "lsp26-follower";
+            followedAddresses: string[];
+        } | {
+            method: "time-locked";
+            unlockTimestamp: string;
+        };
+        method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+        provider: "taco" | "lit";
+        encryptedKey: Record<string, unknown>;
+        condition?: unknown;
+    }>, {
+        params: {
+            method: "digital-asset-balance";
+            tokenAddress: string;
+            requiredBalance: string;
+        } | {
+            method: "lsp8-ownership";
+            tokenAddress: string;
+            requiredTokenId: string;
+        } | {
+            method: "lsp26-follower";
+            followedAddresses: string[];
+        } | {
+            method: "time-locked";
+            unlockTimestamp: string;
+        };
+        method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+        provider: "taco" | "lit";
+        encryptedKey: Record<string, unknown>;
+        condition?: unknown;
+    }, {
+        params: {
+            method: "digital-asset-balance";
+            tokenAddress: string;
+            requiredBalance: string;
+        } | {
+            method: "lsp8-ownership";
+            tokenAddress: string;
+            requiredTokenId: string;
+        } | {
+            method: "lsp26-follower";
+            followedAddresses: string[];
+        } | {
+            method: "time-locked";
+            unlockTimestamp: string;
+        };
+        method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+        provider: "taco" | "lit";
+        encryptedKey: Record<string, unknown>;
+        condition?: unknown;
+    }>;
+    /** Chunked storage information */
+    chunks: z.ZodEffects<z.ZodObject<{
+        /** IPFS chunk references */
+        ipfs: z.ZodOptional<z.ZodObject<{
+            cids: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            cids: string[];
+        }, {
+            cids: string[];
+        }>>;
+        /** Lumera/Pastel Cascade chunk references */
+        lumera: z.ZodOptional<z.ZodObject<{
+            actionIds: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            actionIds: string[];
+        }, {
+            actionIds: string[];
+        }>>;
+        /** S3 chunk references */
+        s3: z.ZodOptional<z.ZodObject<{
+            keys: z.ZodArray<z.ZodString, "many">;
+            bucket: z.ZodString;
+            region: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            keys: string[];
+            bucket: string;
+            region: string;
+        }, {
+            keys: string[];
+            bucket: string;
+            region: string;
+        }>>;
+        /** Arweave chunk references */
+        arweave: z.ZodOptional<z.ZodObject<{
+            transactionIds: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            transactionIds: string[];
+        }, {
+            transactionIds: string[];
+        }>>;
+        /** Initialization vector for symmetric encryption (base64) */
+        iv: z.ZodString;
+        /** Total size of encrypted content in bytes */
+        totalSize: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        iv: string;
+        totalSize: number;
+        ipfs?: {
+            cids: string[];
+        } | undefined;
+        s3?: {
+            keys: string[];
+            bucket: string;
+            region: string;
+        } | undefined;
+        lumera?: {
+            actionIds: string[];
+        } | undefined;
+        arweave?: {
+            transactionIds: string[];
+        } | undefined;
+    }, {
+        iv: string;
+        totalSize: number;
+        ipfs?: {
+            cids: string[];
+        } | undefined;
+        s3?: {
+            keys: string[];
+            bucket: string;
+            region: string;
+        } | undefined;
+        lumera?: {
+            actionIds: string[];
+        } | undefined;
+        arweave?: {
+            transactionIds: string[];
+        } | undefined;
+    }>, {
+        iv: string;
+        totalSize: number;
+        ipfs?: {
+            cids: string[];
+        } | undefined;
+        s3?: {
+            keys: string[];
+            bucket: string;
+            region: string;
+        } | undefined;
+        lumera?: {
+            actionIds: string[];
+        } | undefined;
+        arweave?: {
+            transactionIds: string[];
+        } | undefined;
+    }, {
+        iv: string;
+        totalSize: number;
+        ipfs?: {
+            cids: string[];
+        } | undefined;
+        s3?: {
+            keys: string[];
+            bucket: string;
+            region: string;
+        } | undefined;
+        lumera?: {
+            actionIds: string[];
+        } | undefined;
+        arweave?: {
+            transactionIds: string[];
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version: "2.0.0";
+    id: string;
+    title: string;
+    revision: number;
+    images: {
+        url: string;
+        width: number;
+        height: number;
+        verification: {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+            data: string;
+        } | {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+            data: string;
+            source: string;
+        };
+    }[][];
+    file: {
+        type: string;
+        name: string;
+        size: number;
+        hash: string;
+        lastModified?: number | undefined;
+    };
+    encryption: {
+        params: {
+            method: "digital-asset-balance";
+            tokenAddress: string;
+            requiredBalance: string;
+        } | {
+            method: "lsp8-ownership";
+            tokenAddress: string;
+            requiredTokenId: string;
+        } | {
+            method: "lsp26-follower";
+            followedAddresses: string[];
+        } | {
+            method: "time-locked";
+            unlockTimestamp: string;
+        };
+        method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+        provider: "taco" | "lit";
+        encryptedKey: Record<string, unknown>;
+        condition?: unknown;
+    };
+    chunks: {
+        iv: string;
+        totalSize: number;
+        ipfs?: {
+            cids: string[];
+        } | undefined;
+        s3?: {
+            keys: string[];
+            bucket: string;
+            region: string;
+        } | undefined;
+        lumera?: {
+            actionIds: string[];
+        } | undefined;
+        arweave?: {
+            transactionIds: string[];
+        } | undefined;
+    };
+    description?: string | undefined;
+}, {
+    version: "2.0.0";
+    id: string;
+    title: string;
+    revision: number;
+    images: {
+        url: string;
+        width: number;
+        height: number;
+        verification: {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+            data: string;
+        } | {
+            method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+            data: string;
+            source: string;
+        };
+    }[][];
+    file: {
+        type: string;
+        name: string;
+        size: number;
+        hash: string;
+        lastModified?: number | undefined;
+    };
+    encryption: {
+        params: {
+            method: "digital-asset-balance";
+            tokenAddress: string;
+            requiredBalance: string;
+        } | {
+            method: "lsp8-ownership";
+            tokenAddress: string;
+            requiredTokenId: string;
+        } | {
+            method: "lsp26-follower";
+            followedAddresses: string[];
+        } | {
+            method: "time-locked";
+            unlockTimestamp: string;
+        };
+        method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+        provider: "taco" | "lit";
+        encryptedKey: Record<string, unknown>;
+        condition?: unknown;
+    };
+    chunks: {
+        iv: string;
+        totalSize: number;
+        ipfs?: {
+            cids: string[];
+        } | undefined;
+        s3?: {
+            keys: string[];
+            bucket: string;
+            region: string;
+        } | undefined;
+        lumera?: {
+            actionIds: string[];
+        } | undefined;
+        arweave?: {
+            transactionIds: string[];
+        } | undefined;
+    };
+    description?: string | undefined;
+}>;
+/**
+ * LSP29 encrypted asset schema (root wrapper)
+ *
+ * The top-level schema wraps the inner asset with an `LSP29EncryptedAsset` key,
+ * following the LSP convention for typed metadata objects.
+ */
+declare const lsp29EncryptedAssetSchema: z.ZodObject<{
+    LSP29EncryptedAsset: z.ZodObject<{
+        /** Schema version — 2.0.0 for new encryption + chunks structure */
+        version: z.ZodLiteral<"2.0.0">;
+        /** Unique content identifier chosen by creator */
+        id: z.ZodString;
+        /** Human-readable title for the content */
+        title: z.ZodString;
+        /** Human-readable description of the content */
+        description: z.ZodOptional<z.ZodString>;
+        /** Version number starting at 1, incremented for each update */
+        revision: z.ZodNumber;
+        /** Social feed images for content preview (LSP4 images format) */
+        images: z.ZodArray<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            verification: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+                data: z.ZodString;
+                method: z.ZodEnum<[_chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES, _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8]>;
+            }, "strip", z.ZodTypeAny, {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+                data: string;
+            }, {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+                data: string;
+            }>, z.ZodObject<{
+                method: z.ZodEnum<[_chillwhales_lsp2.VERIFICATION_METHODS.ECDSA]>;
+                data: z.ZodString;
+                source: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+                data: string;
+                source: string;
+            }, {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+                data: string;
+                source: string;
+            }>]>;
+        }, "strip", z.ZodTypeAny, {
+            url: string;
+            width: number;
+            height: number;
+            verification: {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+                data: string;
+            } | {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+                data: string;
+                source: string;
+            };
+        }, {
+            url: string;
+            width: number;
+            height: number;
+            verification: {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+                data: string;
+            } | {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+                data: string;
+                source: string;
+            };
+        }>, "many">, "many">;
+        /** Technical metadata about the encrypted file */
+        file: z.ZodObject<{
+            /** MIME type of the original file (e.g., "video/mp4") */
+            type: z.ZodString;
+            /** Original filename */
+            name: z.ZodString;
+            /** Original file size in bytes (before encryption) */
+            size: z.ZodNumber;
+            /** Unix timestamp (ms) of file's last modification */
+            lastModified: z.ZodOptional<z.ZodNumber>;
+            /** Hash of the original file content (SHA-256, hex) */
+            hash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            name: string;
+            size: number;
+            hash: string;
+            lastModified?: number | undefined;
+        }, {
+            type: string;
+            name: string;
+            size: number;
+            hash: string;
+            lastModified?: number | undefined;
+        }>;
+        /** Encryption metadata for decryption */
+        encryption: z.ZodEffects<z.ZodObject<{
+            /** Encryption provider network */
+            provider: z.ZodEnum<["taco", "lit"]>;
+            /** Access control method (provider-agnostic) */
+            method: z.ZodEnum<["digital-asset-balance", "lsp8-ownership", "lsp26-follower", "time-locked"]>;
+            /** Method-specific parameters for access control verification */
+            params: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+                method: z.ZodLiteral<"digital-asset-balance">;
+                /** Digital asset contract address (LSP7 or LSP8) */
+                tokenAddress: z.ZodString;
+                /** Required balance as string (for BigInt compatibility), must be > 0 */
+                requiredBalance: z.ZodEffects<z.ZodString, string, string>;
+            }, "strip", z.ZodTypeAny, {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            }, {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            }>, z.ZodObject<{
+                method: z.ZodLiteral<"lsp8-ownership">;
+                /** LSP8 token contract address */
+                tokenAddress: z.ZodString;
+                /** Required token ID as string */
+                requiredTokenId: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            }, {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            }>, z.ZodObject<{
+                method: z.ZodLiteral<"lsp26-follower">;
+                /** Array of Universal Profile addresses that must be followed */
+                followedAddresses: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            }, {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            }>, z.ZodObject<{
+                method: z.ZodLiteral<"time-locked">;
+                /** Unix timestamp (seconds) when content becomes accessible */
+                unlockTimestamp: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                method: "time-locked";
+                unlockTimestamp: string;
+            }, {
+                method: "time-locked";
+                unlockTimestamp: string;
+            }>]>;
+            /** Provider-native condition object (stored as-is for external interop) */
+            condition: z.ZodUnknown;
+            /** Provider-specific encrypted key data */
+            encryptedKey: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            params: {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            } | {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            } | {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            } | {
+                method: "time-locked";
+                unlockTimestamp: string;
+            };
+            method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+            provider: "taco" | "lit";
+            encryptedKey: Record<string, unknown>;
+            condition?: unknown;
+        }, {
+            params: {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            } | {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            } | {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            } | {
+                method: "time-locked";
+                unlockTimestamp: string;
+            };
+            method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+            provider: "taco" | "lit";
+            encryptedKey: Record<string, unknown>;
+            condition?: unknown;
+        }>, {
+            params: {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            } | {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            } | {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            } | {
+                method: "time-locked";
+                unlockTimestamp: string;
+            };
+            method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+            provider: "taco" | "lit";
+            encryptedKey: Record<string, unknown>;
+            condition?: unknown;
+        }, {
+            params: {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            } | {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            } | {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            } | {
+                method: "time-locked";
+                unlockTimestamp: string;
+            };
+            method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+            provider: "taco" | "lit";
+            encryptedKey: Record<string, unknown>;
+            condition?: unknown;
+        }>;
+        /** Chunked storage information */
+        chunks: z.ZodEffects<z.ZodObject<{
+            /** IPFS chunk references */
+            ipfs: z.ZodOptional<z.ZodObject<{
+                cids: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                cids: string[];
+            }, {
+                cids: string[];
+            }>>;
+            /** Lumera/Pastel Cascade chunk references */
+            lumera: z.ZodOptional<z.ZodObject<{
+                actionIds: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                actionIds: string[];
+            }, {
+                actionIds: string[];
+            }>>;
+            /** S3 chunk references */
+            s3: z.ZodOptional<z.ZodObject<{
+                keys: z.ZodArray<z.ZodString, "many">;
+                bucket: z.ZodString;
+                region: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                keys: string[];
+                bucket: string;
+                region: string;
+            }, {
+                keys: string[];
+                bucket: string;
+                region: string;
+            }>>;
+            /** Arweave chunk references */
+            arweave: z.ZodOptional<z.ZodObject<{
+                transactionIds: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                transactionIds: string[];
+            }, {
+                transactionIds: string[];
+            }>>;
+            /** Initialization vector for symmetric encryption (base64) */
+            iv: z.ZodString;
+            /** Total size of encrypted content in bytes */
+            totalSize: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            iv: string;
+            totalSize: number;
+            ipfs?: {
+                cids: string[];
+            } | undefined;
+            s3?: {
+                keys: string[];
+                bucket: string;
+                region: string;
+            } | undefined;
+            lumera?: {
+                actionIds: string[];
+            } | undefined;
+            arweave?: {
+                transactionIds: string[];
+            } | undefined;
+        }, {
+            iv: string;
+            totalSize: number;
+            ipfs?: {
+                cids: string[];
+            } | undefined;
+            s3?: {
+                keys: string[];
+                bucket: string;
+                region: string;
+            } | undefined;
+            lumera?: {
+                actionIds: string[];
+            } | undefined;
+            arweave?: {
+                transactionIds: string[];
+            } | undefined;
+        }>, {
+            iv: string;
+            totalSize: number;
+            ipfs?: {
+                cids: string[];
+            } | undefined;
+            s3?: {
+                keys: string[];
+                bucket: string;
+                region: string;
+            } | undefined;
+            lumera?: {
+                actionIds: string[];
+            } | undefined;
+            arweave?: {
+                transactionIds: string[];
+            } | undefined;
+        }, {
+            iv: string;
+            totalSize: number;
+            ipfs?: {
+                cids: string[];
+            } | undefined;
+            s3?: {
+                keys: string[];
+                bucket: string;
+                region: string;
+            } | undefined;
+            lumera?: {
+                actionIds: string[];
+            } | undefined;
+            arweave?: {
+                transactionIds: string[];
+            } | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        version: "2.0.0";
+        id: string;
+        title: string;
+        revision: number;
+        images: {
+            url: string;
+            width: number;
+            height: number;
+            verification: {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+                data: string;
+            } | {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+                data: string;
+                source: string;
+            };
+        }[][];
+        file: {
+            type: string;
+            name: string;
+            size: number;
+            hash: string;
+            lastModified?: number | undefined;
+        };
+        encryption: {
+            params: {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            } | {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            } | {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            } | {
+                method: "time-locked";
+                unlockTimestamp: string;
+            };
+            method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+            provider: "taco" | "lit";
+            encryptedKey: Record<string, unknown>;
+            condition?: unknown;
+        };
+        chunks: {
+            iv: string;
+            totalSize: number;
+            ipfs?: {
+                cids: string[];
+            } | undefined;
+            s3?: {
+                keys: string[];
+                bucket: string;
+                region: string;
+            } | undefined;
+            lumera?: {
+                actionIds: string[];
+            } | undefined;
+            arweave?: {
+                transactionIds: string[];
+            } | undefined;
+        };
+        description?: string | undefined;
+    }, {
+        version: "2.0.0";
+        id: string;
+        title: string;
+        revision: number;
+        images: {
+            url: string;
+            width: number;
+            height: number;
+            verification: {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+                data: string;
+            } | {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+                data: string;
+                source: string;
+            };
+        }[][];
+        file: {
+            type: string;
+            name: string;
+            size: number;
+            hash: string;
+            lastModified?: number | undefined;
+        };
+        encryption: {
+            params: {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            } | {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            } | {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            } | {
+                method: "time-locked";
+                unlockTimestamp: string;
+            };
+            method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+            provider: "taco" | "lit";
+            encryptedKey: Record<string, unknown>;
+            condition?: unknown;
+        };
+        chunks: {
+            iv: string;
+            totalSize: number;
+            ipfs?: {
+                cids: string[];
+            } | undefined;
+            s3?: {
+                keys: string[];
+                bucket: string;
+                region: string;
+            } | undefined;
+            lumera?: {
+                actionIds: string[];
+            } | undefined;
+            arweave?: {
+                transactionIds: string[];
+            } | undefined;
+        };
+        description?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    LSP29EncryptedAsset: {
+        version: "2.0.0";
+        id: string;
+        title: string;
+        revision: number;
+        images: {
+            url: string;
+            width: number;
+            height: number;
+            verification: {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+                data: string;
+            } | {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+                data: string;
+                source: string;
+            };
+        }[][];
+        file: {
+            type: string;
+            name: string;
+            size: number;
+            hash: string;
+            lastModified?: number | undefined;
+        };
+        encryption: {
+            params: {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            } | {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            } | {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            } | {
+                method: "time-locked";
+                unlockTimestamp: string;
+            };
+            method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+            provider: "taco" | "lit";
+            encryptedKey: Record<string, unknown>;
+            condition?: unknown;
+        };
+        chunks: {
+            iv: string;
+            totalSize: number;
+            ipfs?: {
+                cids: string[];
+            } | undefined;
+            s3?: {
+                keys: string[];
+                bucket: string;
+                region: string;
+            } | undefined;
+            lumera?: {
+                actionIds: string[];
+            } | undefined;
+            arweave?: {
+                transactionIds: string[];
+            } | undefined;
+        };
+        description?: string | undefined;
+    };
+}, {
+    LSP29EncryptedAsset: {
+        version: "2.0.0";
+        id: string;
+        title: string;
+        revision: number;
+        images: {
+            url: string;
+            width: number;
+            height: number;
+            verification: {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_UTF8 | _chillwhales_lsp2.VERIFICATION_METHODS.HASH_KECCAK256_BYTES;
+                data: string;
+            } | {
+                method: _chillwhales_lsp2.VERIFICATION_METHODS.ECDSA;
+                data: string;
+                source: string;
+            };
+        }[][];
+        file: {
+            type: string;
+            name: string;
+            size: number;
+            hash: string;
+            lastModified?: number | undefined;
+        };
+        encryption: {
+            params: {
+                method: "digital-asset-balance";
+                tokenAddress: string;
+                requiredBalance: string;
+            } | {
+                method: "lsp8-ownership";
+                tokenAddress: string;
+                requiredTokenId: string;
+            } | {
+                method: "lsp26-follower";
+                followedAddresses: string[];
+            } | {
+                method: "time-locked";
+                unlockTimestamp: string;
+            };
+            method: "digital-asset-balance" | "lsp8-ownership" | "lsp26-follower" | "time-locked";
+            provider: "taco" | "lit";
+            encryptedKey: Record<string, unknown>;
+            condition?: unknown;
+        };
+        chunks: {
+            iv: string;
+            totalSize: number;
+            ipfs?: {
+                cids: string[];
+            } | undefined;
+            s3?: {
+                keys: string[];
+                bucket: string;
+                region: string;
+            } | undefined;
+            lumera?: {
+                actionIds: string[];
+            } | undefined;
+            arweave?: {
+                transactionIds: string[];
+            } | undefined;
+        };
+        description?: string | undefined;
+    };
+}>;
+
+/**
+ * LSP29 Encrypted Assets TypeScript Types
+ *
+ * Types are inferred from Zod schemas via z.infer for single source of truth.
+ * Re-exports constant-derived types for convenience.
+ *
+ * @see LSP-29-EncryptedAssets.md for full specification
+ */
+
+/** Union type of supported encryption provider identifiers */
+type LSP29Provider = (typeof LSP29_PROVIDERS)[number];
+/** Union type of supported access control method identifiers */
+type LSP29Method = (typeof LSP29_METHODS)[number];
+/** Union type of supported storage backend identifiers */
+type LSP29Backend = (typeof LSP29_BACKENDS)[number];
+/** File metadata for the encrypted original */
+type LSP29File = z.infer<typeof lsp29FileSchema>;
+/** IPFS chunk references */
+type LSP29IpfsChunks = z.infer<typeof lsp29IpfsChunksSchema>;
+/** Lumera/Pastel Cascade chunk references */
+type LSP29LumeraChunks = z.infer<typeof lsp29LumeraChunksSchema>;
+/** S3 chunk references */
+type LSP29S3Chunks = z.infer<typeof lsp29S3ChunksSchema>;
+/** Arweave chunk references */
+type LSP29ArweaveChunks = z.infer<typeof lsp29ArweaveChunksSchema>;
+/** Combined chunks with per-backend arrays and encryption IV */
+type LSP29Chunks = z.infer<typeof lsp29ChunksSchema>;
+/** Digital Asset Balance access control parameters */
+type LSP29DigitalAssetBalanceParams = z.infer<typeof lsp29DigitalAssetBalanceParamsSchema>;
+/** LSP8 NFT Ownership access control parameters */
+type LSP29Lsp8OwnershipParams = z.infer<typeof lsp29Lsp8OwnershipParamsSchema>;
+/** LSP26 Follower access control parameters */
+type LSP29Lsp26FollowerParams = z.infer<typeof lsp29Lsp26FollowerParamsSchema>;
+/** Time-Locked access control parameters */
+type LSP29TimeLockedParams = z.infer<typeof lsp29TimeLockedParamsSchema>;
+/** Discriminated union of all encryption parameter variants */
+type LSP29EncryptionParams = z.infer<typeof lsp29EncryptionParamsSchema>;
+/** Provider-first encryption metadata */
+type LSP29Encryption = z.infer<typeof lsp29EncryptionSchema>;
+/** Inner encrypted asset metadata (without the LSP29EncryptedAsset wrapper) */
+type LSP29EncryptedAssetInner = z.infer<typeof lsp29EncryptedAssetInnerSchema>;
+/** Root encrypted asset with LSP29EncryptedAsset wrapper key */
+type LSP29EncryptedAsset = z.infer<typeof lsp29EncryptedAssetSchema>;
+/** Subset of asset fields needed for encryption/decryption operations */
+type LSP29EncryptionData = Pick<LSP29EncryptedAssetInner, "file" | "encryption" | "chunks">;
+
+/**
+ * LSP29 Metadata Decoding
+ *
+ * Parses and validates LSP29 encrypted asset metadata JSON.
+ *
+ * @see LSP-29-EncryptedAssets.md for full specification
+ */
+
+/**
+ * Parses an LSP29 metadata JSON string and validates it against the v2.0.0 schema.
+ *
+ * @param json - JSON string containing LSP29 encrypted asset metadata
+ * @returns Parsed and validated LSP29EncryptedAsset
+ * @throws Error if JSON is invalid or doesn't match the v2.0.0 schema
+ *
+ * @example
+ * ```typescript
+ * const metadata = decodeLsp29Metadata(jsonString);
+ * console.log(metadata.LSP29EncryptedAsset.title);
+ * console.log(metadata.LSP29EncryptedAsset.encryption.provider);
+ * ```
+ */
+declare function decodeLsp29Metadata(json: string): LSP29EncryptedAsset;
+
+/**
+ * LSP29 Data Key Computation Utilities
+ *
+ * Pure functions for computing ERC725Y data keys according to the LSP-29
+ * Encrypted Assets specification. These utilities enable storage and
+ * retrieval of encrypted assets on Universal Profiles.
+ *
+ * Ported from packages/utils/src/lsp29.ts — uses local constants (zero external imports).
+ *
+ * @see LSP-29-EncryptedAssets.md for full specification
+ * @see https://github.com/lukso-network/LIPs/blob/main/LSPs/LSP-2-ERC725YJSONSchema.md
+ */
+
+/**
+ * Computes the data key for a specific LSP29EncryptedAssets[] array element
+ *
+ * According to LSP2 Array specification, element keys are formed by:
+ * - First 16 bytes: First 16 bytes of the array key
+ * - Last 16 bytes: uint128 index value
+ *
+ * @param index - Zero-based array index (must be non-negative integer or bigint)
+ * @returns 32-byte data key for the array element
+ * @throws Error if index is negative
+ *
+ * @example
+ * ```typescript
+ * const key0 = computeLsp29ArrayIndexKey(0);
+ * // '0x1965f98377ddff08e78c93d820cc8de400000000000000000000000000000000'
+ *
+ * const key1 = computeLsp29ArrayIndexKey(1);
+ * // '0x1965f98377ddff08e78c93d820cc8de400000000000000000000000000000001'
+ *
+ * // Also works with bigint
+ * const keyBigInt = computeLsp29ArrayIndexKey(BigInt(5));
+ * ```
+ */
+declare function computeLsp29ArrayIndexKey(index: number | bigint): Hex;
+/**
+ * Computes the mapping key for the latest version of encrypted content
+ *
+ * This key maps a content ID to the array index of its most recent revision.
+ * The key is updated each time a new revision is added.
+ *
+ * Key format: LSP29EncryptedAssetsMap prefix + first 20 bytes of keccak256(contentId)
+ *
+ * @param contentId - Unique content identifier chosen by the creator
+ * @returns 32-byte mapping data key
+ *
+ * @example
+ * ```typescript
+ * const key = computeLsp29MapKey('premium-content');
+ * // Returns: '0x2b9a7a38a67cedc507c20000...' (32 bytes)
+ * ```
+ */
+declare function computeLsp29MapKey(contentId: string): Hex;
+/**
+ * Computes the mapping key for a specific revision of encrypted content
+ *
+ * This key maps a content ID + revision number to the array index of that
+ * specific version. These keys are immutable once set.
+ *
+ * Key format: LSP29EncryptedAssetsMap prefix + first 20 bytes of keccak256(abi.encodePacked(contentId, uint32(revision)))
+ *
+ * @param contentId - Unique content identifier chosen by the creator
+ * @param revision - Version number (1-based, must be positive integer)
+ * @returns 32-byte mapping data key
+ * @throws Error if revision is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * const keyV1 = computeLsp29MapKeyVersioned('premium-content', 1);
+ * const keyV2 = computeLsp29MapKeyVersioned('premium-content', 2);
+ * ```
+ */
+declare function computeLsp29MapKeyVersioned(contentId: string, revision: number): Hex;
+/**
+ * Computes the revision count mapping key for a content ID
+ *
+ * This key maps a content ID to the total number of revisions published.
+ * Used to enumerate all versions and validate revision numbers.
+ *
+ * Key format: LSP29EncryptedAssetRevisionCount prefix + first 20 bytes of keccak256(contentId)
+ *
+ * @param contentId - Unique content identifier chosen by the creator
+ * @returns 32-byte mapping data key
+ *
+ * @example
+ * ```typescript
+ * const key = computeLsp29RevisionCountKey('premium-content');
+ * ```
+ */
+declare function computeLsp29RevisionCountKey(contentId: string): Hex;
+
+/**
+ * LSP29 Encrypted Assets Type Guards
+ *
+ * Structural validation for identifying LSP29 v2.0.0 encrypted asset objects.
+ *
+ * @see LSP-29-EncryptedAssets.md for full specification
+ */
+
+/**
+ * Type guard to check if data is a valid LSP29 Encrypted Asset (v2.0.0)
+ *
+ * Uses Zod schema validation to verify the structure matches the
+ * LSP29EncryptedAsset specification. Does not throw on invalid data.
+ *
+ * @param data - Unknown data to check
+ * @returns true if data is a valid LSP29EncryptedAsset
+ *
+ * @example
+ * ```typescript
+ * if (isLsp29Asset(unknownData)) {
+ *   console.log(unknownData.LSP29EncryptedAsset.title);
+ * }
+ *
+ * const lsp29Assets = decodedItems.filter(isLsp29Asset);
+ * ```
+ */
+declare function isLsp29Asset(data: unknown): data is LSP29EncryptedAsset;
+
+export { ENCRYPTION_METHOD_METADATA, LSP29DataKeys, LSP29_BACKENDS, LSP29_METHODS, LSP29_PROVIDERS, MAPPING_SEPARATOR, computeLsp29ArrayIndexKey, computeLsp29MapKey, computeLsp29MapKeyVersioned, computeLsp29RevisionCountKey, decodeLsp29Metadata, isLsp29Asset, lsp29ArweaveChunksSchema, lsp29ChunksSchema, lsp29DigitalAssetBalanceParamsSchema, lsp29EncryptedAssetInnerSchema, lsp29EncryptedAssetSchema, lsp29EncryptionParamsSchema, lsp29EncryptionSchema, lsp29FileSchema, lsp29IpfsChunksSchema, lsp29Lsp26FollowerParamsSchema, lsp29Lsp8OwnershipParamsSchema, lsp29LumeraChunksSchema, lsp29S3ChunksSchema, lsp29TimeLockedParamsSchema };
+export type { LSP29ArweaveChunks, LSP29Backend, LSP29Chunks, LSP29DigitalAssetBalanceParams, LSP29EncryptedAsset, LSP29EncryptedAssetInner, LSP29Encryption, LSP29EncryptionData, LSP29EncryptionParams, LSP29File, LSP29IpfsChunks, LSP29Lsp26FollowerParams, LSP29Lsp8OwnershipParams, LSP29LumeraChunks, LSP29Method, LSP29Provider, LSP29S3Chunks, LSP29TimeLockedParams };