@opendatalabs/vana-sdk 0.1.0-alpha.7ee7635 → 0.1.0-alpha.80df35f

package/dist/controllers/protocol.d.cts

@@ -1,188 +0,0 @@
-import { GetContractReturnType } from 'viem';
-import { ContractInfo } from '../types/contracts.cjs';
-import { ControllerContext } from '../types/controller-context.cjs';
-import { VanaContract, ContractAbis } from '../generated/abi/index.cjs';
-import { ContractFactory } from '../contracts/contractController.cjs';
-import '../platform/interface.cjs';
-import '../types/config.cjs';
-import '../types/chains.cjs';
-import '../types/storage.cjs';
-import '../types/permissions.cjs';
-import '../storage/manager.cjs';
-import '../types/operations.cjs';
-import '../generated/event-types.cjs';
-import '../generated/server/server-exports.cjs';
-import '../generated/server/server.cjs';
-import '../generated/abi/ComputeEngineImplementation.cjs';
-import '../generated/abi/DataRegistryImplementation.cjs';
-import '../generated/abi/TeePoolImplementation.cjs';
-import '../generated/abi/TeePoolPhalaImplementation.cjs';
-import '../generated/abi/DataPortabilityPermissionsImplementation.cjs';
-import '../generated/abi/DataPortabilityServersImplementation.cjs';
-import '../generated/abi/DataPortabilityGranteesImplementation.cjs';
-import '../generated/abi/DataRefinerRegistryImplementation.cjs';
-import '../generated/abi/QueryEngineImplementation.cjs';
-import '../generated/abi/ComputeInstructionRegistryImplementation.cjs';
-import '../generated/abi/TeePoolEphemeralStandardImplementation.cjs';
-import '../generated/abi/TeePoolPersistentStandardImplementation.cjs';
-import '../generated/abi/TeePoolPersistentGpuImplementation.cjs';
-import '../generated/abi/TeePoolDedicatedStandardImplementation.cjs';
-import '../generated/abi/TeePoolDedicatedGpuImplementation.cjs';
-import '../generated/abi/VanaEpochImplementation.cjs';
-import '../generated/abi/DLPRegistryImplementation.cjs';
-import '../generated/abi/DLPTreasuryImplementation.cjs';
-import '../generated/abi/DLPRewardDeployerTreasuryImplementation.cjs';
-import '../generated/abi/DLPPerformanceImplementation.cjs';
-import '../generated/abi/DLPRewardDeployerImplementation.cjs';
-import '../generated/abi/DLPRewardSwapImplementation.cjs';
-import '../generated/abi/SwapHelperImplementation.cjs';
-import '../generated/abi/DLPRootImplementation.cjs';
-import '../generated/abi/DataLiquidityPoolImplementation.cjs';
-import '../generated/abi/DLPRegistryTreasuryImplementation.cjs';
-import '../generated/abi/VanaPoolStakingImplementation.cjs';
-import '../generated/abi/VanaPoolEntityImplementation.cjs';
-import '../generated/abi/VanaPoolTreasuryImplementation.cjs';
-import '../generated/abi/DATImplementation.cjs';
-import '../generated/abi/DATFactoryImplementation.cjs';
-import '../generated/abi/DATPausableImplementation.cjs';
-import '../generated/abi/DATVotesImplementation.cjs';
-import 'abitype';
-import '../core/client.cjs';
-import '../config/chains.cjs';
-
-/**
- * Provides direct, low-level access to all Vana protocol smart contracts.
- *
- * @remarks
- * This controller serves as the designated "escape hatch" for advanced developers who need
- * to interact directly with the underlying blockchain contracts. It provides access to
- * contract addresses, ABIs, and factory methods for creating typed contract instances.
- * Most developers should use the higher-level DataController and PermissionsController
- * instead of this advanced API.
- *
- * **Contract Selection:**
- * The controller automatically handles chain detection and provides only contracts that
- * are deployed on the current network. All contract instances are fully typed for
- * enhanced developer experience and type safety.
- *
- * **Method Selection:**
- * - `getContract()` retrieves contract address and ABI for manual interaction
- * - `createContract()` returns fully typed contract instance with read/write methods
- * - `getAvailableContracts()` lists all contracts deployed on current chain
- * - `isContractAvailable()` checks if specific contract exists on current chain
- * - `getChainId()` and `getChainName()` provide current network information
- *
- * **Usage Guidelines:**
- * Use this controller when high-level controllers don't provide needed functionality.
- * Most developers should use `vana.data.*` for files and `vana.permissions.*` for access control.
- *
- * **Type Safety:**
- * Use `as const` assertion with contract names for full TypeScript type inference.
- * Contract instances provide complete typing for all methods, parameters, and return values.
- *
- * @example
- * ```typescript
- * // Get contract info for direct interaction
- * const registry = vana.protocol.getContract("DataRegistry" as const);
- *
- * // Access contract address and ABI with full typing
- * console.log(registry.address); // Contract address on current chain
- * console.log(registry.abi);     // Fully typed contract ABI
- *
- * // Create a typed contract instance
- * const contract = vana.protocol.createContract("DataRegistry" as const);
- * const fileCount = await contract.read.filesCount();
- * ```
- * @category Advanced
- * @see {@link https://docs.vana.com/developer/protocol/contracts | Vana Protocol Contracts} for contract specifications
- */
-declare class ProtocolController {
-    private readonly context;
-    private readonly contractFactory;
-    constructor(context: ControllerContext);
-    /**
-     * Retrieves the address and ABI for a specific Vana protocol contract.
-     *
-     * @remarks
-     * This method provides direct access to contract addresses and ABIs for the current
-     * chain. It includes full TypeScript type inference when using const assertions,
-     * enabling type-safe contract interactions. The method only returns contracts that
-     * are actually deployed on the current network.
-     * @param contractName - The name of the Vana contract to retrieve (use const assertion for full typing)
-     * @returns An object containing the contract's address and fully typed ABI
-     * @throws {ContractNotFoundError} When the contract is not deployed on the current chain.
-     *   Verify contract name spelling and check current network with `getChainId()`.
-     * @example
-     * ```typescript
-     * // Get contract info with full type inference
-     * const dataRegistry = vana.protocol.getContract("DataRegistry" as const);
-     *
-     * // Now dataRegistry.abi is fully typed for the DataRegistry contract
-     * console.log(dataRegistry.address); // "0x123..."
-     * console.log(dataRegistry.abi.length); // Full ABI array
-     * ```
-     */
-    getContract<T extends VanaContract>(contractName: T): ContractInfo<ContractAbis[T]>;
-    /**
-     * Creates a fully typed contract instance ready for blockchain interaction.
-     *
-     * @remarks
-     * This method creates a contract instance with complete type safety for all contract
-     * methods including read operations, write operations, and event handling. The instance
-     * is pre-configured with the correct address, ABI, and wallet client for immediate use.
-     * All method parameters and return types are fully typed based on the contract ABI.
-     * @param contractName - The name of the Vana contract (use const assertion for full typing)
-     * @returns A fully typed contract instance with read/write methods and event handling
-     * @throws {ContractNotFoundError} When the contract is not deployed on the current chain
-     * @example
-     * ```typescript
-     * // Create typed contract instance
-     * const dataRegistry = vana.protocol.createContract("DataRegistry" as const);
-     *
-     * // Full type safety for all operations
-     * const fileCount = await dataRegistry.read.filesCount(); // Type: bigint
-     * const txHash = await dataRegistry.write.addFile(["ipfs://..."]); // Typed parameters
-     *
-     * // Listen to events with full typing
-     * const logs = await dataRegistry.getEvents.FileAdded();
-     * ```
-     */
-    createContract<T extends VanaContract>(contractName: T): GetContractReturnType<ContractAbis[T]>;
-    /**
-     * Gets all available contract names that can be used with getContract().
-     * Returns only contracts that are actually deployed on the current chain.
-     *
-     * @returns Array of all available contract names for the current chain
-     */
-    getAvailableContracts(): VanaContract[];
-    /**
-     * Checks if a specific contract is available on the current chain.
-     *
-     * @param contractName - The contract name to check
-     * @returns Whether the contract is deployed on the current chain
-     */
-    isContractAvailable(contractName: VanaContract): boolean;
-    /**
-     * Gets the contract factory instance for advanced usage.
-     * This provides access to additional contract management methods.
-     *
-     * @returns The contract factory instance
-     */
-    getContractFactory(): ContractFactory;
-    /**
-     * Gets the current chain ID from the wallet client.
-     *
-     * @returns The chain ID
-     * @throws {Error} When chain ID is not available from wallet client
-     */
-    getChainId(): number;
-    /**
-     * Gets the current chain name from the wallet client.
-     *
-     * @returns The chain name
-     * @throws {Error} When chain name is not available from wallet client
-     */
-    getChainName(): string;
-}
-
-export { ProtocolController };

