@cmdoss/memwal-sdk 0.6.0

package/dist/generated/pdw/memory.d.ts

@@ -0,0 +1,676 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Memory management module for Personal Data Wallet
+ *
+ * This module provides memory record management with:
+ *
+ * - Rich metadata for encrypted content stored on Walrus
+ * - Support for both capability-based and legacy address-based access
+ * - Vector embedding storage for semantic search
+ * - Knowledge graph integration
+ *
+ * V2 Changes (Capability-based):
+ *
+ * - Added capability_id field to link memories to MemoryCap
+ * - New create_memory_with_cap() for capability-based creation
+ * - Maintains backward compatibility with existing functions
+ */
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.js';
+import { type Transaction } from '@mysten/sui/transactions';
+export declare const MemoryCreated: MoveStruct<{
+    id: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    category: import("@mysten/bcs").BcsType<string, string, "string">;
+    vector_id: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** V2: Link to MemoryCap object ID */
+    capability_id: import("@mysten/bcs").BcsType<string | null, string | Uint8Array<ArrayBufferLike> | null | undefined, "Option<bytes[32]>">;
+    /**
+     * V2: App context for filtering (e.g., "MEMO", "HEALTH")
+     *
+     * - Query all: no filter
+     * - Query by context: filter by app_id
+     */
+    app_id: import("@mysten/bcs").BcsType<string | null, string | null | undefined, "Option<string>">;
+}, "@local-pkg/pdw::memory::MemoryCreated">;
+export declare const MemoryIndexUpdated: MoveStruct<{
+    id: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    version: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    index_blob_id: import("@mysten/bcs").BcsType<string, string, "string">;
+    graph_blob_id: import("@mysten/bcs").BcsType<string, string, "string">;
+}, "@local-pkg/pdw::memory::MemoryIndexUpdated">;
+export declare const MemoryMetadataUpdated: MoveStruct<{
+    memory_id: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    metadata_blob_id: import("@mysten/bcs").BcsType<string, string, "string">;
+    embedding_dimension: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/pdw::memory::MemoryMetadataUpdated">;
+export declare const MemoryUpdated: MoveStruct<{
+    id: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /**
+     * Fields that were updated (bitmask: 1=blob_id, 2=category, 4=topic, 8=importance,
+     * 16=embedding)
+     */
+    updated_fields: import("@mysten/bcs").BcsType<number, number, "u8">;
+    new_blob_id: import("@mysten/bcs").BcsType<string | null, string | null | undefined, "Option<string>">;
+    new_category: import("@mysten/bcs").BcsType<string | null, string | null | undefined, "Option<string>">;
+    updated_at: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/pdw::memory::MemoryUpdated">;
+export declare const MemoryMetadata: MoveStruct<{
+    content_type: import("@mysten/bcs").BcsType<string, string, "string">;
+    content_size: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    content_hash: import("@mysten/bcs").BcsType<string, string, "string">;
+    category: import("@mysten/bcs").BcsType<string, string, "string">;
+    topic: import("@mysten/bcs").BcsType<string, string, "string">;
+    importance: import("@mysten/bcs").BcsType<number, number, "u8">;
+    embedding_blob_id: import("@mysten/bcs").BcsType<string, string, "string">;
+    embedding_dimension: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    created_timestamp: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    updated_timestamp: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    custom_metadata: MoveStruct<{
+        contents: import("@mysten/bcs").BcsType<{
+            key: string;
+            value: string;
+        }[], Iterable<{
+            key: string;
+            value: string;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, string>">;
+}, "@local-pkg/pdw::memory::MemoryMetadata">;
+export declare const MemoryIndex: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    owner: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    version: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    index_blob_id: import("@mysten/bcs").BcsType<string, string, "string">;
+    graph_blob_id: import("@mysten/bcs").BcsType<string, string, "string">;
+}, "@local-pkg/pdw::memory::MemoryIndex">;
+export declare const Memory: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    owner: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    category: import("@mysten/bcs").BcsType<string, string, "string">;
+    vector_id: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    blob_id: import("@mysten/bcs").BcsType<string, string, "string">;
+    metadata: MoveStruct<{
+        content_type: import("@mysten/bcs").BcsType<string, string, "string">;
+        content_size: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+        content_hash: import("@mysten/bcs").BcsType<string, string, "string">;
+        category: import("@mysten/bcs").BcsType<string, string, "string">;
+        topic: import("@mysten/bcs").BcsType<string, string, "string">;
+        importance: import("@mysten/bcs").BcsType<number, number, "u8">;
+        embedding_blob_id: import("@mysten/bcs").BcsType<string, string, "string">;
+        embedding_dimension: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+        created_timestamp: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+        updated_timestamp: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+        custom_metadata: MoveStruct<{
+            contents: import("@mysten/bcs").BcsType<{
+                key: string;
+                value: string;
+            }[], Iterable<{
+                key: string;
+                value: string;
+            }> & {
+                length: number;
+            }, string>;
+        }, "0x2::vec_map::VecMap<string, string>">;
+    }, "@local-pkg/pdw::memory::MemoryMetadata">;
+    /**
+     * V2: Link to MemoryCap for capability-based access control If set, access is
+     * controlled via MemoryCap ownership If none, falls back to owner-based access
+     * (legacy)
+     */
+    capability_id: import("@mysten/bcs").BcsType<string | null, string | Uint8Array<ArrayBufferLike> | null | undefined, "Option<bytes[32]>">;
+    /**
+     * V2: App context for context-based querying Copied from MemoryCap.app_id for
+     * efficient filtering
+     *
+     * - Query all memories: getOwnedObjects without filter
+     * - Query by context: filter by app_id field
+     */
+    app_id: import("@mysten/bcs").BcsType<string | null, string | null | undefined, "Option<string>">;
+}, "@local-pkg/pdw::memory::Memory">;
+export interface CreateMemoryIndexArguments {
+    indexBlobId: RawTransactionArgument<number[]>;
+    graphBlobId: RawTransactionArgument<number[]>;
+}
+export interface CreateMemoryIndexOptions {
+    package?: string;
+    arguments: CreateMemoryIndexArguments | [
+        indexBlobId: RawTransactionArgument<number[]>,
+        graphBlobId: RawTransactionArgument<number[]>
+    ];
+}
+/** Create a new memory index for a user */
+export declare function createMemoryIndex(options: CreateMemoryIndexOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateMemoryIndexArguments {
+    memoryIndex: RawTransactionArgument<string>;
+    expectedVersion: RawTransactionArgument<number | bigint>;
+    newIndexBlobId: RawTransactionArgument<number[]>;
+    newGraphBlobId: RawTransactionArgument<number[]>;
+}
+export interface UpdateMemoryIndexOptions {
+    package?: string;
+    arguments: UpdateMemoryIndexArguments | [
+        memoryIndex: RawTransactionArgument<string>,
+        expectedVersion: RawTransactionArgument<number | bigint>,
+        newIndexBlobId: RawTransactionArgument<number[]>,
+        newGraphBlobId: RawTransactionArgument<number[]>
+    ];
+}
+/** Update an existing memory index with new blob IDs */
+export declare function updateMemoryIndex(options: UpdateMemoryIndexOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateMemoryMetadataArguments {
+    contentType: RawTransactionArgument<number[]>;
+    contentSize: RawTransactionArgument<number | bigint>;
+    contentHash: RawTransactionArgument<number[]>;
+    category: RawTransactionArgument<number[]>;
+    topic: RawTransactionArgument<number[]>;
+    importance: RawTransactionArgument<number>;
+    embeddingBlobId: RawTransactionArgument<number[]>;
+    embeddingDimension: RawTransactionArgument<number | bigint>;
+    createdTimestamp: RawTransactionArgument<number | bigint>;
+}
+export interface CreateMemoryMetadataOptions {
+    package?: string;
+    arguments: CreateMemoryMetadataArguments | [
+        contentType: RawTransactionArgument<number[]>,
+        contentSize: RawTransactionArgument<number | bigint>,
+        contentHash: RawTransactionArgument<number[]>,
+        category: RawTransactionArgument<number[]>,
+        topic: RawTransactionArgument<number[]>,
+        importance: RawTransactionArgument<number>,
+        embeddingBlobId: RawTransactionArgument<number[]>,
+        embeddingDimension: RawTransactionArgument<number | bigint>,
+        createdTimestamp: RawTransactionArgument<number | bigint>
+    ];
+}
+/** Create metadata struct with embedding */
+export declare function createMemoryMetadata(options: CreateMemoryMetadataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateMemoryRecordArguments {
+    category: RawTransactionArgument<number[]>;
+    vectorId: RawTransactionArgument<number | bigint>;
+    blobId: RawTransactionArgument<number[]>;
+    contentType: RawTransactionArgument<number[]>;
+    contentSize: RawTransactionArgument<number | bigint>;
+    contentHash: RawTransactionArgument<number[]>;
+    topic: RawTransactionArgument<number[]>;
+    importance: RawTransactionArgument<number>;
+    embeddingBlobId: RawTransactionArgument<number[]>;
+}
+export interface CreateMemoryRecordOptions {
+    package?: string;
+    arguments: CreateMemoryRecordArguments | [
+        category: RawTransactionArgument<number[]>,
+        vectorId: RawTransactionArgument<number | bigint>,
+        blobId: RawTransactionArgument<number[]>,
+        contentType: RawTransactionArgument<number[]>,
+        contentSize: RawTransactionArgument<number | bigint>,
+        contentHash: RawTransactionArgument<number[]>,
+        topic: RawTransactionArgument<number[]>,
+        importance: RawTransactionArgument<number>,
+        embeddingBlobId: RawTransactionArgument<number[]>
+    ];
+}
+/**
+ * Create a new memory record with rich metadata (LEGACY - for backward
+ * compatibility)
+ *
+ * NOTE: For new implementations, use create_memory_with_cap() instead which
+ * provides capability-based access control.
+ */
+export declare function createMemoryRecord(options: CreateMemoryRecordOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateMemoryWithCapArguments {
+    cap: RawTransactionArgument<string>;
+    category: RawTransactionArgument<number[]>;
+    vectorId: RawTransactionArgument<number | bigint>;
+    blobId: RawTransactionArgument<number[]>;
+    contentType: RawTransactionArgument<number[]>;
+    contentSize: RawTransactionArgument<number | bigint>;
+    contentHash: RawTransactionArgument<number[]>;
+    topic: RawTransactionArgument<number[]>;
+    importance: RawTransactionArgument<number>;
+    embeddingBlobId: RawTransactionArgument<number[]>;
+}
+export interface CreateMemoryWithCapOptions {
+    package?: string;
+    arguments: CreateMemoryWithCapArguments | [
+        cap: RawTransactionArgument<string>,
+        category: RawTransactionArgument<number[]>,
+        vectorId: RawTransactionArgument<number | bigint>,
+        blobId: RawTransactionArgument<number[]>,
+        contentType: RawTransactionArgument<number[]>,
+        contentSize: RawTransactionArgument<number | bigint>,
+        contentHash: RawTransactionArgument<number[]>,
+        topic: RawTransactionArgument<number[]>,
+        importance: RawTransactionArgument<number>,
+        embeddingBlobId: RawTransactionArgument<number[]>
+    ];
+}
+/**
+ * Create a new memory record with capability-based access control (V2 -
+ * RECOMMENDED)
+ *
+ * This function links the memory to a MemoryCap for SEAL-compliant access control.
+ * Benefits:
+ *
+ * - Access controlled via MemoryCap ownership
+ * - Cross-dApp sharing "just works" (same owner = access)
+ * - No allowlist management needed
+ *
+ * @param cap: Reference to the MemoryCap (proves ownership) @param category:
+ * Memory category @param vector_id: Links to HNSW index @param blob_id: Pointer to
+ * encrypted content on Walrus @param content_type: MIME type @param content_size:
+ * Size in bytes @param content_hash: Content hash (blob_id) @param topic: Topic
+ * classification @param importance: Importance scale (1-10) @param
+ * embedding_blob_id: Pointer to embedding on Walrus @param ctx: Transaction
+ * context
+ */
+export declare function createMemoryWithCap(options: CreateMemoryWithCapOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateMemoryMetadataArguments {
+    memory: RawTransactionArgument<string>;
+    newTopic: RawTransactionArgument<number[]>;
+    newImportance: RawTransactionArgument<number>;
+}
+export interface UpdateMemoryMetadataOptions {
+    package?: string;
+    arguments: UpdateMemoryMetadataArguments | [
+        memory: RawTransactionArgument<string>,
+        newTopic: RawTransactionArgument<number[]>,
+        newImportance: RawTransactionArgument<number>
+    ];
+}
+/** Update metadata for an existing memory */
+export declare function updateMemoryMetadata(options: UpdateMemoryMetadataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddCustomMetadataArguments {
+    memory: RawTransactionArgument<string>;
+    key: RawTransactionArgument<number[]>;
+    value: RawTransactionArgument<number[]>;
+}
+export interface AddCustomMetadataOptions {
+    package?: string;
+    arguments: AddCustomMetadataArguments | [
+        memory: RawTransactionArgument<string>,
+        key: RawTransactionArgument<number[]>,
+        value: RawTransactionArgument<number[]>
+    ];
+}
+/** Add custom metadata field */
+export declare function addCustomMetadata(options: AddCustomMetadataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateMemoryRecordArguments {
+    memory: RawTransactionArgument<string>;
+    newBlobId: RawTransactionArgument<number[]>;
+    newCategory: RawTransactionArgument<number[]>;
+    newTopic: RawTransactionArgument<number[]>;
+    newImportance: RawTransactionArgument<number>;
+    newEmbeddingBlobId: RawTransactionArgument<number[]>;
+    newContentHash: RawTransactionArgument<number[]>;
+    newContentSize: RawTransactionArgument<number | bigint>;
+}
+export interface UpdateMemoryRecordOptions {
+    package?: string;
+    arguments: UpdateMemoryRecordArguments | [
+        memory: RawTransactionArgument<string>,
+        newBlobId: RawTransactionArgument<number[]>,
+        newCategory: RawTransactionArgument<number[]>,
+        newTopic: RawTransactionArgument<number[]>,
+        newImportance: RawTransactionArgument<number>,
+        newEmbeddingBlobId: RawTransactionArgument<number[]>,
+        newContentHash: RawTransactionArgument<number[]>,
+        newContentSize: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Comprehensive update for a memory record
+ *
+ * Updates multiple fields of a Memory object in a single transaction. Only
+ * non-empty values will be updated (empty vector<u8> = skip update).
+ *
+ * This function follows Sui's object model where:
+ *
+ * - Objects are passed as mutable references (&mut)
+ * - Version number is automatically incremented by Sui runtime
+ * - Changes are atomic within the transaction
+ *
+ * @param memory: Mutable reference to the Memory object @param new_blob_id: New
+ * Walrus blob ID (empty = no change) @param new_category: New category (empty = no
+ * change) @param new_topic: New topic (empty = no change) @param new_importance:
+ * New importance (0 = no change, 1-10 = update) @param new_embedding_blob_id: New
+ * embedding blob ID (empty = no change) @param new_content_hash: New content hash
+ * (empty = no change) @param new_content_size: New content size (0 = no change)
+ * @param ctx: Transaction context
+ */
+export declare function updateMemoryRecord(options: UpdateMemoryRecordOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateMemoryWithCapArguments {
+    cap: RawTransactionArgument<string>;
+    memory: RawTransactionArgument<string>;
+    newBlobId: RawTransactionArgument<number[]>;
+    newCategory: RawTransactionArgument<number[]>;
+    newTopic: RawTransactionArgument<number[]>;
+    newImportance: RawTransactionArgument<number>;
+    newEmbeddingBlobId: RawTransactionArgument<number[]>;
+    newContentHash: RawTransactionArgument<number[]>;
+    newContentSize: RawTransactionArgument<number | bigint>;
+}
+export interface UpdateMemoryWithCapOptions {
+    package?: string;
+    arguments: UpdateMemoryWithCapArguments | [
+        cap: RawTransactionArgument<string>,
+        memory: RawTransactionArgument<string>,
+        newBlobId: RawTransactionArgument<number[]>,
+        newCategory: RawTransactionArgument<number[]>,
+        newTopic: RawTransactionArgument<number[]>,
+        newImportance: RawTransactionArgument<number>,
+        newEmbeddingBlobId: RawTransactionArgument<number[]>,
+        newContentHash: RawTransactionArgument<number[]>,
+        newContentSize: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Update memory record with capability verification (V2)
+ *
+ * Same as update_memory_record but verifies the caller owns the associated
+ * MemoryCap. Use this for capability-based memories to ensure proper access
+ * control.
+ *
+ * @param cap: Reference to the MemoryCap (proves ownership) @param memory: Mutable
+ * reference to the Memory object @param new_blob_id: New Walrus blob ID (empty =
+ * no change) @param new_category: New category (empty = no change) @param
+ * new_topic: New topic (empty = no change) @param new_importance: New importance
+ * (0 = no change, 1-10 = update) @param new_embedding_blob_id: New embedding blob
+ * ID (empty = no change) @param new_content_hash: New content hash (empty = no
+ * change) @param new_content_size: New content size (0 = no change) @param ctx:
+ * Transaction context
+ */
+export declare function updateMemoryWithCap(options: UpdateMemoryWithCapOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateMemoryRecordLightweightArguments {
+    category: RawTransactionArgument<number[]>;
+    vectorId: RawTransactionArgument<number | bigint>;
+    blobId: RawTransactionArgument<number[]>;
+    blobObjectId: RawTransactionArgument<number[]>;
+    importance: RawTransactionArgument<number>;
+}
+export interface CreateMemoryRecordLightweightOptions {
+    package?: string;
+    arguments: CreateMemoryRecordLightweightArguments | [
+        category: RawTransactionArgument<number[]>,
+        vectorId: RawTransactionArgument<number | bigint>,
+        blobId: RawTransactionArgument<number[]>,
+        blobObjectId: RawTransactionArgument<number[]>,
+        importance: RawTransactionArgument<number>
+    ];
+}
+/**
+ * Create a lightweight memory record (for use with Walrus metadata) - LEGACY
+ *
+ * This function creates a minimal on-chain Memory struct with only essential
+ * queryable fields. Rich metadata should be stored as Walrus blob metadata.
+ *
+ * Use this when:
+ *
+ * - Gas costs are a concern
+ * - Rich metadata is stored on Walrus blob
+ * - Only need basic filtering (category, vector_id)
+ *
+ * NOTE: For new implementations, use create_memory_lightweight_with_cap() instead
+ */
+export declare function createMemoryRecordLightweight(options: CreateMemoryRecordLightweightOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateMemoryLightweightWithCapArguments {
+    cap: RawTransactionArgument<string>;
+    category: RawTransactionArgument<number[]>;
+    vectorId: RawTransactionArgument<number | bigint>;
+    blobId: RawTransactionArgument<number[]>;
+    blobObjectId: RawTransactionArgument<number[]>;
+    importance: RawTransactionArgument<number>;
+}
+export interface CreateMemoryLightweightWithCapOptions {
+    package?: string;
+    arguments: CreateMemoryLightweightWithCapArguments | [
+        cap: RawTransactionArgument<string>,
+        category: RawTransactionArgument<number[]>,
+        vectorId: RawTransactionArgument<number | bigint>,
+        blobId: RawTransactionArgument<number[]>,
+        blobObjectId: RawTransactionArgument<number[]>,
+        importance: RawTransactionArgument<number>
+    ];
+}
+/**
+ * Create a lightweight memory record with capability-based access (V2 -
+ * RECOMMENDED)
+ *
+ * Gas-optimized version for capability-based access control.
+ *
+ * @param cap: Reference to the MemoryCap (proves ownership) @param category:
+ * Memory category @param vector_id: Links to HNSW index @param blob_id: Pointer to
+ * encrypted content on Walrus @param blob_object_id: Optional Walrus blob object
+ * ID @param importance: Importance scale (1-10) @param ctx: Transaction context
+ */
+export declare function createMemoryLightweightWithCap(options: CreateMemoryLightweightWithCapOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DeleteMemoryRecordArguments {
+    memory: RawTransactionArgument<string>;
+}
+export interface DeleteMemoryRecordOptions {
+    package?: string;
+    arguments: DeleteMemoryRecordArguments | [
+        memory: RawTransactionArgument<string>
+    ];
+}
+/** Delete a memory record */
+export declare function deleteMemoryRecord(options: DeleteMemoryRecordOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetIndexBlobIdArguments {
+    memoryIndex: RawTransactionArgument<string>;
+}
+export interface GetIndexBlobIdOptions {
+    package?: string;
+    arguments: GetIndexBlobIdArguments | [
+        memoryIndex: RawTransactionArgument<string>
+    ];
+}
+export declare function getIndexBlobId(options: GetIndexBlobIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetGraphBlobIdArguments {
+    memoryIndex: RawTransactionArgument<string>;
+}
+export interface GetGraphBlobIdOptions {
+    package?: string;
+    arguments: GetGraphBlobIdArguments | [
+        memoryIndex: RawTransactionArgument<string>
+    ];
+}
+export declare function getGraphBlobId(options: GetGraphBlobIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetVersionArguments {
+    memoryIndex: RawTransactionArgument<string>;
+}
+export interface GetVersionOptions {
+    package?: string;
+    arguments: GetVersionArguments | [
+        memoryIndex: RawTransactionArgument<string>
+    ];
+}
+export declare function getVersion(options: GetVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetMemoryBlobIdArguments {
+    memory: RawTransactionArgument<string>;
+}
+export interface GetMemoryBlobIdOptions {
+    package?: string;
+    arguments: GetMemoryBlobIdArguments | [
+        memory: RawTransactionArgument<string>
+    ];
+}
+export declare function getMemoryBlobId(options: GetMemoryBlobIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetMemoryVectorIdArguments {
+    memory: RawTransactionArgument<string>;
+}
+export interface GetMemoryVectorIdOptions {
+    package?: string;
+    arguments: GetMemoryVectorIdArguments | [
+        memory: RawTransactionArgument<string>
+    ];
+}
+export declare function getMemoryVectorId(options: GetMemoryVectorIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetMemoryCategoryArguments {
+    memory: RawTransactionArgument<string>;
+}
+export interface GetMemoryCategoryOptions {
+    package?: string;
+    arguments: GetMemoryCategoryArguments | [
+        memory: RawTransactionArgument<string>
+    ];
+}
+export declare function getMemoryCategory(options: GetMemoryCategoryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetMetadataArguments {
+    memory: RawTransactionArgument<string>;
+}
+export interface GetMetadataOptions {
+    package?: string;
+    arguments: GetMetadataArguments | [
+        memory: RawTransactionArgument<string>
+    ];
+}
+export declare function getMetadata(options: GetMetadataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetEmbeddingBlobIdArguments {
+    metadata: RawTransactionArgument<string>;
+}
+export interface GetEmbeddingBlobIdOptions {
+    package?: string;
+    arguments: GetEmbeddingBlobIdArguments | [
+        metadata: RawTransactionArgument<string>
+    ];
+}
+export declare function getEmbeddingBlobId(options: GetEmbeddingBlobIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetContentTypeArguments {
+    metadata: RawTransactionArgument<string>;
+}
+export interface GetContentTypeOptions {
+    package?: string;
+    arguments: GetContentTypeArguments | [
+        metadata: RawTransactionArgument<string>
+    ];
+}
+export declare function getContentType(options: GetContentTypeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetContentSizeArguments {
+    metadata: RawTransactionArgument<string>;
+}
+export interface GetContentSizeOptions {
+    package?: string;
+    arguments: GetContentSizeArguments | [
+        metadata: RawTransactionArgument<string>
+    ];
+}
+export declare function getContentSize(options: GetContentSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetTopicArguments {
+    metadata: RawTransactionArgument<string>;
+}
+export interface GetTopicOptions {
+    package?: string;
+    arguments: GetTopicArguments | [
+        metadata: RawTransactionArgument<string>
+    ];
+}
+export declare function getTopic(options: GetTopicOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetImportanceArguments {
+    metadata: RawTransactionArgument<string>;
+}
+export interface GetImportanceOptions {
+    package?: string;
+    arguments: GetImportanceArguments | [
+        metadata: RawTransactionArgument<string>
+    ];
+}
+export declare function getImportance(options: GetImportanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetCreatedTimestampArguments {
+    metadata: RawTransactionArgument<string>;
+}
+export interface GetCreatedTimestampOptions {
+    package?: string;
+    arguments: GetCreatedTimestampArguments | [
+        metadata: RawTransactionArgument<string>
+    ];
+}
+export declare function getCreatedTimestamp(options: GetCreatedTimestampOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetUpdatedTimestampArguments {
+    metadata: RawTransactionArgument<string>;
+}
+export interface GetUpdatedTimestampOptions {
+    package?: string;
+    arguments: GetUpdatedTimestampArguments | [
+        metadata: RawTransactionArgument<string>
+    ];
+}
+export declare function getUpdatedTimestamp(options: GetUpdatedTimestampOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetCustomMetadataArguments {
+    metadata: RawTransactionArgument<string>;
+}
+export interface GetCustomMetadataOptions {
+    package?: string;
+    arguments: GetCustomMetadataArguments | [
+        metadata: RawTransactionArgument<string>
+    ];
+}
+export declare function getCustomMetadata(options: GetCustomMetadataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetCapabilityIdArguments {
+    memory: RawTransactionArgument<string>;
+}
+export interface GetCapabilityIdOptions {
+    package?: string;
+    arguments: GetCapabilityIdArguments | [
+        memory: RawTransactionArgument<string>
+    ];
+}
+/** Get the capability_id from a memory (if linked to a MemoryCap) */
+export declare function getCapabilityId(options: GetCapabilityIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasCapabilityArguments {
+    memory: RawTransactionArgument<string>;
+}
+export interface HasCapabilityOptions {
+    package?: string;
+    arguments: HasCapabilityArguments | [
+        memory: RawTransactionArgument<string>
+    ];
+}
+/** Check if memory is linked to a capability (V2) */
+export declare function hasCapability(options: HasCapabilityOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsLegacyAccessArguments {
+    memory: RawTransactionArgument<string>;
+}
+export interface IsLegacyAccessOptions {
+    package?: string;
+    arguments: IsLegacyAccessArguments | [
+        memory: RawTransactionArgument<string>
+    ];
+}
+/** Check if memory is using legacy owner-based access */
+export declare function isLegacyAccess(options: IsLegacyAccessOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetAppIdArguments {
+    memory: RawTransactionArgument<string>;
+}
+export interface GetAppIdOptions {
+    package?: string;
+    arguments: GetAppIdArguments | [
+        memory: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Get the app_id from a memory (for context-based querying) Returns None for
+ * legacy memories without capability
+ */
+export declare function getAppId(options: GetAppIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsAppContextArguments {
+    memory: RawTransactionArgument<string>;
+    appId: RawTransactionArgument<string>;
+}
+export interface IsAppContextOptions {
+    package?: string;
+    arguments: IsAppContextArguments | [
+        memory: RawTransactionArgument<string>,
+        appId: RawTransactionArgument<string>
+    ];
+}
+/** Check if memory belongs to a specific app context */
+export declare function isAppContext(options: IsAppContextOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+//# sourceMappingURL=memory.d.ts.map