package/dist/controllers/schemas.d.cts

@@ -1,260 +0,0 @@
-import { CompleteSchema, Schema, AddSchemaParams } from '../types/data.cjs';
-import { SchemaAddedResult } from '../types/transactionResults.cjs';
-import { ControllerContext } from '../types/controller-context.cjs';
-import 'viem';
-import '../platform/interface.cjs';
-import '../types/config.cjs';
-import '../types/chains.cjs';
-import '../types/storage.cjs';
-import '../types/permissions.cjs';
-import '../storage/manager.cjs';
-import '../types/operations.cjs';
-import '../generated/event-types.cjs';
-import '../generated/server/server-exports.cjs';
-import '../generated/server/server.cjs';
-
-/**
- * Parameters for creating a new schema with automatic IPFS upload.
- *
- * @remarks
- * This interface is used with the high-level `schemas.create()` method which
- * automatically uploads the schema definition to IPFS and registers it on-chain.
- * @category Schema Management
- */
-interface CreateSchemaParams {
-    /** The name of the schema */
-    name: string;
-    /** The dialect of the schema (e.g., 'json' or 'sqlite') */
-    dialect: "json" | "sqlite";
-    /** The schema definition object or JSON string */
-    schema: object | string;
-}
-/**
- * Result of creating a new schema.
- *
- * @remarks
- * Returned by the `schemas.create()` method after successful upload and registration.
- * @category Schema Management
- */
-interface CreateSchemaResult {
-    /** The schema ID assigned by the contract */
-    schemaId: number;
-    /** The IPFS URL where the schema definition is stored */
-    definitionUrl: string;
-    /** The transaction hash of the schema registration */
-    transactionHash: string;
-}
-/**
- * Manages data schemas and refiners on the Vana network.
- *
- * @remarks
- * This controller handles the complete lifecycle of data schemas including creation,
- * validation, IPFS upload, and blockchain registration. It provides methods for managing
- * both schemas (data structure definitions) and refiners (data processing definitions).
- *
- * **Schema Storage:**
- * Schemas are stored unencrypted on IPFS for public access and reusability across the network.
- * Schema definitions use JSON Schema format for data validation and structure definition.
- *
- * **Method Selection:**
- * - `create()` validates, uploads to IPFS, and registers new schemas on blockchain
- * - `get()` retrieves existing schema metadata by ID from blockchain contracts
- * - `count()` returns total number of registered schemas for pagination
- * - `list()` provides paginated access to all schemas with optional filtering
- * - `addSchema()` provides lower-level schema registration with pre-uploaded URLs
- *
- * **Storage Requirements:**
- * Methods requiring storage configuration: `create()`
- * Methods working without storage: `get()`, `count()`, `list()`, `addSchema()`
- *
- * @example
- * ```typescript
- * // Create a new schema with automatic IPFS upload
- * const result = await vana.schemas.create({
- *   name: "User Profile",
- *   dialect: "json",
- *   schema: {
- *     type: "object",
- *     properties: {
- *       name: { type: "string" },
- *       age: { type: "number" }
- *     },
- *     required: ["name"]
- *   }
- * });
- *
- * // Get an existing schema
- * const schema = await vana.schemas.get(1);
- *
- * // List all schemas
- * const count = await vana.schemas.count();
- * ```
- * @category Schema Management
- */
-declare class SchemaController {
-    private readonly context;
-    constructor(context: ControllerContext);
-    /**
-     * Creates a new schema with automatic validation and IPFS upload.
-     *
-     * @remarks
-     * This is the primary method for creating schemas on the Vana network. It handles
-     * the complete workflow including schema validation, IPFS upload, and blockchain
-     * registration. The schema definition is stored unencrypted on IPFS to enable
-     * public access and reusability.
-     *
-     * The method automatically:
-     * - Validates the schema definition against the Vana metaschema
-     * - Uploads the definition to IPFS to generate a permanent URL
-     * - Registers the schema on the blockchain with the generated URL
-     *
-     * @param params - Schema creation parameters including name, dialect, and definition
-     * @returns Promise resolving to creation results with schema ID and transaction hash
-     * @throws {SchemaValidationError} When the schema definition is invalid
-     * @throws {Error} When IPFS upload or blockchain registration fails
-     * @example
-     * ```typescript
-     * // Create a JSON schema for user profiles
-     * const result = await vana.schemas.create({
-     *   name: "User Profile",
-     *   dialect: "json",
-     *   schema: {
-     *     type: "object",
-     *     properties: {
-     *       name: { type: "string" },
-     *       age: { type: "number", minimum: 0 }
-     *     },
-     *     required: ["name"]
-     *   }
-     * });
-     *
-     * console.log(`Schema created with ID: ${result.schemaId}`);
-     * ```
-     */
-    create(params: CreateSchemaParams): Promise<CreateSchemaResult>;
-    /**
-     * Retrieves a complete schema by its ID with definition fetched and flattened.
-     *
-     * @param schemaId - The ID of the schema to retrieve
-     * @param options - Optional parameters
-     * @param options.subgraphUrl - Custom subgraph URL to use instead of default
-     * @returns Promise resolving to the complete schema object with all fields populated
-     * @throws {Error} When the schema is not found, definition cannot be fetched, or chain is unavailable
-     * @example
-     * ```typescript
-     * const schema = await vana.schemas.get(1);
-     * console.log(`Schema: ${schema.name} (${schema.dialect})`);
-     * console.log(`Version: ${schema.version}`);
-     * console.log(`Description: ${schema.description}`);
-     * console.log('Schema:', schema.schema);
-     *
-     * // Use directly with validator (schema has all required fields)
-     * validator.validateDataAgainstSchema(data, schema);
-     * ```
-     */
-    get(schemaId: number, options?: {
-        subgraphUrl?: string;
-    }): Promise<CompleteSchema>;
-    /**
-     * Gets the total number of schemas registered on the network.
-     *
-     * @param options - Optional parameters
-     * @param options.subgraphUrl - Custom subgraph URL to use instead of default
-     * @returns Promise resolving to the total schema count
-     * @throws {Error} When the count cannot be retrieved
-     * @example
-     * ```typescript
-     * const count = await vana.schemas.count();
-     * console.log(`Total schemas: ${count}`);
-     *
-     * // With custom subgraph
-     * const count = await vana.schemas.count({
-     *   subgraphUrl: 'https://custom-subgraph.com/graphql'
-     * });
-     * ```
-     */
-    count(options?: {
-        subgraphUrl?: string;
-    }): Promise<number>;
-    /**
-     * Lists all schemas with pagination.
-     *
-     * @param options - Optional parameters for listing schemas
-     * @param options.limit - Maximum number of schemas to return
-     * @param options.offset - Number of schemas to skip
-     * @param options.subgraphUrl - Custom subgraph URL to use instead of default
-     * @param options.includeDefinitions - Whether to fetch and include schema definitions (default: false for performance)
-     * @returns Promise resolving to an array of schemas
-     * @example
-     * ```typescript
-     * // Get all schemas (without definitions for performance)
-     * const schemas = await vana.schemas.list();
-     *
-     * // Get schemas with definitions
-     * const schemas = await vana.schemas.list({ includeDefinitions: true });
-     *
-     * // Get schemas with pagination
-     * const schemas = await vana.schemas.list({ limit: 10, offset: 0 });
-     * ```
-     */
-    list(options?: {
-        limit?: number;
-        offset?: number;
-        subgraphUrl?: string;
-        includeDefinitions?: boolean;
-    }): Promise<Schema[]>;
-    /**
-     * Adds a schema using the legacy method (low-level API).
-     *
-     * @deprecated Use create() instead for the high-level API with automatic IPFS upload
-     * @param params - Schema parameters including pre-generated definition URL
-     * @returns Promise resolving to the add schema result
-     */
-    addSchema(params: AddSchemaParams): Promise<SchemaAddedResult>;
-    /**
-     * Internal method: Query schema via subgraph
-     *
-     * @param params - Query parameters
-     * @param params.schemaId - The ID of the schema to retrieve
-     * @param params.subgraphUrl - The subgraph URL to query
-     * @returns Promise resolving to the schema object
-     * @private
-     */
-    private _getSchemaViaSubgraph;
-    /**
-     * Internal method: List schemas via subgraph
-     *
-     * @param params - Query parameters
-     * @param params.limit - Maximum number of schemas to return
-     * @param params.offset - Number of schemas to skip
-     * @param params.subgraphUrl - The subgraph URL to query
-     * @returns Promise resolving to an array of schemas
-     * @private
-     */
-    private _listSchemasViaSubgraph;
-    /**
-     * Internal method: Count schemas via subgraph
-     *
-     * @param params - Query parameters
-     * @param params.subgraphUrl - The subgraph URL to query
-     * @returns Promise resolving to the total schema count
-     * @private
-     */
-    private _countSchemasViaSubgraph;
-    /**
-     * Gets the user's wallet address.
-     *
-     * @private
-     * @returns Promise resolving to the user's address
-     */
-    private getUserAddress;
-    /**
-     * Fetches and attaches definitions to an array of schemas.
-     *
-     * @param schemas - Array of schemas to fetch definitions for
-     * @private
-     */
-    private _fetchDefinitionsForSchemas;
-}
-
-export { type CreateSchemaParams, type CreateSchemaResult, SchemaController };

package/dist/controllers/server.d.cts

@@ -1,230 +0,0 @@
-import { Operation, PollingOptions } from '../types/operations.cjs';
-import { ControllerContext } from '../types/controller-context.cjs';
-import { InitPersonalServerParams, PersonalServerIdentity, CreateOperationParams } from '../types/personal.cjs';
-import '../generated/event-types.cjs';
-import 'viem';
-import '../generated/server/server-exports.cjs';
-import '../generated/server/server.cjs';
-import '../platform/interface.cjs';
-import '../types/config.cjs';
-import '../types/chains.cjs';
-import '../types/storage.cjs';
-import '../types/permissions.cjs';
-import '../storage/manager.cjs';
-
-/**
- * Manages interactions with Vana personal servers and identity infrastructure.
- *
- * @remarks
- * This controller handles communication with personal servers for data processing
- * and identity servers for public key derivation. It provides methods for posting
- * computation requests to personal servers, polling for results, and retrieving
- * cryptographic keys for secure data sharing. All server interactions use the
- * Replicate API infrastructure with proper authentication and error handling.
- *
- * **Server Identity System:**
- * Personal servers use deterministic key derivation: each user address maps to a specific server identity.
- * This enables secure communication without requiring servers to be online during key retrieval.
- *
- * **Method Selection:**
- * - `getIdentity()` retrieves server public keys and addresses for encryption setup
- * - `createOperation()` submits computation requests with signed permission verification
- * - `getOperation()` polls operation status and retrieves results when complete
- * - `cancelOperation()` stops running operations when cancellation is supported
- *
- * **Workflow Pattern:**
- * Typical flow: Get identity → Create operation → Poll status → Retrieve results
- *
- * @example
- * ```typescript
- * // Get a server's identity including public key for encryption
- * const identity = await vana.server.getIdentity({
- *   userAddress: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36"
- * });
- *
- * // Create an operation using a granted permission
- * const response = await vana.server.createOperation({
- *   permissionId: 123,
- * });
- *
- * // Poll for computation results
- * const result = await vana.server.getOperation(response.id);
- * ```
- * @category Server Management
- * @see {@link https://docs.vana.com/developer/personal-servers | Vana Personal Servers} for conceptual overview
- */
-declare class ServerController {
-    private readonly context;
-    constructor(context: ControllerContext);
-    private get personalServerBaseUrl();
-    /**
-     * Retrieves the cryptographic identity of a personal server.
-     *
-     * @remarks
-     * This method fetches the public key and metadata for a personal server,
-     * which is required for encrypting data before sharing with the server.
-     * The identity includes the server's public key, address, and operational
-     * details needed for secure communication. This information is cached
-     * by identity servers to enable offline key retrieval.
-     *
-     * @param request - Parameters containing the user address
-     * @param request.userAddress - The wallet address associated with the personal server
-     * @returns Promise resolving to the server's identity information
-     * @throws {NetworkError} When the identity service is unavailable or returns invalid data
-     * @throws {PersonalServerError} When server identity cannot be retrieved
-     * @example
-     * ```typescript
-     * // Get server identity for data encryption
-     * const identity = await vana.server.getIdentity({
-     *   userAddress: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36"
-     * });
-     *
-     * console.log(`Server: ${identity.name}`);
-     * console.log(`Address: ${identity.address}`);
-     * console.log(`Public Key: ${identity.public_key}`);
-     *
-     * // Use the public key for encrypting data to share with this server
-     * const encryptedData = await encryptWithWalletPublicKey(
-     *   userData,
-     *   identity.public_key
-     * );
-     * ```
-     */
-    getIdentity(request: InitPersonalServerParams): Promise<PersonalServerIdentity>;
-    /**
-     * Creates a server operation and returns its details as a plain object.
-     *
-     * @remarks
-     * This method submits a computation request to the personal server and returns
-     * an Operation object that can be serialized and passed across API boundaries.
-     * Use `waitForOperation()` to poll for completion.
-     *
-     * @param params - The operation request parameters
-     * @param params.permissionId - The permission ID authorizing this operation.
-     *   Obtain via `vana.permissions.getUserPermissionGrantsOnChain()`.
-     * @returns An Operation object containing the operation ID and status
-     * @throws {PersonalServerError} When the server request fails or parameters are invalid
-     * @throws {NetworkError} When personal server API communication fails
-     * @example
-     * ```typescript
-     * const operation = await vana.server.createOperation({
-     *   permissionId: 123
-     * });
-     * console.log(`Operation ID: ${operation.id}`);
-     *
-     * // Wait for completion
-     * const result = await vana.server.waitForOperation(operation.id);
-     * console.log("Result:", result.result);
-     * ```
-     */
-    createOperation<T = unknown>(params: CreateOperationParams): Promise<Operation<T>>;
-    /**
-     * Retrieves the current status and result of a server operation.
-     *
-     * @remarks
-     * Common status values: `starting`, `running`, `succeeded`, `failed`, `canceled`.
-     * When status is `succeeded`, the result field contains the operation output.
-     *
-     * @param operationId - The ID of the operation to query
-     * @returns The operation as a plain object containing status, result, and metadata
-     * @throws {NetworkError} When the API request fails or returns invalid data
-     * @example
-     * ```typescript
-     * const operation = await vana.server.getOperation(operationId);
-     * if (operation.status === 'succeeded') {
-     *   console.log('Result:', operation.result);
-     * }
-     * ```
-     */
-    getOperation<T = unknown>(operationId: string): Promise<Operation<T>>;
-    /**
-     * Waits for an operation to complete and returns the final result.
-     *
-     * @remarks
-     * This method polls the operation status at regular intervals until it
-     * reaches a terminal state (succeeded, failed, or canceled). Supports
-     * ergonomic overloads to accept either an Operation object or just the ID.
-     *
-     * @param opOrId - Either an Operation object or operation ID string
-     * @param options - Optional polling configuration
-     * @returns The completed operation with result or error
-     * @throws {PersonalServerError} When the operation fails or times out
-     * @example
-     * ```typescript
-     * // Using operation object
-     * const operation = await vana.server.createOperation({ permissionId: 123 });
-     * const completed = await vana.server.waitForOperation(operation);
-     *
-     * // Using just the ID
-     * const completed = await vana.server.waitForOperation("op_abc123");
-     *
-     * // With custom timeout
-     * const completed = await vana.server.waitForOperation(operation, {
-     *   timeout: 60000,
-     *   pollingInterval: 1000
-     * });
-     * ```
-     */
-    waitForOperation<T = unknown>(opOrId: Operation<T> | string, options?: PollingOptions): Promise<Operation<T>>;
-    /**
-     * Cancels a running operation on the personal server.
-     *
-     * @remarks
-     * This method attempts to cancel an operation that is currently processing
-     * on the personal server. The operation must be in a cancellable state
-     * (typically `starting` or `processing`). Not all operations support
-     * cancellation, and cancellation may not be immediate. The server will
-     * attempt to stop the operation and update its status to `canceled`.
-     *
-     * **Cancellation Behavior:**
-     * - Operations in `succeeded` or `failed` states cannot be canceled
-     * - Some long-running operations may take time to respond to cancellation
-     * - Always verify cancellation by polling the operation status afterward
-     *
-     * @param operationId - The unique identifier of the operation to cancel,
-     *   obtained from `createOperation()` response
-     * @returns Promise that resolves when the cancellation request is accepted
-     * @throws {PersonalServerError} When the operation cannot be canceled or doesn't exist.
-     *   Check operation status - it may already be completed or failed.
-     * @throws {NetworkError} When unable to reach the personal server API.
-     *   Verify server URL and network connectivity.
-     * @example
-     * ```typescript
-     * // Start a long-running operation
-     * const operation = await vana.server.createOperation({
-     *   permissionId: 123
-     * });
-     *
-     * // Cancel if needed
-     * try {
-     *   await vana.server.cancelOperation(operation.id);
-     *   console.log("Cancellation requested");
-     *
-     *   // Verify cancellation
-     *   const status = await vana.server.getOperation(operation.id);
-     *   if (status.status === "canceled") {
-     *     console.log("Operation successfully canceled");
-     *   }
-     * } catch (error) {
-     *   console.error("Failed to cancel:", error);
-     * }
-     * ```
-     */
-    cancelOperation(operationId: string): Promise<void>;
-    /**
-     * Makes the request to the personal server API.
-     *
-     * @param requestBody - The post request parameters to serialize
-     * @returns JSON string representation of the request data
-     */
-    private makeRequest;
-    /**
-     * Creates a signature for the request JSON.
-     *
-     * @param requestJson - The JSON string to sign
-     * @returns Promise resolving to the cryptographic signature
-     */
-    private createSignature;
-}
-
-export { ServerController };