import * as viem from 'viem';
import { Chain, Address, Hash, WalletClient, Account, Abi, GetContractReturnType, PublicClient } from 'viem';
export { Abi, Account, Address, Chain, GetContractReturnType, Hash, PublicClient, WalletClient } from 'viem';
import { Abi as Abi$1 } from 'abitype';

/**
 * Supported Vana chain IDs
 */
type VanaChainId = 14800 | 1480;
/**
 * Supported Vana chains
 */
type VanaChain = Chain & {
    id: VanaChainId;
};
/**
 * Type guard to check if a chain ID is supported
 *
 * @param chainId - The chain ID to validate
 * @returns True if the chain ID is a supported Vana chain ID
 */
declare function isVanaChainId(chainId: number): chainId is VanaChainId;
/**
 * Type guard to check if a chain is a Vana chain
 *
 * @param chain - The chain object to validate
 * @returns True if the chain is a supported Vana chain
 */
declare function isVanaChain(chain: Chain): chain is VanaChain;

/**
 * Interface for storage providers that handle file upload, download, and management operations.
 *
 * Storage providers abstract different storage backends (IPFS, Google Drive, Pinata, etc.)
 * behind a common interface. The SDK uses these providers to store encrypted user data
 * and permission grants in a decentralized manner.
 *
 * @category Storage
 * @example
 * ```typescript
 * // Implement a custom storage provider
 * class MyStorageProvider implements StorageProvider {
 *   async upload(file: Blob, filename?: string): Promise<StorageUploadResult> {
 *     // Custom upload logic
 *     return { url: 'https://my-storage.com/file.dat', size: file.size };
 *   }
 *
 *   async download(url: string): Promise<Blob> {
 *     // Custom download logic
 *     const response = await fetch(url);
 *     return response.blob();
 *   }
 *
 *   async list(options?: StorageListOptions): Promise<StorageFile[]> {
 *     // Return list of files
 *     return [];
 *   }
 *
 *   async delete(url: string): Promise<void> {
 *     // Delete file implementation
 *   }
 * }
 * ```
 */
interface StorageProvider {
    /**
     * Upload a file to the storage provider
     *
     * @param file - The file to upload
     * @param filename - Optional custom filename
     * @returns Promise with storage URL and metadata
     */
    upload(file: Blob, filename?: string): Promise<StorageUploadResult>;
    /**
     * Download a file from the storage provider
     *
     * @param url - The storage URL
     * @returns Promise with file blob
     */
    download(url: string): Promise<Blob>;
    /**
     * List files from the storage provider
     *
     * @param options - Optional filtering and pagination
     * @returns Promise with file list
     */
    list(options?: StorageListOptions): Promise<StorageFile[]>;
    /**
     * Delete a file from the storage provider
     *
     * @param url - The storage URL
     * @returns Promise with success status
     */
    delete(url: string): Promise<boolean>;
    /**
     * Get provider-specific configuration
     *
     * @returns Provider configuration object
     */
    getConfig(): StorageProviderConfig;
}
interface StorageUploadResult {
    /** Public URL to access the file */
    url: string;
    /** File size in bytes */
    size: number;
    /** Content type/MIME type */
    contentType: string;
    /** Provider-specific metadata */
    metadata?: Record<string, unknown>;
}
interface StorageFile {
    /** File identifier */
    id: string;
    /** File name */
    name: string;
    /** Public URL to access the file */
    url: string;
    /** File size in bytes */
    size: number;
    /** Content type/MIME type */
    contentType: string;
    /** Upload timestamp */
    createdAt: Date;
    /** Provider-specific metadata */
    metadata?: Record<string, unknown>;
}
interface StorageListOptions {
    /** Maximum number of files to return */
    limit?: number;
    /** Pagination cursor/offset */
    offset?: string | number;
    /** Filter by file name pattern */
    namePattern?: string;
    /** Filter by content type */
    contentType?: string;
}
interface StorageProviderConfig {
    /** Provider name */
    name: string;
    /** Provider type */
    type: string;
    /** Whether authentication is required */
    requiresAuth: boolean;
    /** Supported features */
    features: {
        upload: boolean;
        download: boolean;
        list: boolean;
        delete: boolean;
    };
}
declare class StorageError extends Error {
    readonly code: string;
    readonly provider: string;
    constructor(message: string, code: string, provider: string, options?: {
        cause?: Error;
    });
}

/**
 * Represents a granted permission from the DataPermissions contract.
 *
 * This interface describes the structure of permissions that have been granted
 * on-chain, including all the metadata and parameters associated with the permission.
 * Used when querying user permissions or checking access rights.
 *
 * @category Permissions
 */
interface GrantedPermission {
    /** Unique identifier for the permission */
    id: bigint;
    /** Array of file IDs included in the permission */
    files: number[];
    /** Type of operation permitted (e.g., "llm_inference") */
    operation?: string;
    /** The grant URL containing all permission details */
    grant: string;
    /** The parameters associated with the permission */
    parameters?: Record<string, unknown>;
    /** Optional nonce used when granting the permission */
    nonce?: number;
    /** Optional block number when permission was granted */
    grantedAt?: number;
    /** Address that granted the permission */
    grantor: Address;
    /** Address that received the permission */
    grantee: Address;
    /** Whether the permission is still active */
    active: boolean;
    /** Expiration timestamp if applicable */
    expiresAt?: number;
}
/**
 * Parameters for granting data access permission to an application.
 *
 * This interface defines the required and optional parameters when granting
 * an application permission to access specific files for a particular operation.
 * Used with `vana.permissions.grant()`.
 *
 * @category Permissions
 * @example
 * ```typescript
 * const params: GrantPermissionParams = {
 *   to: '0x1234...', // Application address
 *   operation: 'llm_inference',
 *   files: [1, 2, 3], // File IDs to grant access to
 *   parameters: {
 *     model: 'gpt-4',
 *     maxTokens: 1000,
 *     prompt: 'Analyze my data'
 *   }
 * };
 * ```
 */
interface GrantPermissionParams$1 {
    /** The on-chain identity of the application */
    to: Address;
    /** The class of computation, e.g., "llm_inference" */
    operation: string;
    /** Array of file IDs to grant permission for */
    files: number[];
    /** The full, off-chain parameters (e.g., LLM prompt) */
    parameters: Record<string, unknown>;
    /** Optional pre-stored grant URL to avoid duplicate IPFS storage */
    grantUrl?: string;
    /** Optional nonce for the permission */
    nonce?: bigint;
    /** Optional expiration time for the permission */
    expiresAt?: number;
}
/**
 * Parameters for revoking a previously granted data access permission.
 *
 * Used with `PermissionsController.revoke()` to remove an application's access
 * to user data. Once revoked, the application can no longer use the permission
 * to access the specified files.
 *
 * @category Permissions
 * @example
 * ```typescript
 * const revokeParams: RevokePermissionParams = {
 *   permissionId: 123n // Permission ID to revoke
 * };
 *
 * await vana.permissions.revoke(revokeParams);
 * ```
 */
interface RevokePermissionParams {
    /** The permission ID to revoke */
    permissionId: bigint;
}
/**
 * Parameters for checking if a specific permission exists and is valid.
 *
 * Used to verify whether an application has active permission to access
 * specific user files for a particular operation before attempting to use the data.
 *
 * @category Permissions
 * @example
 * ```typescript
 * const checkParams: CheckPermissionParams = {
 *   application: '0x1234...', // App address
 *   operation: 'llm_inference',
 *   files: [1, 2, 3], // File IDs to check
 *   parameters: { model: 'gpt-4' }, // Operation parameters
 *   user: '0xabcd...' // Optional specific user
 * };
 *
 * const hasPermission = await vana.permissions.check(checkParams);
 * ```
 */
interface CheckPermissionParams {
    /** The application address */
    application: Address;
    /** The operation type */
    operation: string;
    /** The file IDs */
    files: number[];
    /** The grant parameters */
    parameters: Record<string, unknown>;
    /** The user address */
    user?: Address;
}
/**
 * Permission check result
 *
 * @category Permissions
 */
interface PermissionCheckResult {
    /** Whether the permission exists and is valid */
    exists: boolean;
    /** The permission details if it exists */
    permission?: GrantedPermission;
    /** Reason why permission is invalid (if applicable) */
    reason?: string;
}
/**
 * EIP-712 domain definition for PermissionGrant signatures
 *
 * @category Permissions
 */
interface PermissionGrantDomain {
    /** Domain name */
    name: string;
    /** Domain version */
    version: string;
    /** Chain ID */
    chainId: number;
    /** Verifying contract address */
    verifyingContract: Address;
}
/**
 * EIP-712 Permission message structure (current contract format)
 *
 * @category Permissions
 */
interface PermissionGrantMessage {
    /** Application address */
    application: Address;
    /** File IDs */
    files: number[];
    /** Operation type */
    operation: string;
    /** Grant URL */
    grant: string;
    /** Parameters as JSON string */
    parameters: string;
    /** Nonce */
    nonce: bigint;
}
/**
 * EIP-712 PermissionInput message structure (new simplified format)
 *
 * @category Permissions
 */
interface PermissionInputMessage {
    /** Nonce */
    nonce: bigint;
    /** Grant URL */
    grant: string;
    /** File IDs */
    fileIds: bigint[];
}
/**
 * Contract RevokePermissionInput structure
 *
 * @category Permissions
 */
interface RevokePermissionInput {
    /** Nonce */
    nonce: bigint;
    /** Permission ID to revoke */
    permissionId: bigint;
}
/**
 * Contract Permission Info structure returned from the contract
 *
 * @category Permissions
 */
interface PermissionInfo {
    /** Permission ID */
    id: bigint;
    /** Address that granted the permission */
    grantor: Address;
    /** Nonce used when creating */
    nonce: bigint;
    /** Grant URL */
    grant: string;
    /** Signature bytes */
    signature: `0x${string}`;
    /** Whether the permission is active */
    isActive: boolean;
    /** File IDs associated with this permission */
    fileIds: bigint[];
}
/**
 * EIP-712 Permission message structure (simplified future format)
 *
 * @category Permissions
 */
interface SimplifiedPermissionMessage {
    /** Application address */
    application: Address;
    /** Grant URL */
    grant: string;
    /** Nonce */
    nonce: bigint;
}
/**
 * Grant file structure containing permission details.
 *
 * Grant files contain the complete specification of what an application is permitted
 * to do with user data, including operation parameters and file access rights.
 *
 * @category Permissions
 * @example
 * ```typescript
 * const grantFile: GrantFile = {
 *   grantee: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
 *   operation: 'llm_inference',
 *   parameters: {
 *     prompt: 'Analyze this data: {{data}}',
 *     model: 'gpt-4',
 *     maxTokens: 2000,
 *     temperature: 0.7
 *   },
 *   expires: 1736467579
 * };
 * ```
 */
interface GrantFile {
    /** EVM address of the application authorized to use this grant */
    grantee: Address;
    /** Operation the grantee is authorized to perform */
    operation: string;
    /** Operation-specific parameters */
    parameters: Record<string, unknown>;
    /** Optional Unix timestamp when grant expires (seconds since epoch per POSIX.1-2008) */
    expires?: number;
}
/**
 * EIP-712 typed data structure for Permission
 *
 * @category Permissions
 */
interface PermissionGrantTypedData {
    /** EIP-712 domain */
    domain: PermissionGrantDomain;
    /** EIP-712 types */
    types: {
        Permission: Array<{
            name: string;
            type: string;
        }>;
    };
    /** Primary type */
    primaryType: "Permission";
    /** Message to sign */
    message: PermissionInputMessage;
}
/**
 * Generic EIP-712 typed data structure
 *
 * @category Permissions
 */
interface GenericTypedData {
    /** EIP-712 domain */
    domain: PermissionGrantDomain;
    /** EIP-712 types */
    types: Record<string, Array<{
        name: string;
        type: string;
    }>>;
    /** Primary type */
    primaryType: string;
    /** Message to sign */
    message: Record<string, unknown>;
}
/**
 * Permission operation types
 *
 * @category Permissions
 */
type PermissionOperation = "llm_inference" | "data_analysis" | "model_training" | "data_sharing" | "compute_task" | string;
/**
 * Permission status
 *
 * @category Permissions
 */
type PermissionStatus = "active" | "revoked" | "expired" | "pending";
/**
 * Parameters for querying permissions
 *
 * @category Permissions
 */
interface QueryPermissionsParams {
    /** Filter by grantor address */
    grantor?: Address;
    /** Filter by grantee address */
    grantee?: Address;
    /** Filter by operation type */
    operation?: PermissionOperation;
    /** Filter by file IDs */
    files?: number[];
    /** Filter by status */
    status?: PermissionStatus;
    /** Starting block number */
    fromBlock?: bigint;
    /** Ending block number */
    toBlock?: bigint;
    /** Maximum number of results */
    limit?: number;
    /** Offset for pagination */
    offset?: number;
}
/**
 * Permission query result
 *
 * @category Permissions
 */
interface PermissionQueryResult {
    /** Array of permissions matching the query */
    permissions: GrantedPermission[];
    /** Total number of permissions (for pagination) */
    total: number;
    /** Whether there are more results available */
    hasMore: boolean;
}
/**
 * Permission analytics data
 *
 * @category Permissions
 */
interface PermissionAnalytics {
    /** Total number of permissions granted */
    totalPermissions: number;
    /** Number of active permissions */
    activePermissions: number;
    /** Number of revoked permissions */
    revokedPermissions: number;
    /** Number of expired permissions */
    expiredPermissions: number;
    /** Most common operation types */
    topOperations: Array<{
        operation: PermissionOperation;
        count: number;
    }>;
    /** Most active applications */
    topApplications: Array<{
        application: Address;
        count: number;
    }>;
}
/**
 * Server information
 *
 * @category Permissions
 */
interface Server {
    /** Server URL */
    url: string;
}
/**
 * Parameters for trusting a server
 *
 * @category Permissions
 */
interface TrustServerParams {
    /** Server ID (address) */
    serverId: Address;
    /** Server URL */
    serverUrl: string;
}
/**
 * Parameters for untrusting a server
 *
 * @category Permissions
 */
interface UntrustServerParams {
    /** Server ID (address) */
    serverId: Address;
}
/**
 * Input for trusting a server with signature (gasless)
 *
 * @category Permissions
 */
interface TrustServerInput {
    /** User nonce */
    nonce: bigint;
    /** Server ID (address) */
    serverId: Address;
    /** Server URL */
    serverUrl: string;
}
/**
 * Input for untrusting a server with signature (gasless)
 *
 * @category Permissions
 */
interface UntrustServerInput {
    /** User nonce */
    nonce: bigint;
    /** Server ID (address) */
    serverId: Address;
}
/**
 * EIP-712 typed data for TrustServer
 *
 * @category Permissions
 */
interface TrustServerTypedData {
    /** EIP-712 domain */
    domain: PermissionGrantDomain;
    /** EIP-712 types */
    types: {
        TrustServer: Array<{
            name: string;
            type: string;
        }>;
    };
    /** Primary type */
    primaryType: "TrustServer";
    /** Message to sign */
    message: TrustServerInput;
}
/**
 * EIP-712 typed data for UntrustServer
 *
 * @category Permissions
 */
interface UntrustServerTypedData {
    /** EIP-712 domain */
    domain: PermissionGrantDomain;
    /** EIP-712 types */
    types: {
        UntrustServer: Array<{
            name: string;
            type: string;
        }>;
    };
    /** Primary type */
    primaryType: "UntrustServer";
    /** Message to sign */
    message: UntrustServerInput;
}
/**
 * Permission event data
 *
 * @category Permissions
 */
interface PermissionEvent {
    /** Event type */
    type: "granted" | "revoked" | "expired";
    /** Permission details */
    permission: GrantedPermission;
    /** Block number where event occurred */
    blockNumber: bigint;
    /** Transaction hash */
    transactionHash: Hash;
    /** Event timestamp */
    timestamp: number;
}
/**
 * Enhanced trusted server information with trust status
 *
 * @category Permissions
 */
interface TrustedServerInfo {
    /** Server ID (address) */
    serverId: Address;
    /** Server URL */
    url: string;
    /** Whether this server is trusted by the user */
    isTrusted: boolean;
    /** Index in user's trusted server list (if trusted) */
    trustIndex?: number;
}
/**
 * Paginated result for trusted server queries
 *
 * @category Permissions
 */
interface PaginatedTrustedServers {
    /** Array of server addresses */
    servers: Address[];
    /** Total number of trusted servers */
    total: number;
    /** Offset used for this query */
    offset: number;
    /** Limit used for this query */
    limit: number;
    /** Whether there are more servers beyond this page */
    hasMore: boolean;
}
/**
 * Options for querying trusted servers
 *
 * @category Permissions
 */
interface TrustedServerQueryOptions {
    /** User address to query (defaults to current user) */
    userAddress?: Address;
    /** Maximum number of servers to return */
    limit?: number;
    /** Offset for pagination */
    offset?: number;
    /** Whether to include full server info or just IDs */
    includeServerInfo?: boolean;
}
/**
 * Result of batch server info requests
 *
 * @category Permissions
 */
interface BatchServerInfoResult {
    /** Successfully retrieved server info */
    servers: Map<Address, {
        url: string;
    }>;
    /** Server IDs that failed to retrieve */
    failed: Address[];
}
/**
 * Server trust status information
 *
 * @category Permissions
 */
interface ServerTrustStatus {
    /** Server ID being checked */
    serverId: Address;
    /** Whether the server is trusted by the user */
    isTrusted: boolean;
    /** Index in user's trusted server list (if trusted) */
    trustIndex?: number;
}

/**
 * Configuration for storage providers used by the SDK.
 *
 * Allows you to configure multiple storage backends (IPFS, Pinata, Google Drive, etc.)
 * and specify which one to use by default for file operations.
 *
 * @category Configuration
 * @example
 * ```typescript
 * const storage: StorageConfig = {
 *   providers: {
 *     ipfs: new IPFSStorage({ gateway: 'https://gateway.pinata.cloud' }),
 *     pinata: new PinataStorage({ apiKey: 'your-key', secretKey: 'your-secret' })
 *   },
 *   defaultProvider: 'ipfs'
 * };
 * ```
 */
interface StorageConfig {
    /** Map of provider name to storage provider instance */
    providers: Record<string, StorageProvider>;
    /** Default provider name to use when none specified */
    defaultProvider?: string;
}
/**
 * Relayer callback functions for handling gasless transactions.
 *
 * Instead of hardcoding HTTP/REST API calls, users can provide custom callback
 * functions to handle transaction relay in any way they choose (HTTP, WebSocket,
 * direct blockchain submission, etc.).
 *
 * @category Configuration
 * @example
 * ```typescript
 * const relayerCallbacks: RelayerCallbacks = {
 *   async submitPermissionGrant(typedData, signature) {
 *     // Custom implementation - could be HTTP, WebSocket, etc.
 *     const response = await fetch('https://my-relayer.com/api/grant', {
 *       method: 'POST',
 *       headers: { 'Content-Type': 'application/json' },
 *       body: JSON.stringify({ typedData, signature })
 *     });
 *     const result = await response.json();
 *     return result.transactionHash;
 *   },
 *
 *   async submitFileAddition(url, userAddress) {
 *     // Custom relay implementation
 *     return await myCustomRelayer.addFile(url, userAddress);
 *   }
 * };
 * ```
 */
interface RelayerCallbacks {
    /**
     * Submit a signed permission grant transaction for relay
     *
     * @param typedData - The EIP-712 typed data that was signed
     * @param signature - The user's signature
     * @returns Promise resolving to the transaction hash
     */
    submitPermissionGrant?: (typedData: PermissionGrantTypedData, signature: Hash) => Promise<Hash>;
    /**
     * Submit a signed permission revocation transaction for relay
     *
     * @param typedData - The EIP-712 typed data that was signed
     * @param signature - The user's signature
     * @returns Promise resolving to the transaction hash
     */
    submitPermissionRevoke?: (typedData: GenericTypedData, signature: Hash) => Promise<Hash>;
    /**
     * Submit a signed trust server transaction for relay
     *
     * @param typedData - The EIP-712 typed data that was signed
     * @param signature - The user's signature
     * @returns Promise resolving to the transaction hash
     */
    submitTrustServer?: (typedData: TrustServerTypedData, signature: Hash) => Promise<Hash>;
    /**
     * Submit a signed untrust server transaction for relay
     *
     * @param typedData - The EIP-712 typed data that was signed
     * @param signature - The user's signature
     * @returns Promise resolving to the transaction hash
     */
    submitUntrustServer?: (typedData: UntrustServerTypedData, signature: Hash) => Promise<Hash>;
    /**
     * Submit a file addition for relay
     *
     * @param url - The file URL to register
     * @param userAddress - The user's address
     * @returns Promise resolving to object with fileId and transactionHash
     */
    submitFileAddition?: (url: string, userAddress: string) => Promise<{
        fileId: number;
        transactionHash: Hash;
    }>;
    /**
     * Submit a file addition with permissions for relay
     *
     * @param url - The file URL to register
     * @param userAddress - The user's address
     * @param permissions - Array of encrypted permissions
     * @returns Promise resolving to object with fileId and transactionHash
     */
    submitFileAdditionWithPermissions?: (url: string, userAddress: string, permissions: Array<{
        account: string;
        key: string;
    }>) => Promise<{
        fileId: number;
        transactionHash: Hash;
    }>;
    /**
     * Store a grant file for relay (e.g., upload to IPFS)
     *
     * @param grantData - The grant file data
     * @returns Promise resolving to the storage URL
     */
    storeGrantFile?: (grantData: GrantFile) => Promise<string>;
}
/**
 * Base configuration interface
 *
 * @category Configuration
 */
interface BaseConfig {
    /**
     * Optional relayer callback functions for handling gasless transactions.
     * Provides flexible relay mechanism - can use HTTP, WebSocket, or any custom implementation.
     */
    relayerCallbacks?: RelayerCallbacks;
    /** Optional storage providers configuration for file upload/download */
    storage?: StorageConfig;
    /**
     * Optional subgraph URL for querying user files and permissions.
     * If not provided, defaults to the built-in subgraph URL for the current chain.
     * Can be overridden per method call if needed.
     */
    subgraphUrl?: string;
}
/**
 * Configuration with wallet client
 *
 * @category Configuration
 */
interface WalletConfig extends BaseConfig {
    /** The viem WalletClient instance used for signing transactions */
    walletClient: WalletClient & {
        chain: VanaChain;
    };
}
/**
 * Configuration with chain and account details
 *
 * @category Configuration
 */
interface ChainConfig extends BaseConfig {
    /** The chain ID for Vana network */
    chainId: VanaChainId;
    /** RPC URL for the chain (optional, will use default for the chain if not provided) */
    rpcUrl?: string;
    /** Optional account for signing transactions */
    account?: Account;
}
/**
 * Main configuration interface for initializing the Vana SDK.
 *
 * You can configure the SDK using either a pre-configured wallet client
 * (WalletConfig) or by providing chain and account details (ChainConfig).
 * Both approaches support optional storage providers and relayer configuration.
 *
 * @category Configuration
 * @example
 * ```typescript
 * // Using WalletConfig with pre-configured client
 * const config: VanaConfig = {
 *   walletClient: createWalletClient({
 *     account: privateKeyToAccount('0x...'),
 *     chain: moksha,
 *     transport: http()
 *   }),
 *   relayerCallbacks: {
 *     submitPermissionGrant: async (typedData, signature) => {
 *       // Custom relay implementation
 *       return await myRelayer.submit(typedData, signature);
 *     }
 *   }
 * };
 *
 * // Using ChainConfig with chain ID and account
 * const config: VanaConfig = {
 *   chainId: 14800,
 *   account: privateKeyToAccount('0x...'),
 *   relayerCallbacks: {
 *     submitPermissionGrant: async (typedData, signature) => {
 *       // Custom relay implementation
 *       return await myRelayer.submit(typedData, signature);
 *     }
 *   }
 * };
 * ```
 */
type VanaConfig = WalletConfig | ChainConfig;
/**
 * Runtime configuration information
 *
 * @category Configuration
 */
interface RuntimeConfig {
    /** Current chain ID */
    chainId: VanaChainId;
    /** Current chain name */
    chainName: string;
    /** Available storage providers */
    storageProviders: string[];
    /** Default storage provider */
    defaultStorageProvider?: string;
    /** Current relayer callbacks configuration */
    relayerCallbacks?: RelayerCallbacks;
}
/**
 * Validates whether a configuration object is a WalletConfig.
 *
 * @param config - The configuration object to check
 * @returns True if the config is a WalletConfig (contains walletClient)
 * @example
 * ```typescript
 * if (isWalletConfig(config)) {
 *   console.log('Using wallet client:', config.walletClient.account?.address);
 * } else {
 *   console.log('Using chain config with chain ID:', config.chainId);
 * }
 * ```
 */
declare function isWalletConfig(config: VanaConfig): config is WalletConfig;
/**
 * Validates whether a configuration object is a ChainConfig.
 *
 * @param config - The configuration object to check
 * @returns True if the config is a ChainConfig (contains chainId but not walletClient)
 * @example
 * ```typescript
 * if (isChainConfig(config)) {
 *   console.log('Chain ID:', config.chainId);
 *   console.log('RPC URL:', config.rpcUrl);
 * } else {
 *   console.log('Using pre-configured wallet client');
 * }
 * ```
 */
declare function isChainConfig(config: VanaConfig): config is ChainConfig;
/**
 * Configuration validation options
 *
 * @category Configuration
 */
interface ConfigValidationOptions {
    /** Whether to validate storage providers */
    validateStorage?: boolean;
    /** Whether to validate relayer URL */
    validateRelayer?: boolean;
    /** Whether to validate chain configuration */
    validateChain?: boolean;
}
/**
 * Configuration validation result
 *
 * @category Configuration
 */
interface ConfigValidationResult {
    /** Whether the configuration is valid */
    valid: boolean;
    /** List of validation errors */
    errors: string[];
    /** List of validation warnings */
    warnings: string[];
}

/**
 * Union type of all canonical Vana contract names
 */
type VanaContractName = "DataPermissions" | "DataRegistry" | "TeePool" | "ComputeEngine" | "TeePoolPhala" | "DataRefinerRegistry" | "QueryEngine" | "ComputeInstructionRegistry" | "TeePoolEphemeralStandard" | "TeePoolPersistentStandard" | "TeePoolPersistentGpu" | "TeePoolDedicatedStandard" | "TeePoolDedicatedGpu" | "VanaEpoch" | "DLPRegistry" | "DLPRegistryTreasury" | "DLPPerformance" | "DLPRewardDeployer" | "DLPRewardDeployerTreasury" | "DLPRewardSwap" | "SwapHelper" | "VanaPoolStaking" | "VanaPoolEntity" | "VanaPoolTreasury" | "DAT" | "DATFactory" | "DATPausable" | "DATVotes" | "DataLiquidityPool" | "DLPRoot";
/**
 * Contract information with typed address and ABI
 */
interface ContractInfo<TAbi extends Abi = Abi> {
    /** The contract's deployed address */
    address: Address;
    /** The contract's ABI */
    abi: TAbi;
}
/**
 * Contract deployment information
 */
interface ContractDeployment {
    /** The contract's deployed address */
    address: Address;
    /** Block number where contract was deployed */
    blockNumber: bigint;
    /** Transaction hash of deployment */
    transactionHash: Hash;
}
/**
 * Typed contract instance
 */
type VanaContractInstance<TAbi extends Abi = Abi> = GetContractReturnType<TAbi>;
/**
 * Contract addresses mapping by chain and contract name
 */
type ContractAddresses = {
    [chainId: number]: {
        [contractName in VanaContractName]?: Address;
    };
};
/**
 * Contract method parameters for typed interactions
 */
type ContractMethodParams<TAbi extends Abi, TFunctionName extends string> = TAbi extends readonly unknown[] ? TAbi[number] extends {
    name: TFunctionName;
    type: "function";
    inputs: infer TInputs;
} ? TInputs extends readonly unknown[] ? {
    [K in keyof TInputs]: TInputs[K] extends {
        name: infer TName;
        type: infer TType;
    } ? TName extends string ? TType extends "address" ? Address : TType extends "uint256" ? bigint : TType extends "string" ? string : TType extends "bool" ? boolean : TType extends "bytes32" ? Hash : unknown : never : never;
} : never : never : never;
/**
 * Contract method return type for typed interactions
 */
type ContractMethodReturnType<TAbi extends Abi, TFunctionName extends string> = TAbi extends readonly unknown[] ? TAbi[number] extends {
    name: TFunctionName;
    type: "function";
    outputs: infer TOutputs;
} ? TOutputs extends readonly unknown[] ? TOutputs["length"] extends 1 ? TOutputs[0] extends {
    type: infer TType;
} ? TType extends "address" ? Address : TType extends "uint256" ? bigint : TType extends "string" ? string : TType extends "bool" ? boolean : TType extends "bytes32" ? Hash : unknown : unknown : {
    [K in keyof TOutputs]: TOutputs[K] extends {
        name: infer TName;
        type: infer TType;
    } ? TName extends string ? TType extends "address" ? Address : TType extends "uint256" ? bigint : TType extends "string" ? string : TType extends "bool" ? boolean : TType extends "bytes32" ? Hash : unknown : never : never;
} : never : never : never;

/**
 * Represents a registered data file in the Vana network with complete blockchain metadata.
 *
 * @remarks
 * This interface describes files that have been uploaded to storage and registered
 * on the Vana blockchain, including their storage location, ownership, and blockchain
 * tracking information. Each file receives a unique ID and is linked to the owner's
 * address for permission management. Used throughout the SDK for file operations
 * and access control workflows.
 *
 * @category Data Management
 */
interface UserFile$1 {
    /** Unique identifier assigned by the Data Registry contract. */
    id: number;
    /** Storage URL where the encrypted file content is hosted. */
    url: string;
    /** Wallet address of the user who owns this file. */
    ownerAddress: Address;
    /** Block number when this file was registered on-chain. */
    addedAtBlock: bigint;
    /** Schema identifier for data validation and structure definition. */
    schemaId?: number;
    /** Unix timestamp when the file was registered on-chain. */
    addedAtTimestamp?: bigint;
    /** Transaction hash of the on-chain file registration. */
    transactionHash?: Address;
    /** Additional file properties and custom application data. */
    metadata?: FileMetadata;
}
/**
 * Provides optional metadata for uploaded files and content description.
 *
 * @remarks
 * This interface contains descriptive information about uploaded files, including
 * file properties and custom application-specific data that can be used for
 * organization, validation, and display purposes.
 * @category Data Management
 */
interface FileMetadata {
    /** Original filename as provided by the user or application. */
    name?: string;
    /** Total file size in bytes for storage tracking. */
    size?: number;
    /** MIME type identifier for content type recognition. */
    mimeType?: string;
    /** Hash value for file integrity verification. */
    checksum?: string;
    /** ISO 8601 timestamp when the file was uploaded. */
    uploadedAt?: string;
    /** Application-specific metadata for custom use cases. */
    custom?: Record<string, unknown>;
}
/**
 * Defines parameters for uploading files to storage providers with encryption options.
 *
 * @remarks
 * Used with DataController upload methods and storage operations. Supports multiple
 * content formats, optional encryption, and custom storage provider selection with
 * comprehensive metadata tracking.
 * @example
 * ```typescript
 * const uploadParams: UploadFileParams = {
 *   content: new TextEncoder().encode(JSON.stringify(userData)),
 *   metadata: {
 *     name: "personal-profile.json",
 *     mimeType: "application/json",
 *     size: 2048,
 *   },
 *   storageProvider: "ipfs",
 *   encrypt: true,
 * };
 *
 * const result = await vana.data.uploadFile(uploadParams);
 * ```
 * @category Data Management
 */
interface UploadFileParams {
    /** Raw file data in bytes, buffer, or string format. */
    content: Uint8Array | Buffer | string;
    /** Descriptive metadata for file organization and tracking. */
    metadata?: FileMetadata;
    /** Storage provider name or uses configured default if unspecified. */
    storageProvider?: string;
    /** Enables automatic encryption before upload to storage. */
    encrypt?: boolean;
    /** Custom encryption key or generates one automatically if encryption enabled. */
    encryptionKey?: string;
}
/**
 * Contains the result of a successful file upload operation.
 *
 * @remarks
 * This interface provides the essential information returned after uploading
 * a file to a storage provider, including access URL, size verification,
 * and encryption details when applicable.
 * @category Data Management
 */
interface UploadFileResult {
    /** Public URL where the uploaded file can be accessed. */
    url: string;
    /** Actual file size in bytes after upload processing. */
    size: number;
    /** Hash value for verifying file integrity after upload. */
    checksum?: string;
    /** Encryption metadata when file was encrypted before storage. */
    encryption?: EncryptionInfo;
}
/**
 * Result of uploading an encrypted file to storage and blockchain
 *
 * @category Data Management
 */
interface UploadEncryptedFileResult extends UploadFileResult {
    /** The new file ID assigned by the DataRegistry */
    fileId: number;
    /** Transaction hash of the file registration */
    transactionHash?: Hash;
}
/**
 * Encryption information for a file
 *
 * @category Data Management
 */
interface EncryptionInfo {
    /** Encryption algorithm used */
    algorithm: string;
    /** Key derivation function */
    kdf?: string;
    /** Initialization vector */
    iv?: string;
    /** Salt used for key derivation */
    salt?: string;
    /** Key identifier */
    keyId?: string;
}
/**
 * Parameters for getting user files
 *
 * @category Data Management
 */
interface GetUserFilesParams {
    /** Owner address to filter by */
    owner?: Address;
    /** Starting block number for filtering */
    fromBlock?: bigint;
    /** Ending block number for filtering */
    toBlock?: bigint;
    /** Maximum number of files to return */
    limit?: number;
    /** Offset for pagination */
    offset?: number;
}
/**
 * Parameters for getting a specific file
 *
 * @category Data Management
 */
interface GetFileParams {
    /** File ID to retrieve */
    fileId: number;
    /** Whether to include metadata */
    includeMetadata?: boolean;
}
/**
 * Parameters for downloading a file
 *
 * @category Data Management
 */
interface DownloadFileParams {
    /** File URL or ID to download */
    file: string | number;
    /** Storage provider to use */
    storageProvider?: string;
    /** Decryption key if file is encrypted */
    decryptionKey?: string;
}
/**
 * Result of downloading a file
 *
 * @category Data Management
 */
interface DownloadFileResult {
    /** File content */
    content: Uint8Array;
    /** File metadata */
    metadata?: FileMetadata;
    /** Whether the file was encrypted */
    wasEncrypted?: boolean;
}
/**
 * Parameters for deleting a file
 *
 * @category Data Management
 */
interface DeleteFileParams {
    /** File ID to delete */
    fileId: number;
    /** Whether to also delete from storage */
    deleteFromStorage?: boolean;
    /** Storage provider to delete from */
    storageProvider?: string;
}
/**
 * Result of deleting a file
 *
 * @category Data Management
 */
interface DeleteFileResult {
    /** Whether the file was successfully deleted from the registry */
    registryDeleted: boolean;
    /** Whether the file was successfully deleted from storage */
    storageDeleted?: boolean;
    /** Transaction hash of the deletion */
    transactionHash?: Hash;
}
/**
 * File access permissions
 *
 * @category Data Management
 */
interface FileAccessPermissions {
    /** Whether the file can be read */
    read: boolean;
    /** Whether the file can be written */
    write: boolean;
    /** Whether the file can be deleted */
    delete: boolean;
    /** Whether the file can be shared */
    share: boolean;
}
/**
 * File sharing configuration
 *
 * @category Data Management
 */
interface FileSharingConfig {
    /** Addresses that can access the file */
    allowedAddresses?: Address[];
    /** Expiration time for shared access */
    expiresAt?: Date;
    /** Required permissions for shared access */
    permissions: FileAccessPermissions;
}
/**
 * Batch upload parameters
 *
 * @category Data Management
 */
interface BatchUploadParams {
    /** Array of files to upload */
    files: UploadFileParams[];
    /** Storage provider to use for all files */
    storageProvider?: string;
    /** Whether to encrypt all files */
    encrypt?: boolean;
    /** Encryption key for all files */
    encryptionKey?: string;
}
/**
 * Batch upload result
 *
 * @category Data Management
 */
interface BatchUploadResult {
    /** Results for each uploaded file */
    results: UploadEncryptedFileResult[];
    /** Overall success status */
    success: boolean;
    /** Any errors that occurred */
    errors?: string[];
}
/**
 * Represents a data schema in the refiner registry.
 *
 * Schemas define the structure and validation rules for user data processed by refiners.
 * They ensure data quality and consistency across the Vana network by specifying how
 * raw user data should be formatted, validated, and processed.
 *
 * @category Data Management
 * @example
 * ```typescript
 * const socialMediaSchema: Schema = {
 *   id: 5,
 *   name: 'Social Media Profile',
 *   type: 'JSON',
 *   url: 'ipfs://QmSchema...', // Schema definition file
 *   description: 'Schema for validating social media profile data'
 * };
 * ```
 */
interface Schema {
    /** Schema ID */
    id: number;
    /** Schema name */
    name: string;
    /** Schema type */
    type: string;
    /** URL containing the schema definition */
    definitionUrl: string;
}
/**
 * Represents a refiner with schema information
 *
 * @category Data Management
 */
interface Refiner {
    /** Refiner ID */
    id: number;
    /** DLP ID this refiner belongs to */
    dlpId: number;
    /** Owner address */
    owner: Address;
    /** Refiner name */
    name: string;
    /** Schema ID associated with this refiner */
    schemaId: number;
    /** URL containing refinement instructions */
    refinementInstructionUrl: string;
}
/**
 * Parameters for adding a new schema
 *
 * @category Data Management
 */
interface AddSchemaParams {
    /** Schema name */
    name: string;
    /** Schema type */
    type: string;
    /** URL containing the schema definition */
    definitionUrl: string;
}
/**
 * Result of adding a schema
 *
 * @category Data Management
 */
interface AddSchemaResult {
    /** The new schema ID assigned by the contract */
    schemaId: number;
    /** Transaction hash of the schema registration */
    transactionHash: Hash;
}
/**
 * Parameters for registering a new data refiner in the Vana network.
 *
 * Refiners are processors that transform and validate user data according to specific
 * schemas and instructions. They enable applications to work with structured, verified
 * user data while maintaining privacy and user control.
 *
 * @category Data Management
 * @example
 * ```typescript
 * const refinerParams: AddRefinerParams = {
 *   dlpId: 1, // Data Liquidity Pool ID
 *   name: 'Social Media Refiner',
 *   schemaId: 5, // Pre-defined schema for social media data
 *   refinementInstructionUrl: 'ipfs://Qm...' // Instructions for data processing
 * };
 * ```
 */
interface AddRefinerParams {
    /** DLP ID this refiner belongs to */
    dlpId: number;
    /** Refiner name */
    name: string;
    /** Schema ID to associate with this refiner */
    schemaId: number;
    /** URL containing refinement instructions */
    refinementInstructionUrl: string;
}
/**
 * Result of adding a refiner
 *
 * @category Data Management
 */
interface AddRefinerResult {
    /** The new refiner ID assigned by the contract */
    refinerId: number;
    /** Transaction hash of the refiner registration */
    transactionHash: Hash;
}
/**
 * Parameters for updating a refiner's schema ID
 *
 * @category Data Management
 */
interface UpdateSchemaIdParams {
    /** Refiner ID to update */
    refinerId: number;
    /** New schema ID to associate with the refiner */
    newSchemaId: number;
}
/**
 * Result of updating a refiner's schema ID
 *
 * @category Data Management
 */
interface UpdateSchemaIdResult {
    /** Transaction hash of the update */
    transactionHash: Hash;
}
/**
 * Query mode for trusted server retrieval
 *
 * @category Data Management
 */
type TrustedServerQueryMode = "subgraph" | "rpc" | "auto";
/**
 * Trusted server data structure (unified format for both subgraph and RPC modes)
 *
 * @category Data Management
 */
interface TrustedServer {
    /** Unique identifier for the trusted server relationship */
    id: string;
    /** Server address (EVM address) */
    serverAddress: Address;
    /** Server URL */
    serverUrl: string;
    /** Timestamp when server was trusted */
    trustedAt: bigint;
    /** User who trusted the server */
    user: Address;
    /** Index in user's trusted server list (only available in RPC mode) */
    trustIndex?: number;
}
/**
 * Parameters for getUserTrustedServers with dual-mode support
 *
 * @category Data Management
 */
interface GetUserTrustedServersParams {
    /** User address to query */
    user: Address;
    /** Query mode: 'subgraph' (fast, requires subgraph), 'rpc' (direct contract), or 'auto' (tries subgraph first) */
    mode?: TrustedServerQueryMode;
    /** Subgraph URL (required for subgraph mode) */
    subgraphUrl?: string;
    /** Pagination limit (applies to RPC mode) */
    limit?: number;
    /** Pagination offset (applies to RPC mode) */
    offset?: number;
}
/**
 * Result of getUserTrustedServers query
 *
 * @category Data Management
 */
interface GetUserTrustedServersResult {
    /** Array of trusted servers */
    servers: TrustedServer[];
    /** Query mode that was actually used */
    usedMode: TrustedServerQueryMode;
    /** Total count (only available in RPC mode) */
    total?: number;
    /** Whether there are more servers (pagination info for RPC mode) */
    hasMore?: boolean;
    /** Any warnings or fallback information */
    warnings?: string[];
}

/**
 * Data schema interface following the Vana schema specification
 *
 * @category Configuration
 */
interface DataSchema {
    /** The name of the data schema */
    name: string;
    /** The version of the data schema */
    version: string;
    /** Optional description of the data schema */
    description?: string;
    /** The dialect type - either SQLite or JSON */
    dialect: "sqlite" | "json";
    /** Optional version of the dialect */
    dialectVersion?: string;
    /** The actual schema definition as string or object */
    schema: string | object;
}
/**
 * Error thrown when schema validation fails
 */
declare class SchemaValidationError extends Error {
    errors: Array<{
        instancePath: string;
        schemaPath: string;
        keyword: string;
        params: Record<string, unknown>;
        message?: string;
    }>;
    constructor(message: string, errors: Array<{
        instancePath: string;
        schemaPath: string;
        keyword: string;
        params: Record<string, unknown>;
        message?: string;
    }>);
}
/**
 * Schema validation utility class
 */
declare class SchemaValidator {
    private ajv;
    private dataSchemaValidator;
    constructor();
    /**
     * Validates a data schema against the Vana meta-schema
     *
     * @param schema - The data schema to validate
     * @throws SchemaValidationError if invalid
     * @example
     * ```typescript
     * const validator = new SchemaValidator();
     *
     * const schema = {
     *   name: "User Profile",
     *   version: "1.0.0",
     *   dialect: "json",
     *   schema: {
     *     type: "object",
     *     properties: {
     *       name: { type: "string" },
     *       age: { type: "number" }
     *     }
     *   }
     * };
     *
     * validator.validateDataSchema(schema); // throws if invalid
     * ```
     */
    validateDataSchema(schema: unknown): asserts schema is DataSchema;
    /**
     * Validates data against a JSON Schema from a data schema
     *
     * @param data - The data to validate
     * @param schema - The data schema containing the schema
     * @throws SchemaValidationError if invalid
     * @example
     * ```typescript
     * const validator = new SchemaValidator();
     *
     * const schema = {
     *   name: "User Profile",
     *   version: "1.0.0",
     *   dialect: "json",
     *   schema: {
     *     type: "object",
     *     properties: {
     *       name: { type: "string" },
     *       age: { type: "number" }
     *     },
     *     required: ["name"]
     *   }
     * };
     *
     * const userData = { name: "Alice", age: 30 };
     * validator.validateDataAgainstSchema(userData, schema);
     * ```
     */
    validateDataAgainstSchema(data: unknown, schema: DataSchema): void;
    /**
     * Validates a SQLite DDL string for basic syntax
     * Note: This is a basic validation, full SQL parsing would require a proper SQL parser
     *
     * @param ddl - The DDL string to validate
     * @param dialectVersion - Optional SQLite version (e.g., "3" for SQLite v3)
     * @throws SchemaValidationError if invalid
     */
    validateSQLiteDDL(ddl: string, dialectVersion?: string): void;
    /**
     * Fetches and validates a schema from a URL
     *
     * @param url - The URL to fetch the schema from
     * @returns The validated data schema
     * @throws SchemaValidationError if invalid or fetch fails
     * @example
     * ```typescript
     * const validator = new SchemaValidator();
     * const schema = await validator.fetchAndValidateSchema("https://example.com/schema.json");
     * ```
     */
    fetchAndValidateSchema(url: string): Promise<DataSchema>;
}
/**
 * Global schema validator instance
 */
declare const schemaValidator: SchemaValidator;
/**
 * Convenience function to validate a data schema
 *
 * @param schema - The data schema to validate
 * @returns void - Assertion function that doesn't return a value
 * @throws SchemaValidationError if invalid
 */
declare function validateDataSchema(schema: unknown): asserts schema is DataSchema;
/**
 * Convenience function to validate data against a schema
 *
 * @param data - The data to validate
 * @param schema - The data schema containing the schema
 * @returns void - Function doesn't return a value
 * @throws SchemaValidationError if invalid
 */
declare function validateDataAgainstSchema(data: unknown, schema: DataSchema): void;
/**
 * Convenience function to fetch and validate a schema from a URL
 *
 * @param url - The URL to fetch the schema from
 * @returns The validated data schema
 * @throws SchemaValidationError if invalid or fetch fails
 */
declare function fetchAndValidateSchema(url: string): Promise<DataSchema>;

/**
 * Parameters for the `vana.personal.postRequest` method.
 */
interface PostRequestParams {
    /** The permission ID */
    permissionId: number;
}
/**
 * Parameters for the `vana.personal.initPersonalServer` method.
 */
interface InitPersonalServerParams {
    /** The user's wallet address */
    userAddress: string;
}
/**
 * Response from the personal server containing a link to get results or cancel computation.
 */
interface ReplicatePredictionResponse {
    /** The prediction ID for tracking the computation */
    id: string;
    /** The status of the computation */
    status: "starting" | "processing" | "succeeded" | "failed" | "canceled";
    /** URL to check the status and get results */
    urls: {
        get: string;
        cancel: string;
    };
    /** The input parameters used for the computation */
    input: Record<string, unknown>;
    /** Optional output if computation is complete */
    output?: unknown;
    /** Optional error if computation failed */
    error?: string;
}
/**
 * Response from the personal server containing user identity information.
 */
interface PersonalServerResponse$1 {
    /** The user's wallet address */
    userAddress: string;
    /** The user's identity information */
    identity: {
        /** Additional identity metadata */
        metadata?: {
            /** Derived address for the personal server */
            derivedAddress?: string;
            /** Public key for encryption */
            publicKey?: string;
        } & Record<string, unknown>;
    };
    /** Timestamp when the identity was fetched */
    timestamp: string;
}

/**
 * Types for external API responses used by the Vana SDK
 * These types help ensure type safety when interacting with third-party services
 */
/**
 * Replicate API Response Types
 * Documentation: https://replicate.com/docs/reference/http
 */
/** Status values for Replicate predictions */
type ReplicateStatus = "starting" | "processing" | "succeeded" | "failed" | "canceled";
/** Base Replicate API prediction response */
interface ReplicateAPIResponse {
    /** Unique identifier for the prediction */
    id: string;
    /** Model version identifier */
    version: string;
    /** Current status of the prediction */
    status: ReplicateStatus;
    /** Input parameters sent to the model */
    input: Record<string, unknown>;
    /** Output from the model (if completed successfully) */
    output?: unknown;
    /** Error message (if failed) */
    error?: string | null;
    /** Logs from the prediction run */
    logs?: string;
    /** Whether data has been removed due to content policy */
    data_removed?: boolean;
    /** Timestamp when prediction was created */
    created_at: string;
    /** Timestamp when prediction started processing */
    started_at?: string;
    /** Timestamp when prediction completed */
    completed_at?: string;
    /** URLs for interacting with the prediction */
    urls: {
        /** URL to get prediction status/results */
        get: string;
        /** URL to cancel the prediction */
        cancel: string;
        /** Web interface URL */
        web?: string;
    };
    /** Performance metrics */
    metrics?: {
        /** Time spent in prediction (seconds) */
        predict_time?: number;
        /** Total time including setup (seconds) */
        total_time?: number;
    };
}
/**
 * Identity Server Output Types
 * These define the expected structure of output from Vana's identity server
 */
/** Output from the identity server model */
interface IdentityServerOutput {
    /** User's EVM address */
    user_address: string;
    /** Personal server information */
    personal_server: {
        /** Derived address for the personal server */
        address: string;
        /** Public key for encryption */
        public_key: string;
    };
}
/** Identity server response with typed output */
interface IdentityServerResponse extends Omit<ReplicateAPIResponse, "output"> {
    /** Parsed identity server output */
    output?: IdentityServerOutput | string;
}
/**
 * Personal Server Output Types
 * These define the expected structure of output from Vana's personal server
 */
/** Output from the personal server model */
interface PersonalServerOutput {
    /** User's EVM address */
    user_address: string;
    /** Identity information */
    identity: {
        /** Additional metadata */
        metadata?: Record<string, unknown>;
        /** Derived address (alternative location) */
        derivedAddress?: string;
    };
}
/** Personal server response with typed output */
interface PersonalServerResponse extends Omit<ReplicateAPIResponse, "output"> {
    /** Parsed personal server output */
    output?: PersonalServerOutput | string;
}
/**
 * Storage Provider API Types
 */
/** Pinata IPFS upload response */
interface PinataUploadResponse {
    /** IPFS hash of the uploaded content */
    IpfsHash: string;
    /** Size of the pinned content in bytes */
    PinSize: number;
    /** Timestamp of when content was pinned */
    Timestamp: string;
    /** Whether this content was already pinned */
    isDuplicate?: boolean;
}
/** Pinata pin information */
interface PinataPin {
    /** IPFS hash */
    ipfs_pin_hash: string;
    /** Pin size in bytes */
    size: number;
    /** User ID */
    user_id: string;
    /** Date pinned */
    date_pinned: string;
    /** Date unpinned (if applicable) */
    date_unpinned?: string;
    /** Additional metadata */
    metadata?: {
        name?: string;
        keyvalues?: Record<string, string>;
    };
}
/** Pinata list response */
interface PinataListResponse {
    /** Total count of pins */
    count: number;
    /** Array of pin information */
    rows: PinataPin[];
}
/**
 * Generic API Response Wrapper
 * Used for internal API routes in the demo application
 */
/** Standard API response wrapper */
interface APIResponse<T = unknown> {
    /** Whether the request was successful */
    success: boolean;
    /** Response data (if successful) */
    data?: T;
    /** Error message (if unsuccessful) */
    error?: string;
}
/**
 * Type Guards for Runtime Validation
 */
/**
 * Validates whether a value is a valid ReplicateAPIResponse.
 *
 * @param value - The value to check
 * @returns True if the value matches the ReplicateAPIResponse structure
 * @example
 * ```typescript
 * const response = await fetch('/api/replicate');
 * const data = await response.json();
 *
 * if (isReplicateAPIResponse(data)) {
 *   console.log('Status:', data.status);
 *   console.log('Output:', data.output);
 * }
 * ```
 */
declare function isReplicateAPIResponse(value: unknown): value is ReplicateAPIResponse;
/**
 * Validates whether a value is a valid IdentityServerOutput.
 *
 * @param value - The value to check
 * @returns True if the value matches the IdentityServerOutput structure
 * @example
 * ```typescript
 * const output = response.output;
 *
 * if (isIdentityServerOutput(output)) {
 *   console.log('User address:', output.user_address);
 *   console.log('Server address:', output.personal_server.address);
 * }
 * ```
 */
declare function isIdentityServerOutput(value: unknown): value is IdentityServerOutput;
/**
 * Validates whether a value is a valid PersonalServerOutput.
 *
 * @param value - The value to check
 * @returns True if the value matches the PersonalServerOutput structure
 * @example
 * ```typescript
 * const output = response.output;
 *
 * if (isPersonalServerOutput(output)) {
 *   console.log('User address:', output.user_address);
 *   console.log('Identity metadata:', output.identity.metadata);
 * }
 * ```
 */
declare function isPersonalServerOutput(value: unknown): value is PersonalServerOutput;
/**
 * Validates whether a value is a valid APIResponse.
 *
 * @param value - The value to check
 * @returns True if the value matches the APIResponse structure
 * @example
 * ```typescript
 * const response = await fetch('/api/data');
 * const data = await response.json();
 *
 * if (isAPIResponse(data)) {
 *   if (data.success) {
 *     console.log('Data:', data.data);
 *   } else {
 *     console.error('Error:', data.error);
 *   }
 * }
 * ```
 */
declare function isAPIResponse<T>(value: unknown): value is APIResponse<T>;
/**
 * Utility Functions for Safe JSON Parsing
 */
/**
 * Safely parses JSON string with type validation.
 *
 * @param jsonString - The JSON string to parse
 * @param typeGuard - Type guard function to validate the parsed value
 * @returns The parsed and validated value, or null if parsing/validation fails
 * @example
 * ```typescript
 * const jsonStr = '{"user_address": "0x123...", "identity": {}}';
 * const result = safeParseJSON(jsonStr, isPersonalServerOutput);
 *
 * if (result) {
 *   console.log('Parsed server output:', result.user_address);
 * } else {
 *   console.log('Invalid JSON or type mismatch');
 * }
 * ```
 */
declare function safeParseJSON<T>(jsonString: string, typeGuard: (value: unknown) => value is T): T | null;
/**
 * Parses Replicate API response output with type safety.
 *
 * @param response - The Replicate API response
 * @param typeGuard - Type guard function to validate the output
 * @returns The parsed and validated output, or null if validation fails
 * @example
 * ```typescript
 * const response = await replicateClient.get(predictionId);
 * const output = parseReplicateOutput(response, isIdentityServerOutput);
 *
 * if (output) {
 *   console.log('Identity server result:', output.user_address);
 * } else {
 *   console.log('Output not available or invalid format');
 * }
 * ```
 */
declare function parseReplicateOutput<T>(response: ReplicateAPIResponse, typeGuard: (value: unknown) => value is T): T | null;

/**
 * Response from the relayer service for grant file storage
 *
 * @category Advanced
 */
interface RelayerStorageResponse {
    /** The IPFS URL where the grant file is stored */
    grantUrl: string;
    /** Success status */
    success: boolean;
    /** Optional error message */
    error?: string;
    /** Storage metadata */
    metadata?: {
        /** IPFS hash */
        ipfsHash: string;
        /** File size in bytes */
        size: number;
        /** Upload timestamp */
        timestamp: number;
    };
}
/**
 * Response from the relayer service for transaction submission
 *
 * @category Advanced
 */
interface RelayerTransactionResponse {
    /** The transaction hash of the submitted transaction */
    transactionHash: Hash;
    /** Success status */
    success: boolean;
    /** Optional error message */
    error?: string;
    /** Transaction metadata */
    metadata?: {
        /** Gas used */
        gasUsed?: bigint;
        /** Gas price */
        gasPrice?: bigint;
        /** Block number */
        blockNumber?: bigint;
        /** Transaction status */
        status?: "pending" | "confirmed" | "failed";
    };
}
/**
 * Parameters for storing a grant file via relayer
 *
 * @category Advanced
 */
interface RelayerStoreParams {
    /** The grant file to store */
    grantFile: GrantFile;
    /** Optional storage options */
    options?: {
        /** IPFS pin duration in seconds */
        pinDuration?: number;
        /** Whether to use encryption */
        encrypt?: boolean;
        /** Custom metadata */
        metadata?: Record<string, unknown>;
    };
}
/**
 * Parameters for submitting a transaction via relayer
 *
 * @category Advanced
 */
interface RelayerSubmitParams {
    /** The signed typed data */
    typedData: PermissionGrantTypedData;
    /** The signature */
    signature: string;
    /** Optional transaction options */
    options?: {
        /** Gas limit */
        gasLimit?: bigint;
        /** Priority level */
        priority?: "low" | "medium" | "high";
        /** Whether to wait for confirmation */
        waitForConfirmation?: boolean;
    };
}
/**
 * Relayer service status
 *
 * @category Advanced
 */
interface RelayerStatus {
    /** Whether the relayer is online */
    online: boolean;
    /** Service version */
    version: string;
    /** Supported chains */
    supportedChains: number[];
    /** Current chain status */
    chainStatus: Record<number, {
        /** Whether the chain is supported */
        supported: boolean;
        /** Current block number */
        currentBlock: bigint;
        /** Gas price estimation */
        gasPrice: bigint;
        /** Queue size */
        queueSize: number;
    }>;
    /** Rate limit information */
    rateLimits: {
        /** Requests per minute */
        requestsPerMinute: number;
        /** Storage requests per hour */
        storageRequestsPerHour: number;
        /** Transaction requests per hour */
        transactionRequestsPerHour: number;
    };
}
/**
 * Relayer configuration
 *
 * @category Advanced
 */
interface RelayerConfig {
    /** Relayer service URL */
    url: string;
    /** API key for authentication */
    apiKey?: string;
    /** Timeout for requests in milliseconds */
    timeout?: number;
    /** Retry configuration */
    retry?: {
        /** Number of retry attempts */
        attempts: number;
        /** Delay between retries in milliseconds */
        delay: number;
    };
    /** Whether to use HTTPS */
    useHttps?: boolean;
}
/**
 * Relayer request options
 *
 * @category Advanced
 */
interface RelayerRequestOptions {
    /** Request timeout in milliseconds */
    timeout?: number;
    /** Whether to retry on failure */
    retry?: boolean;
    /** Custom headers */
    headers?: Record<string, string>;
    /** Request priority */
    priority?: "low" | "medium" | "high";
}
/**
 * Relayer error response
 *
 * @category Advanced
 */
interface RelayerErrorResponse {
    /** Error code */
    code: string;
    /** Error message */
    message: string;
    /** Additional error details */
    details?: Record<string, unknown>;
    /** Request ID for debugging */
    requestId?: string;
    /** Timestamp of error */
    timestamp: number;
}
/**
 * Relayer queue information
 *
 * @category Advanced
 */
interface RelayerQueueInfo {
    /** Current queue size */
    size: number;
    /** Estimated processing time in seconds */
    estimatedProcessingTime: number;
    /** Queue position for a specific request */
    position?: number;
    /** Processing statistics */
    stats: {
        /** Average processing time in seconds */
        averageProcessingTime: number;
        /** Requests processed in last hour */
        requestsProcessedHour: number;
        /** Success rate percentage */
        successRate: number;
    };
}
/**
 * Relayer transaction status
 *
 * @category Advanced
 */
interface RelayerTransactionStatus {
    /** Transaction hash */
    transactionHash: Hash;
    /** Current status */
    status: "pending" | "confirmed" | "failed";
    /** Block number if confirmed */
    blockNumber?: bigint;
    /** Gas used */
    gasUsed?: bigint;
    /** Error message if failed */
    error?: string;
    /** Status checks performed */
    checks: Array<{
        /** Check timestamp */
        timestamp: number;
        /** Status at time of check */
        status: string;
        /** Block number at time of check */
        blockNumber: bigint;
    }>;
}
/**
 * Relayer metrics
 *
 * @category Advanced
 */
interface RelayerMetrics {
    /** Total transactions processed */
    totalTransactions: number;
    /** Successful transactions */
    successfulTransactions: number;
    /** Failed transactions */
    failedTransactions: number;
    /** Average processing time in seconds */
    averageProcessingTime: number;
    /** Current queue size */
    queueSize: number;
    /** Uptime percentage */
    uptime: number;
    /** Last 24 hour statistics */
    last24Hours: {
        /** Transactions processed */
        transactions: number;
        /** Success rate */
        successRate: number;
        /** Average response time */
        averageResponseTime: number;
    };
}
/**
 * Relayer webhook configuration
 *
 * @category Advanced
 */
interface RelayerWebhookConfig {
    /** Webhook URL */
    url: string;
    /** Events to subscribe to */
    events: Array<"transaction_confirmed" | "transaction_failed" | "storage_complete">;
    /** Webhook secret for signature verification */
    secret?: string;
    /** Whether webhook is active */
    active: boolean;
}
/**
 * Relayer webhook payload
 *
 * @category Advanced
 */
interface RelayerWebhookPayload {
    /** Event type */
    event: string;
    /** Event data */
    data: Record<string, unknown>;
    /** Timestamp */
    timestamp: number;
    /** Webhook ID */
    webhookId: string;
    /** Signature for verification */
    signature: string;
}

/**
 * Makes all properties in T optional except for those in K
 *
 * @category Reference
 */
type PartialExcept<T, K extends keyof T> = Partial<T> & Pick<T, K>;
/**
 * Makes all properties in T required except for those in K
 *
 * @category Reference
 */
type RequiredExcept<T, K extends keyof T> = Required<T> & Partial<Pick<T, K>>;
/**
 * Extracts the return type of a promise
 *
 * @category Reference
 */
type Awaited<T> = T extends Promise<infer U> ? U : T;
/**
 * Creates a type that accepts either T or a Promise<T>
 *
 * @category Reference
 */
type MaybePromise<T> = T | Promise<T>;
/**
 * Creates a type that accepts either T or an array of T
 *
 * @category Reference
 */
type MaybeArray<T> = T | T[];
/**
 * Pagination parameters for controlling result set size and navigation.
 *
 * Used across SDK methods that return lists of items to control how many items
 * are returned and to navigate through large result sets efficiently.
 *
 * @category Reference
 * @example
 * ```typescript
 * const pagination: PaginationParams = {
 *   limit: 20, // Return 20 items
 *   offset: 40, // Skip first 40 items (page 3)
 *   cursor: 'eyJpZCI6MTIzfQ==' // Or use cursor-based pagination
 * };
 *
 * const files = await vana.data.getUserFiles({
 *   owner: userAddress,
 *   pagination
 * });
 * ```
 */
interface PaginationParams {
    /** Maximum number of items to return */
    limit?: number;
    /** Number of items to skip */
    offset?: number;
    /** Cursor for cursor-based pagination */
    cursor?: string;
}
/**
 * Pagination result
 *
 * @category Reference
 */
interface PaginationResult<T> {
    /** Array of items */
    items: T[];
    /** Total number of items available */
    total: number;
    /** Number of items returned */
    count: number;
    /** Whether there are more items available */
    hasMore: boolean;
    /** Cursor for next page */
    nextCursor?: string;
}
/**
 * Block range parameters
 *
 * @category Reference
 */
interface BlockRange {
    /** Starting block number */
    fromBlock?: bigint;
    /** Ending block number */
    toBlock?: bigint;
}
/**
 * Transaction options
 *
 * @category Reference
 */
interface TransactionOptions {
    /** Gas limit */
    gasLimit?: bigint;
    /** Gas price */
    gasPrice?: bigint;
    /** Max fee per gas (EIP-1559) */
    maxFeePerGas?: bigint;
    /** Max priority fee per gas (EIP-1559) */
    maxPriorityFeePerGas?: bigint;
    /** Nonce */
    nonce?: number;
    /** Value to send with transaction */
    value?: bigint;
}
/**
 * Transaction receipt with additional metadata
 *
 * @category Reference
 */
interface TransactionReceipt {
    /** Transaction hash */
    transactionHash: Hash;
    /** Block number */
    blockNumber: bigint;
    /** Block hash */
    blockHash: Hash;
    /** Gas used */
    gasUsed: bigint;
    /** Transaction status */
    status: "success" | "reverted";
    /** Contract address if contract deployment */
    contractAddress?: Address;
    /** Event logs */
    logs: Array<{
        address: Address;
        topics: Hash[];
        data: string;
    }>;
}
/**
 * Response wrapper for API results
 *
 * @category Reference
 */
interface ApiResponse<T> {
    /** Response data */
    data: T;
    /** Success status */
    success: boolean;
    /** Error message if not successful */
    error?: string;
    /** Additional metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Cache configuration
 *
 * @category Reference
 */
interface CacheConfig {
    /** Cache TTL in milliseconds */
    ttl: number;
    /** Maximum cache size */
    maxSize?: number;
    /** Cache key prefix */
    prefix?: string;
}
/**
 * Validation result
 *
 * @category Reference
 */
interface ValidationResult {
    /** Whether validation passed */
    valid: boolean;
    /** Validation errors */
    errors: string[];
    /** Validation warnings */
    warnings: string[];
}
/**
 * Status information
 *
 * @category Reference
 */
interface StatusInfo {
    /** Whether the service is healthy */
    healthy: boolean;
    /** Status message */
    message?: string;
    /** Last check timestamp */
    lastCheck: number;
    /** Additional status details */
    details?: Record<string, unknown>;
}
/**
 * Rate limit information
 *
 * @category Reference
 */
interface RateLimitInfo {
    /** Current request count */
    requests: number;
    /** Maximum requests allowed */
    limit: number;
    /** Time window in seconds */
    window: number;
    /** Time until reset in seconds */
    resetTime: number;
}
/**
 * File upload progress
 *
 * @category Reference
 */
interface UploadProgress {
    /** Bytes uploaded */
    loaded: number;
    /** Total bytes to upload */
    total: number;
    /** Upload percentage (0-100) */
    percentage: number;
    /** Upload speed in bytes per second */
    speed: number;
    /** Estimated time remaining in seconds */
    estimatedTimeRemaining: number;
}
/**
 * Network information
 *
 * @category Reference
 */
interface NetworkInfo {
    /** Chain ID */
    chainId: number;
    /** Chain name */
    chainName: string;
    /** RPC URL */
    rpcUrl: string;
    /** Block explorer URL */
    explorerUrl?: string;
    /** Current block number */
    currentBlock: bigint;
    /** Network status */
    status: "healthy" | "degraded" | "down";
}
/**
 * Gas estimate information
 *
 * @category Reference
 */
interface GasEstimate {
    /** Gas limit */
    gasLimit: bigint;
    /** Gas price */
    gasPrice: bigint;
    /** Max fee per gas */
    maxFeePerGas?: bigint;
    /** Max priority fee per gas */
    maxPriorityFeePerGas?: bigint;
    /** Estimated cost in wei */
    estimatedCost: bigint;
}
/**
 * Time range parameters for filtering operations by time period.
 *
 * Used in various SDK methods to specify date/time ranges for queries,
 * analytics, and data filtering operations. Times are specified as Unix timestamps.
 *
 * @category Reference
 * @example
 * ```typescript
 * const lastWeek: TimeRange = {
 *   from: Date.now() - (7 * 24 * 60 * 60 * 1000), // 7 days ago
 *   to: Date.now()
 * };
 *
 * const permissions = await vana.permissions.getUserPermissions({
 *   timeRange: lastWeek
 * });
 * ```
 */
interface TimeRange {
    /** Start time (Unix timestamp) */
    from?: number;
    /** End time (Unix timestamp) */
    to?: number;
}

/**
 * Generic request pattern for all SDK operations
 *
 * @category Reference
 */
interface GenericRequest<TParams = unknown, TOptions = unknown> {
    /** Request parameters */
    params: TParams;
    /** Additional request options */
    options?: TOptions;
}
/**
 * Generic response pattern for all SDK operations
 *
 * @category Reference
 */
interface GenericResponse<TData = unknown, TMeta = unknown> {
    /** Response data */
    data: TData;
    /** Response metadata */
    meta?: TMeta;
    /** Success status */
    success: boolean;
    /** Error information if not successful */
    error?: {
        code: string;
        message: string;
        details?: unknown;
    };
}
/**
 * Generic async operation result
 *
 * @category Reference
 */
interface AsyncResult<T> {
    /** Operation result */
    result: T;
    /** Transaction hash if applicable */
    transactionHash?: Hash;
    /** Block number if applicable */
    blockNumber?: bigint;
    /** Gas used if applicable */
    gasUsed?: bigint;
}
/**
 * Generic contract interaction parameters
 *
 * @category Reference
 */
interface ContractCall<TArgs extends readonly unknown[] = readonly unknown[]> {
    /** Contract method name */
    method: string;
    /** Method arguments */
    args: TArgs;
    /** Call options */
    options?: {
        /** Gas limit */
        gasLimit?: bigint;
        /** Gas price */
        gasPrice?: bigint;
        /** Value to send */
        value?: bigint;
    };
}
/**
 * Generic contract event filter
 *
 * @category Reference
 */
interface EventFilter<TEventArgs = unknown> {
    /** Event name */
    event: string;
    /** Event arguments filter */
    args?: TEventArgs;
    /** From block */
    fromBlock?: bigint;
    /** To block */
    toBlock?: bigint;
    /** Address filter */
    address?: Address | Address[];
}
/**
 * Generic event log
 *
 * @category Reference
 */
interface EventLog<TArgs = unknown> {
    /** Event name */
    event: string;
    /** Event arguments */
    args: TArgs;
    /** Block number */
    blockNumber: bigint;
    /** Transaction hash */
    transactionHash: Hash;
    /** Log index */
    logIndex: number;
    /** Transaction index */
    transactionIndex: number;
    /** Contract address */
    address: Address;
}
/**
 * Generic controller context for dependency injection
 *
 * @category Reference
 */
interface ControllerContext$1<TClient = unknown, TConfig = unknown> {
    /** Client instance */
    client: TClient;
    /** Configuration */
    config?: TConfig;
    /** Additional context */
    [key: string]: unknown;
}
/**
 * Generic controller interface
 *
 * @category Reference
 */
interface Controller<TContext = unknown> {
    /** Controller context */
    readonly context: TContext;
}
/**
 * Generic cache interface
 *
 * @category Reference
 */
interface Cache<TKey = string, TValue = unknown> {
    /** Get value from cache */
    get(key: TKey): Promise<TValue | undefined>;
    /** Set value in cache */
    set(key: TKey, value: TValue, ttl?: number): Promise<void>;
    /** Delete value from cache */
    delete(key: TKey): Promise<boolean>;
    /** Clear all cache */
    clear(): Promise<void>;
    /** Check if key exists */
    has(key: TKey): Promise<boolean>;
}
/**
 * Generic retry configuration
 *
 * @category Reference
 */
interface RetryConfig<TError = Error> {
    /** Maximum retry attempts */
    maxAttempts: number;
    /** Base delay in milliseconds */
    baseDelay: number;
    /** Backoff multiplier */
    backoffMultiplier?: number;
    /** Maximum delay */
    maxDelay?: number;
    /** Jitter factor */
    jitter?: number;
    /** Retry condition */
    shouldRetry?: (error: TError, attempt: number) => boolean;
}
/**
 * Generic rate limiter configuration
 *
 * @category Reference
 */
interface RateLimiterConfig {
    /** Requests per time window */
    requestsPerWindow: number;
    /** Time window in milliseconds */
    windowMs: number;
    /** Burst allowance */
    burstLimit?: number;
}
/**
 * Generic middleware interface
 *
 * @category Reference
 */
interface Middleware<TRequest = unknown, TResponse = unknown> {
    /** Middleware name */
    readonly name: string;
    /** Process request */
    request?(req: TRequest): Promise<TRequest>;
    /** Process response */
    response?(res: TResponse): Promise<TResponse>;
    /** Handle errors */
    error?(error: Error, req: TRequest): Promise<TResponse | void>;
}
/**
 * Generic plugin interface
 *
 * @category Reference
 */
interface Plugin<TConfig = unknown> {
    /** Plugin name */
    readonly name: string;
    /** Plugin version */
    readonly version: string;
    /** Plugin configuration */
    readonly config: TConfig;
    /** Initialize plugin */
    init?(): Promise<void>;
    /** Cleanup plugin */
    cleanup?(): Promise<void>;
}
/**
 * Generic factory interface
 *
 * @category Reference
 */
interface Factory<T, TParams = unknown> {
    /** Create instance */
    create(params: TParams): T;
    /** Create multiple instances */
    createMany?(params: TParams[]): T[];
    /** Validate parameters */
    validate?(params: TParams): boolean;
}
/**
 * Generic repository interface for data access
 *
 * @category Reference
 */
interface Repository<TEntity, TKey = string | number> {
    /** Find by ID */
    findById(id: TKey): Promise<TEntity | undefined>;
    /** Find all entities */
    findAll(options?: {
        limit?: number;
        offset?: number;
        filter?: Partial<TEntity>;
        sort?: Array<{
            field: keyof TEntity;
            direction: "asc" | "desc";
        }>;
    }): Promise<{
        entities: TEntity[];
        total: number;
        hasMore: boolean;
    }>;
    /** Create entity */
    create(entity: Omit<TEntity, "id">): Promise<TEntity>;
    /** Update entity */
    update(id: TKey, updates: Partial<TEntity>): Promise<TEntity>;
    /** Delete entity */
    delete(id: TKey): Promise<boolean>;
    /** Check if entity exists */
    exists(id: TKey): Promise<boolean>;
}
/**
 * Generic validator interface
 *
 * @category Reference
 */
interface Validator<T> {
    /** Validate value */
    validate(value: unknown): value is T;
    /** Get validation errors */
    getErrors?(value: unknown): string[];
    /** Get validation schema */
    getSchema?(): unknown;
}
/**
 * Generic transformer interface
 *
 * @category Reference
 */
interface Transformer<TInput, TOutput> {
    /** Transform input to output */
    transform(input: TInput): TOutput | Promise<TOutput>;
    /** Reverse transform output to input */
    reverse?(output: TOutput): TInput | Promise<TInput>;
}
/**
 * Generic service interface
 *
 * @category Reference
 */
interface Service<TConfig = unknown> {
    /** Service name */
    readonly name: string;
    /** Service configuration */
    readonly config: TConfig;
    /** Service status */
    readonly status: "idle" | "starting" | "running" | "stopping" | "stopped" | "error";
    /** Start service */
    start(): Promise<void>;
    /** Stop service */
    stop(): Promise<void>;
    /** Restart service */
    restart?(): Promise<void>;
    /** Get health status */
    getHealth?(): Promise<{
        healthy: boolean;
        details?: Record<string, unknown>;
    }>;
}
/**
 * Generic observer pattern
 *
 * @category Reference
 */
interface Observer<TEvent = unknown> {
    /** Handle event */
    notify(event: TEvent): void | Promise<void>;
}
/**
 * Generic observable pattern
 *
 * @category Reference
 */
interface Observable<TEvent = unknown> {
    /** Subscribe to events */
    subscribe(observer: Observer<TEvent>): () => void;
    /** Unsubscribe from events */
    unsubscribe(observer: Observer<TEvent>): void;
    /** Emit event */
    emit(event: TEvent): void;
}
/**
 * Generic state machine interface
 *
 * @category Reference
 */
interface StateMachine<TState, TEvent> {
    /** Current state */
    readonly currentState: TState;
    /** Transition to new state */
    transition(event: TEvent): TState;
    /** Check if transition is valid */
    canTransition(event: TEvent): boolean;
    /** Get available transitions */
    getAvailableTransitions(): TEvent[];
}
/**
 * Helper type to make properties optional conditionally
 *
 * @category Reference
 */
type ConditionalOptional<T, K extends keyof T, Condition extends boolean> = Condition extends true ? Omit<T, K> & Partial<Pick<T, K>> : T;
/**
 * Helper type to extract promise result type
 *
 * @category Reference
 */
type PromiseResult<T> = T extends Promise<infer U> ? U : T;
/**
 * Helper type to create a union of all possible keys
 *
 * @category Reference
 */
type AllKeys<T> = T extends unknown ? keyof T : never;
/**
 * Helper type to create a deep partial type
 *
 * @category Reference
 */
type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
/**
 * Helper type to create a deep readonly type
 *
 * @category Reference
 */
type DeepReadonly<T> = {
    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};
/**
 * Helper type to create a required type with specific keys
 *
 * @category Reference
 */
type RequireKeys<T, K extends keyof T> = Required<Pick<T, K>> & Omit<T, K>;
/**
 * Helper type to create an optional type with specific keys
 *
 * @category Reference
 */
type OptionalKeys<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
/**
 * Helper type to exclude null and undefined
 *
 * @category Reference
 */
type NonNullable<T> = T extends null | undefined ? never : T;
/**
 * Helper type to create a type with only specific keys
 *
 * @category Reference
 */
type PickByType<T, U> = {
    [K in keyof T as T[K] extends U ? K : never]: T[K];
};
/**
 * Helper type to omit keys by type
 *
 * @category Reference
 */
type OmitByType<T, U> = {
    [K in keyof T as T[K] extends U ? never : K]: T[K];
};
/**
 * Helper type for branded types
 *
 * @category Reference
 */
type Brand<T, B> = T & {
    readonly __brand: B;
};
/**
 * Helper type for nominal types
 *
 * @category Reference
 */
type Nominal<T, N extends string> = T & {
    readonly __nominal: N;
};

/**
 * Represents a user's registered data file.
 */
interface UserFile {
    /** Unique identifier for the file */
    id: number;
    /** URL where the file is stored */
    url: string;
    /** EVM address of the file owner */
    ownerAddress: Address;
    /** Block number when the file was added to the registry */
    addedAtBlock: bigint;
}
/**
 * Parameters for the `vana.permissions.grant` method.
 */
interface GrantPermissionParams {
    /** The on-chain identity of the application */
    to: Address;
    /** The class of computation, e.g., "llm_inference" */
    operation: string;
    /** Array of file IDs to grant permission for */
    files: number[];
    /** The full, off-chain parameters (e.g., LLM prompt) */
    parameters: Record<string, unknown>;
    /** Optional pre-stored grant URL to avoid duplicate IPFS storage */
    grantUrl?: string;
}

/**
 * Google Drive Storage Provider for Vana SDK
 *
 * Implements storage interface for Google Drive using OAuth2 authentication.
 * Based on patterns from dlp-ui-template with NextAuth integration.
 */

interface GoogleDriveConfig {
    /** OAuth2 access token */
    accessToken: string;
    /** Optional refresh token for token renewal */
    refreshToken?: string;
    /** OAuth2 client ID */
    clientId?: string;
    /** OAuth2 client secret */
    clientSecret?: string;
    /** Parent folder ID to upload files to */
    folderId?: string;
}
/**
 * Google Drive Storage Provider with folder management capabilities
 *
 * @remarks
 * Implements storage interface for Google Drive using OAuth2 authentication.
 * Provides file upload/download operations and advanced folder management
 * including search, creation, and nested folder structures. Requires the
 * `https://www.googleapis.com/auth/drive.file` OAuth scope for full functionality.
 *
 * @category Storage
 *
 * @example
 * ```typescript
 * const googleDriveStorage = new GoogleDriveStorage({
 *   accessToken: "your-oauth-access-token",
 *   refreshToken: "your-oauth-refresh-token",
 *   clientId: "your-oauth-client-id",
 *   clientSecret: "your-oauth-client-secret",
 * });
 *
 * // Create folder structure and upload file
 * const folderId = await googleDriveStorage.findOrCreateFolder("screenshots");
 * const result = await googleDriveStorage.upload(fileBlob, "image.png");
 * ```
 */
declare class GoogleDriveStorage implements StorageProvider {
    private config;
    private readonly baseUrl;
    private readonly uploadUrl;
    constructor(config: GoogleDriveConfig);
    upload(file: Blob, filename?: string): Promise<StorageUploadResult>;
    download(url: string): Promise<Blob>;
    list(options?: StorageListOptions): Promise<StorageFile[]>;
    delete(url: string): Promise<boolean>;
    getConfig(): StorageProviderConfig;
    /**
     * Make a Google Drive file publicly readable
     *
     * @param fileId - Google Drive file ID
     */
    private makeFilePublic;
    /**
     * Extract file ID from various Google Drive URL formats
     *
     * @param url - Google Drive URL
     * @returns File ID or null if not found
     */
    private extractFileId;
    /**
     * Searches for an existing folder by name within a specified parent folder
     *
     * @remarks
     * This method queries the Google Drive API to find a folder with the exact name
     * within the specified parent directory. Only searches for folders (not files)
     * and excludes trashed items.
     *
     * @param name - The exact name of the folder to search for
     * @param parentId - The ID of the parent folder to search within (defaults to 'root')
     * @returns Promise that resolves to the folder ID if found, or `null` if not found
     * @throws {StorageError} When the Google Drive API request fails
     *
     * @example
     * ```typescript
     * // Search for a folder in the root directory
     * const folderId = await googleDriveStorage.findFolder("screenshots");
     * if (folderId) {
     *   console.log("Found folder:", folderId);
     * } else {
     *   console.log("Folder not found");
     * }
     *
     * // Search for a subfolder within another folder
     * const subFolderId = await googleDriveStorage.findFolder("roasts", parentFolderId);
     * ```
     */
    findFolder(name: string, parentId?: string): Promise<string | null>;
    /**
     * Creates a new folder within a specified parent folder
     *
     * @remarks
     * This method creates a new folder using the Google Drive API. The folder will be
     * created with the specified name as a child of the parent folder. Requires the
     * `https://www.googleapis.com/auth/drive.file` OAuth scope.
     *
     * @param name - The name for the new folder
     * @param parentId - The ID of the parent folder where the new folder will be created (defaults to 'root')
     * @returns Promise that resolves to the ID of the newly created folder
     * @throws {StorageError} When the Google Drive API request fails or folder creation is denied
     *
     * @example
     * ```typescript
     * // Create a folder in the root directory
     * const folderId = await googleDriveStorage.createFolder("my-documents");
     * console.log("Created folder:", folderId);
     *
     * // Create a subfolder within another folder
     * const subFolderId = await googleDriveStorage.createFolder("reports", parentFolderId);
     * ```
     */
    createFolder(name: string, parentId?: string): Promise<string>;
    /**
     * Finds an existing folder by name, or creates it if it doesn't exist
     *
     * @remarks
     * This is a convenience method that combines `findFolder` and `createFolder`.
     * It first searches for an existing folder with the specified name. If found,
     * it returns the existing folder's ID. If not found, it creates a new folder
     * and returns the new folder's ID.
     *
     * @param name - The name of the folder to find or create
     * @param parentId - The ID of the parent folder to search within or create the folder in (defaults to 'root')
     * @returns Promise that resolves to the folder ID (either existing or newly created)
     * @throws {StorageError} When the Google Drive API request fails
     *
     * @example
     * ```typescript
     * // Ensure a folder exists, creating it if necessary
     * const folderId = await googleDriveStorage.findOrCreateFolder("screenshots");
     * console.log("Folder ID:", folderId); // Will be same ID if folder already existed
     *
     * // Create nested folder structure
     * const parentId = await googleDriveStorage.findOrCreateFolder("projects");
     * const childId = await googleDriveStorage.findOrCreateFolder("vana-app", parentId);
     * ```
     */
    findOrCreateFolder(name: string, parentId?: string): Promise<string>;
    /**
     * Refresh the access token using refresh token
     *
     * @returns Promise with new access token
     */
    refreshAccessToken(): Promise<string>;
}

interface IpfsConfig {
    /** IPFS API endpoint for uploads */
    apiEndpoint: string;
    /** Gateway URL for downloads (optional, defaults to public gateway) */
    gatewayUrl?: string;
    /** Additional headers for API requests */
    headers?: Record<string, string>;
}
/**
 * Connects to any standard IPFS node or service provider
 *
 * @remarks
 * This provider implements the standard IPFS HTTP API (`/api/v0/add`) and works
 * with any IPFS-compatible service. It provides the essential IPFS operations
 * (upload/download) while maintaining the immutable, content-addressed nature
 * of IPFS. Use static factory methods for common providers like Infura or local nodes.
 *
 * @category Storage
 *
 * @example
 * ```typescript
 * // Use with Infura (recommended for production)
 * const ipfsStorage = IpfsStorage.forInfura({
 *   projectId: "your-project-id",
 *   projectSecret: "your-project-secret"
 * });
 *
 * // Use with local IPFS node
 * const localStorage = IpfsStorage.forLocalNode();
 *
 * // Upload file and get CID
 * const result = await ipfsStorage.upload(fileBlob, "document.pdf");
 * console.log("Uploaded to IPFS:", result.url);
 * ```
 */
declare class IpfsStorage implements StorageProvider {
    private config;
    private readonly gatewayUrl;
    private readonly hasAuth;
    constructor(config: IpfsConfig);
    /**
     * Creates an IPFS storage instance configured for Infura
     *
     * @remarks
     * Infura provides reliable, scalable IPFS infrastructure with global availability.
     * This factory method automatically configures the correct endpoints and authentication
     * for Infura's IPFS service.
     *
     * @param credentials - Infura project credentials
     * @param credentials.projectId - Your Infura project ID
     * @param credentials.projectSecret - Your Infura project secret
     * @returns Configured IpfsStorage instance for Infura
     *
     * @example
     * ```typescript
     * const ipfsStorage = IpfsStorage.forInfura({
     *   projectId: "2FVGj8UJP5v8ZcnX9K5L7M8c",
     *   projectSecret: "a7f2c1e5b8d9f3a6e4c8b2d7f9e1a4c3"
     * });
     *
     * const result = await ipfsStorage.upload(fileBlob);
     * ```
     */
    static forInfura(credentials: {
        projectId: string;
        projectSecret: string;
    }): IpfsStorage;
    /**
     * Creates an IPFS storage instance configured for a local IPFS node
     *
     * @remarks
     * This factory method configures the storage provider to connect to a local IPFS node,
     * typically running on your development machine or server. Assumes standard ports
     * (5001 for API, 8080 for gateway) unless otherwise specified.
     *
     * @param options - Local node configuration options
     * @param options.url - Base URL of the local IPFS node (defaults to http://localhost:5001)
     * @returns Configured IpfsStorage instance for local node
     *
     * @example
     * ```typescript
     * // Use default localhost configuration
     * const localStorage = IpfsStorage.forLocalNode();
     *
     * // Use custom local node URL
     * const customStorage = IpfsStorage.forLocalNode({
     *   url: "http://192.168.1.100:5001"
     * });
     *
     * const result = await localStorage.upload(fileBlob, "local-file.txt");
     * ```
     */
    static forLocalNode(options?: {
        url?: string;
    }): IpfsStorage;
    /**
     * Uploads a file to IPFS and returns the content identifier (CID)
     *
     * @remarks
     * This method uploads the file to the configured IPFS endpoint using the standard
     * `/api/v0/add` API. The file is content-addressed, meaning the same file will
     * always produce the same CID regardless of when or where it's uploaded.
     *
     * @param file - The file to upload to IPFS
     * @param filename - Optional filename (for metadata purposes only)
     * @returns Promise that resolves to StorageUploadResult with IPFS gateway URL
     * @throws {StorageError} When the upload fails or no CID is returned
     *
     * @example
     * ```typescript
     * const result = await ipfsStorage.upload(fileBlob, "report.pdf");
     * console.log("File uploaded to IPFS:", result.url);
     * // Example URL: "https://gateway.pinata.cloud/ipfs/QmTzQ1JRkWErjk39mryYw2WVrgBMe2B36gRq8GCL8qCACj"
     * ```
     */
    upload(file: Blob, filename?: string): Promise<StorageUploadResult>;
    /**
     * Downloads a file from IPFS using its content identifier (CID)
     *
     * @remarks
     * This method retrieves the file from IPFS using the configured gateway.
     * It accepts various formats including raw CIDs, ipfs:// URLs, and gateway URLs.
     * The file is downloaded from the globally distributed IPFS network.
     *
     * @param cid - The IPFS content identifier, ipfs:// URL, or gateway URL
     * @returns Promise that resolves to the downloaded file content
     * @throws {StorageError} When the download fails or CID format is invalid
     *
     * @example
     * ```typescript
     * // Download using raw CID
     * const file = await ipfsStorage.download("QmTzQ1JRkWErjk39mryYw2WVrgBMe2B36gRq8GCL8qCACj");
     *
     * // Download using ipfs:// URL
     * const file2 = await ipfsStorage.download("ipfs://QmTzQ1JRkWErjk39mryYw2WVrgBMe2B36gRq8GCL8qCACj");
     *
     * // Create download link
     * const url = URL.createObjectURL(file);
     * ```
     */
    download(cid: string): Promise<Blob>;
    list(_options?: StorageListOptions): Promise<StorageFile[]>;
    delete(_url: string): Promise<boolean>;
    getConfig(): StorageProviderConfig;
    /**
     * Build download URL from CID or existing URL
     *
     * @param cid - IPFS CID or URL
     * @returns Gateway URL for download
     */
    private buildDownloadUrl;
    /**
     * Basic CID validation
     *
     * @param cid - Content identifier to validate
     * @returns True if CID appears valid
     */
    private isValidCID;
}

interface PinataConfig {
    /** Pinata JWT token for authentication */
    jwt: string;
    /** Optional custom gateway URL (defaults to https://gateway.pinata.cloud) */
    gatewayUrl?: string;
}
/**
 * Provides managed IPFS storage with full-featured API via Pinata
 *
 * @remarks
 * This provider uses Pinata's enhanced IPFS service, which extends standard IPFS
 * with additional features like file listing, deletion (unpinning), and rich metadata.
 * It's the "it just works" solution for developers who want full CRUD operations
 * on IPFS without managing infrastructure.
 *
 * @category Storage
 *
 * @example
 * ```typescript
 * const pinataStorage = new PinataStorage({
 *   jwt: "your-pinata-jwt-token"
 * });
 *
 * // Upload with metadata
 * const cid = await pinataStorage.upload(fileBlob, {
 *   name: "user-avatar.png",
 *   metadata: { userId: "123", category: "avatar" }
 * });
 *
 * // List files with query
 * const files = await pinataStorage.list({ limit: 10 });
 *
 * // Delete file
 * await pinataStorage.delete(cid);
 * ```
 */
declare class PinataStorage implements StorageProvider {
    private config;
    private readonly apiUrl;
    private readonly gatewayUrl;
    constructor(config: PinataConfig);
    /**
     * Uploads a file to IPFS via Pinata and returns the CID
     *
     * @remarks
     * This method uploads the file to Pinata's IPFS service with enhanced metadata support.
     * The file is pinned to ensure availability and can include custom metadata for
     * organization and querying. The metadata is stored alongside the file for later retrieval.
     *
     * @param file - The file to upload to IPFS
     * @param filename - Optional custom filename
     * @returns Promise that resolves to the IPFS CID (content identifier)
     * @throws {StorageError} When the upload fails or no CID is returned
     *
     * @example
     * ```typescript
     * const cid = await pinataStorage.upload(fileBlob, {
     *   name: "user-document.pdf",
     *   metadata: {
     *     userId: "user-123",
     *     category: "documents",
     *     uploadDate: new Date().toISOString()
     *   }
     * });
     * console.log("File pinned to IPFS:", cid);
     * ```
     */
    upload(file: Blob, filename?: string): Promise<StorageUploadResult>;
    download(cid: string): Promise<Blob>;
    /**
     * Lists files uploaded to Pinata with optional filtering
     *
     * @remarks
     * This method retrieves a list of files that have been uploaded to Pinata,
     * filtered to only include files uploaded by the Vana SDK. You can further
     * filter results by name pattern, limit results, or paginate through them.
     *
     * @param options - Optional query parameters for filtering and pagination
     * @param options.limit - Maximum number of results to return (default: 10)
     * @param options.offset - Number of results to skip for pagination
     * @param options.namePattern - Filter files by name pattern
     * @returns Promise that resolves to an array of PinataFile objects
     * @throws {StorageError} When the list operation fails
     *
     * @example
     * ```typescript
     * // List all files
     * const allFiles = await pinataStorage.list();
     *
     * // List with pagination and filtering
     * const filteredFiles = await pinataStorage.list({
     *   limit: 20,
     *   offset: 10,
     *   namePattern: "document"
     * });
     *
     * filteredFiles.forEach(file => {
     *   console.log(`${file.name} (${file.size} bytes): ${file.cid}`);
     * });
     * ```
     */
    list(options?: StorageListOptions): Promise<StorageFile[]>;
    /**
     * Deletes a file from Pinata by unpinning it from IPFS
     *
     * @remarks
     * This method removes the file from your Pinata account by unpinning it,
     * which means it will no longer be guaranteed to be available on the IPFS network.
     * Note that if the file is pinned elsewhere or cached by other nodes, it may still
     * be accessible for some time.
     *
     * @param url - The IPFS URL or content identifier of the file to delete
     * @returns Promise that resolves when the file is successfully unpinned
     * @throws {StorageError} When the deletion fails or CID format is invalid
     *
     * @example
     * ```typescript
     * // Delete a file by CID
     * await pinataStorage.delete("QmTzQ1JRkWErjk39mryYw2WVrgBMe2B36gRq8GCL8qCACj");
     * console.log("File unpinned from Pinata");
     *
     * // Delete after listing
     * const files = await pinataStorage.list();
     * for (const file of files) {
     *   if (file.name.includes("temp")) {
     *     await pinataStorage.delete(file.cid);
     *   }
     * }
     * ```
     */
    delete(url: string): Promise<boolean>;
    getConfig(): StorageProviderConfig;
    /**
     * Extract CID from URL or return as-is
     *
     * @param url - URL or CID string
     * @returns CID string
     */
    private extractCidFromUrl;
    /**
     * Basic CID validation
     *
     * @param cid - Content identifier to validate
     * @returns True if CID appears valid
     */
    private isValidCID;
}

interface ServerProxyConfig {
    /** Server endpoint for file uploads */
    uploadUrl: string;
    /** Server endpoint for file downloads */
    downloadUrl: string;
}
/**
 * Delegates storage operations to your server endpoints
 *
 * @remarks
 * This provider is completely agnostic about the actual storage backend used by
 * your server. It simply proxies upload and download requests to your configured
 * endpoints, allowing you to implement any storage strategy (IPFS, S3, local filesystem, etc.)
 * on the server side while maintaining a consistent client interface.
 *
 * @category Storage
 *
 * @example
 * ```typescript
 * const serverStorage = new ServerProxyStorage({
 *   uploadUrl: "/api/files/upload",
 *   downloadUrl: "/api/files/download"
 * });
 *
 * // Upload file through your server
 * const identifier = await serverStorage.upload(fileBlob, { name: "document.pdf" });
 *
 * // Download file through your server
 * const file = await serverStorage.download(identifier);
 * ```
 */
declare class ServerProxyStorage implements StorageProvider {
    private config;
    constructor(config: ServerProxyConfig);
    /**
     * Uploads a file through your server endpoint
     *
     * @remarks
     * This method sends the file to your configured upload endpoint via FormData.
     * Your server is responsible for handling the actual storage implementation
     * and must return a JSON response with `success: true` and an `identifier` field.
     *
     * @param file - The file to upload
     * @param filename - Optional custom filename
     * @returns Promise that resolves to the server-provided identifier
     * @throws {StorageError} When the upload fails or server returns an error
     *
     * @example
     * ```typescript
     * const identifier = await serverStorage.upload(fileBlob, { name: "report.pdf" });
     * console.log("File uploaded with identifier:", identifier);
     * ```
     */
    upload(file: Blob, filename?: string): Promise<StorageUploadResult>;
    /**
     * Downloads a file through your server endpoint
     *
     * @remarks
     * This method sends the identifier to your configured download endpoint via POST request.
     * Your server is responsible for retrieving the file from your storage backend
     * and returning the file content as a blob response.
     *
     * @param url - The server-provided URL or identifier from upload
     * @returns Promise that resolves to the downloaded file content
     * @throws {StorageError} When the download fails or file is not found
     *
     * @example
     * ```typescript
     * const fileBlob = await serverStorage.download("file-123");
     * const url = URL.createObjectURL(fileBlob);
     * ```
     */
    download(url: string): Promise<Blob>;
    list(_options?: StorageListOptions): Promise<StorageFile[]>;
    delete(_url: string): Promise<boolean>;
    /**
     * Extract identifier from URL or return as-is
     *
     * @param url - URL or identifier string
     * @returns identifier string
     */
    private extractIdentifierFromUrl;
    getConfig(): StorageProviderConfig;
}

/**
 * Manages multiple storage providers with a unified interface for file operations.
 *
 * @remarks
 * The StorageManager provides a consistent API for uploading, downloading, and managing
 * files across different storage backends including IPFS, Pinata, Google Drive, and
 * server-managed storage. It handles provider registration, default provider selection,
 * and automatic fallback scenarios for robust file operations.
 *
 * Used internally by DataController for encrypted file storage, but can also be used
 * directly for custom storage workflows. Each provider implements the `StorageProvider`
 * interface to ensure consistent behavior across different storage backends.
 *
 * The manager supports provider-specific configurations and features while maintaining
 * a uniform API surface for applications.
 * @example
 * ```typescript
 * import { StorageManager, IPFSStorage, PinataStorage } from 'vana-sdk';
 *
 * const storage = new StorageManager();
 *
 * // Register multiple providers
 * storage.register('ipfs', new IPFSStorage({
 *   apiEndpoint: 'https://api.pinata.cloud/pinning/pinFileToIPFS'
 * }), true);
 * storage.register('pinata', new PinataStorage({
 *   jwt: 'your-pinata-jwt-token'
 * }));
 *
 * // Upload to default provider
 * const result = await storage.upload(fileBlob, 'myfile.json');
 *
 * // Upload to specific provider
 * const result2 = await storage.upload(fileBlob, 'myfile.json', 'pinata');
 * ```
 * @category Storage
 * @see {@link [URL_PLACEHOLDER] | Storage Providers Guide} for configuration details
 */
declare class StorageManager {
    private providers;
    private defaultProvider;
    /**
     * Registers a storage provider with the manager.
     *
     * @remarks
     * This method adds a new storage provider to the manager's registry and optionally
     * sets it as the default provider for subsequent operations. If no default provider
     * is currently set, the first registered provider automatically becomes the default.
     * @param name - Unique identifier for the provider
     * @param provider - The storage provider instance implementing the `StorageProvider` interface
     * @param isDefault - Whether this provider should be set as the default (defaults to `false`)
     * @example
     * ```typescript
     * const pinata = new PinataStorage({ jwt: 'your-jwt-token' });
     * storage.register('pinata', pinata, true); // Set as default
     *
     * const ipfs = new IPFSStorage({ apiEndpoint: 'https://...' });
     * storage.register('ipfs', ipfs); // Not default
     * ```
     */
    register(name: string, provider: StorageProvider, isDefault?: boolean): void;
    /**
     * Get a registered storage provider
     *
     * @param name - Provider identifier, uses default if not specified
     * @returns Storage provider instance
     */
    getProvider(name?: string): StorageProvider;
    /**
     * List all registered providers
     *
     * @returns Array of provider names
     */
    listProviders(): string[];
    /**
     * Get the default provider name
     *
     * @returns Default provider name or null
     */
    getDefaultProvider(): string | null;
    /**
     * Set the default provider
     *
     * @param name - Provider identifier
     */
    setDefaultProvider(name: string): void;
    /**
     * Uploads a file using the specified or default storage provider.
     *
     * @remarks
     * This method uploads a file to the specified provider or falls back to the default
     * provider if none is specified. The upload result includes the storage URL, file size,
     * content type, and provider-specific metadata that can be used for subsequent operations.
     * @param file - The file blob to upload
     * @param filename - Optional custom filename (defaults to auto-generated name)
     * @param providerName - Optional provider identifier (uses default if not specified)
     * @returns A Promise that resolves to the storage upload result with URL and metadata
     * @throws {StorageError} When no provider is available or upload fails
     * @example
     * ```typescript
     * // Upload to default provider
     * const result = await storage.upload(fileBlob, 'data.json');
     * console.log(`Uploaded to: ${result.url}`);
     *
     * // Upload to specific provider
     * const result2 = await storage.upload(fileBlob, 'data.json', 'pinata');
     * ```
     */
    upload(file: Blob, filename?: string, providerName?: string): Promise<StorageUploadResult>;
    /**
     * Download a file using the specified or default provider
     *
     * @param url - The storage URL
     * @param providerName - Optional provider to use
     * @returns Promise with file blob
     */
    download(url: string, providerName?: string): Promise<Blob>;
    /**
     * List files using the specified or default provider
     *
     * @param options - Optional filtering and pagination
     * @param providerName - Optional provider to use
     * @returns Promise with file list
     */
    list(options?: StorageListOptions, providerName?: string): Promise<StorageFile[]>;
    /**
     * Delete a file using the specified or default provider
     *
     * @param url - The storage URL
     * @param providerName - Optional provider to use
     * @returns Promise with success status
     */
    delete(url: string, providerName?: string): Promise<boolean>;
    /**
     * Get list of registered storage provider names
     *
     * @returns Array of provider names
     */
    getStorageProviders(): string[];
    /**
     * Get the default storage provider name
     *
     * @returns Default provider name or undefined
     */
    getDefaultStorageProvider(): string | undefined;
}

/**
 * Platform Adapter interface for environment-specific implementations
 *
 * This interface abstracts all environment-specific dependencies to ensure
 * the SDK works seamlessly across Node.js and browser/SSR environments.
 */
/**
 * Platform type identifier
 */
type PlatformType = "node" | "browser";
/**
 * Encryption operations that require different implementations per platform
 */
interface VanaCryptoAdapter {
    /**
     * Encrypt data with a public key using asymmetric cryptography
     *
     * @param data The data to encrypt
     * @param publicKey The public key for encryption
     * @returns Promise resolving to encrypted data
     */
    encryptWithPublicKey(data: string, publicKey: string): Promise<string>;
    /**
     * Decrypt data with a private key using asymmetric cryptography
     *
     * @param encryptedData The encrypted data
     * @param privateKey The private key for decryption
     * @returns Promise resolving to decrypted data
     */
    decryptWithPrivateKey(encryptedData: string, privateKey: string): Promise<string>;
    /**
     * Generate a new key pair for asymmetric cryptography
     *
     * @returns Promise resolving to public and private key pair
     */
    generateKeyPair(): Promise<{
        publicKey: string;
        privateKey: string;
    }>;
    /**
     * Encrypt data with a wallet's public key using ECDH cryptography
     * Uses platform-appropriate ECDH implementation (eccrypto vs eccrypto-js)
     *
     * @param data The data to encrypt (string)
     * @param publicKey The wallet's public key (secp256k1)
     * @returns Promise resolving to encrypted data as hex string
     */
    encryptWithWalletPublicKey(data: string, publicKey: string): Promise<string>;
    /**
     * Decrypt data with a wallet's private key using ECDH cryptography
     * Uses platform-appropriate ECDH implementation (eccrypto vs eccrypto-js)
     *
     * @param encryptedData The encrypted data as hex string
     * @param privateKey The wallet's private key (secp256k1)
     * @returns Promise resolving to decrypted data as string
     */
    decryptWithWalletPrivateKey(encryptedData: string, privateKey: string): Promise<string>;
    /**
     * Encrypt data with a password using PGP password-based encryption
     * Uses platform-appropriate OpenPGP implementation with consistent format
     *
     * @param data The data to encrypt as Uint8Array
     * @param password The password for encryption (typically wallet signature)
     * @returns Promise resolving to encrypted data as Uint8Array
     */
    encryptWithPassword(data: Uint8Array, password: string): Promise<Uint8Array>;
    /**
     * Decrypt data with a password using PGP password-based decryption
     * Uses platform-appropriate OpenPGP implementation with consistent format
     *
     * @param encryptedData The encrypted data as Uint8Array
     * @param password The password for decryption (typically wallet signature)
     * @returns Promise resolving to decrypted data as Uint8Array
     */
    decryptWithPassword(encryptedData: Uint8Array, password: string): Promise<Uint8Array>;
}
/**
 * PGP operations that require different configurations per platform
 */
interface VanaPGPAdapter {
    /**
     * Encrypt data using PGP with proper platform configuration
     *
     * @param data The data to encrypt
     * @param publicKey The PGP public key
     * @returns Promise resolving to encrypted data
     */
    encrypt(data: string, publicKey: string): Promise<string>;
    /**
     * Decrypt data using PGP with proper platform configuration
     *
     * @param encryptedData The encrypted data
     * @param privateKey The PGP private key
     * @returns Promise resolving to decrypted data
     */
    decrypt(encryptedData: string, privateKey: string): Promise<string>;
    /**
     * Generate a new PGP key pair with platform-appropriate configuration
     *
     * @param options - Key generation options
     * @param options.name - The name for the PGP key
     * @param options.email - The email for the PGP key
     * @param options.passphrase - Optional passphrase to protect the private key
     * @returns Promise resolving to public and private key pair
     */
    generateKeyPair(options?: {
        name?: string;
        email?: string;
        passphrase?: string;
    }): Promise<{
        publicKey: string;
        privateKey: string;
    }>;
}
/**
 * HTTP operations that need consistent API across platforms
 */
interface VanaHttpAdapter {
    /**
     * Perform HTTP request with platform-appropriate fetch implementation
     *
     * @param url The URL to request
     * @param options Request options
     * @returns Promise resolving to response
     */
    fetch(url: string, options?: RequestInit): Promise<Response>;
}
/**
 * Main platform adapter interface that combines all platform-specific functionality
 */
interface VanaPlatformAdapter {
    /**
     * Crypto operations adapter
     */
    crypto: VanaCryptoAdapter;
    /**
     * PGP operations adapter
     */
    pgp: VanaPGPAdapter;
    /**
     * HTTP operations adapter
     */
    http: VanaHttpAdapter;
    /**
     * Platform identifier for debugging/telemetry
     */
    readonly platform: PlatformType;
}

/**
 * Provides shared configuration and services for all SDK controllers.
 *
 * @remarks
 * This interface defines the foundational blockchain and storage services that all
 * controllers require for operation. The main Vana SDK class automatically creates
 * this context during initialization and passes it to each controller. It includes
 * wallet clients for transaction signing, storage managers for file operations,
 * and platform adapters for environment-specific functionality.
 * @category Configuration
 */
interface ControllerContext {
    /** Signs transactions and messages using the user's private key. */
    walletClient: WalletClient;
    /** Queries blockchain state and smart contracts without signing. */
    publicClient: PublicClient;
    /** Signs application-specific operations when different from primary wallet. */
    applicationClient?: WalletClient;
    /** Handles gasless transaction submission through relayer services. */
    relayerCallbacks?: RelayerCallbacks;
    /** Manages file upload and download operations across storage providers. */
    storageManager?: StorageManager;
    /** Provides subgraph endpoint for querying indexed blockchain data. */
    subgraphUrl?: string;
    /** Adapts SDK functionality to the current runtime environment. */
    platform: VanaPlatformAdapter;
}
/**
 * Manages gasless data access permissions and trusted server registry operations.
 *
 * @remarks
 * This controller enables users to grant applications access to their data without
 * paying gas fees. It handles the complete EIP-712 permission flow including signature
 * creation, IPFS storage of permission details, and gasless transaction submission.
 * The controller also manages trusted servers that can process user data and provides
 * methods for revoking permissions when access is no longer needed.
 *
 * All permission operations support both gasless transactions via relayers and direct
 * blockchain transactions. Grant files containing detailed permission parameters are
 * stored on IPFS while permission references are recorded on the blockchain.
 * @example
 * ```typescript
 * // Grant permission for an app to access your data
 * const txHash = await vana.permissions.grant({
 *   to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
 *   operation: "llm_inference",
 *   parameters: { model: "gpt-4", maxTokens: 1000 },
 * });
 *
 * // Trust a server for data processing
 * await vana.permissions.trustServer({
 *   serverId: "0x123...",
 *   serverUrl: "https://trusted-server.example.com",
 * });
 *
 * // Query current permissions
 * const permissions = await vana.permissions.getUserPermissions();
 * ```
 * @category Permissions
 * @see {@link [URL_PLACEHOLDER] | Vana Permissions System} for conceptual overview
 */
declare class PermissionsController {
    private readonly context;
    constructor(context: ControllerContext);
    /**
     * Grants permission for an application to access user data with gasless transactions.
     *
     * @remarks
     * This method combines signature creation and gasless submission for a complete
     * end-to-end permission grant flow. It creates the grant file, stores it on IPFS,
     * generates an EIP-712 signature, and submits via relayer. The grant file contains
     * detailed parameters while the blockchain stores only a reference to enable
     * efficient permission queries.
     * @param params - The permission grant configuration object
     * @returns A Promise that resolves to the transaction hash when successfully submitted
     * @throws {RelayerError} When gasless transaction submission fails
     * @throws {SignatureError} When user rejects the signature request
     * @throws {SerializationError} When grant data cannot be serialized
     * @throws {BlockchainError} When permission grant preparation fails
     * @example
     * ```typescript
     * const txHash = await vana.permissions.grant({
     *   to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
     *   operation: "llm_inference",
     *   parameters: {
     *     model: "gpt-4",
     *     maxTokens: 1000,
     *     temperature: 0.7,
     *   },
     * });
     *
     * console.log(`Permission granted: ${txHash}`);
     * ```
     */
    grant(params: GrantPermissionParams$1): Promise<Hash>;
    /**
     * Prepares a permission grant with preview before signing.
     *
     * @remarks
     * This method implements a two-phase commit workflow that allows applications
     * to show users a preview of what they're authorizing before requesting a signature.
     * Unlike `createAndSign()`, this method does NOT upload to IPFS or prompt for signatures
     * until the returned `confirm()` function is called.
     * @param params - The permission grant parameters
     * @returns A promise resolving to a preview object and confirm function
     * @example
     * ```typescript
     * const { preview, confirm } = await vana.permissions.prepareGrant({
     *   to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
     *   operation: "llm_inference",
     *   files: [1, 2, 3],
     *   parameters: { model: "gpt-4", prompt: "Analyze my social media data" }
     * });
     *
     * console.log(`Granting ${preview.operation} access to ${preview.files?.length} files`);
     * const transactionHash = await confirm();
     * ```
     */
    prepareGrant(params: GrantPermissionParams$1): Promise<{
        preview: GrantFile;
        confirm: () => Promise<Hash>;
    }>;
    /**
     * Internal method to complete the grant process after user confirmation.
     * This is called by the confirm() function returned from prepareGrant().
     *
     * @param params - The permission grant parameters containing user and operation details
     * @param grantFile - The prepared grant file with permissions and metadata
     * @returns Promise resolving to the transaction hash
     */
    private confirmGrantInternal;
    /**
     * Creates typed data and signature for a permission grant without submitting.
     *
     * @remarks
     * This method handles the first phase of permission granting: creating the grant file,
     * storing it on IPFS, and generating the user's EIP-712 signature. Use this when you
     * want to handle submission separately or batch multiple operations. The method validates
     * the grant file against the JSON schema before creating the signature.
     *
     * For interactive user flows, consider using `prepareGrant()` instead,
     * which allows showing a preview before signing.
     * @param params - The permission grant configuration object
     * @returns A promise resolving to the typed data structure and signature for gasless submission
     * @throws {SignatureError} When the user rejects the signature request
     * @throws {SerializationError} When grant data cannot be properly formatted
     * @throws {BlockchainError} When permission grant preparation fails
     * @throws {NetworkError} When storage operations fail
     * @example
     * ```typescript
     * const { typedData, signature } = await vana.permissions.createAndSign({
     *   to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
     *   operation: "data_analysis",
     *   parameters: { analysisType: "sentiment" },
     * });
     *
     * const transactionHash = await vana.permissions.submitSignedGrant(typedData, signature);
     * ```
     */
    createAndSign(params: GrantPermissionParams$1): Promise<{
        typedData: PermissionGrantTypedData;
        signature: Hash;
    }>;
    /**
     * Submits an already-signed permission grant to the blockchain.
     *
     * @remarks
     * This method supports both relayer-based gasless transactions and direct transactions.
     * It automatically converts `bigint` values to JSON-safe strings when using relayer
     * callbacks and handles transaction submission with proper error handling and retry logic.
     * @param typedData - The EIP-712 typed data structure for the permission grant
     * @param signature - The user's signature as a hex string
     * @returns A Promise that resolves to the transaction hash
     * @throws {RelayerError} When gasless transaction submission fails
     * @throws {BlockchainError} When permission submission fails
     * @throws {NetworkError} When network communication fails
     * @example
     * ```typescript
     * const txHash = await vana.permissions.submitSignedGrant(
     *   typedData,
     *   "0x1234..."
     * );
     * ```
     */
    submitSignedGrant(typedData: PermissionGrantTypedData, signature: Hash): Promise<Hash>;
    /**
     * Submits an already-signed trust server transaction to the blockchain.
     * This method extracts the trust server input from typed data and submits it directly.
     *
     * @param typedData - The EIP-712 typed data for TrustServer
     * @param signature - The user's signature
     * @returns Promise resolving to the transaction hash
     */
    submitSignedTrustServer(typedData: TrustServerTypedData, signature: Hash): Promise<Hash>;
    /**
     * Submits an already-signed permission revoke transaction to the blockchain.
     * This method handles the revocation of previously granted permissions.
     *
     * @param typedData - The EIP-712 typed data for PermissionRevoke
     * @param signature - The user's signature
     * @returns Promise resolving to the transaction hash
     */
    submitSignedRevoke(typedData: GenericTypedData, signature: Hash): Promise<Hash>;
    /**
     * Submits an already-signed untrust server transaction to the blockchain.
     * This method handles the removal of trusted servers.
     *
     * @param typedData - The EIP-712 typed data for UntrustServer
     * @param signature - The user's signature
     * @returns Promise resolving to the transaction hash
     */
    submitSignedUntrustServer(typedData: GenericTypedData, signature: Hash): Promise<Hash>;
    /**
     * Submits a signed transaction directly to the blockchain.
     *
     * @param typedData - The typed data structure for the permission grant
     * @param signature - The cryptographic signature authorizing the transaction
     * @returns Promise resolving to the transaction hash
     */
    private submitDirectTransaction;
    /**
     * Revokes a previously granted permission.
     *
     * @param params - Parameters for revoking the permission
     * @returns Promise resolving to transaction hash
     * @example
     * ```typescript
     * // Revoke a permission by its ID
     * const txHash = await vana.permissions.revoke({
     *   permissionId: 123n
     * });
     * console.log('Permission revoked in transaction:', txHash);
     *
     * // Wait for confirmation if needed
     * const receipt = await vana.core.waitForTransaction(txHash);
     * console.log('Revocation confirmed in block:', receipt.blockNumber);
     * ```
     */
    revoke(params: RevokePermissionParams): Promise<Hash>;
    /**
     * Revokes a permission with a signature (gasless transaction).
     *
     * @param params - Parameters for revoking the permission
     * @returns Promise resolving to transaction hash
     */
    revokeWithSignature(params: RevokePermissionParams): Promise<Hash>;
    /**
     * Retrieves the user's current nonce from the DataPermissions contract.
     *
     * @returns Promise resolving to the user's current nonce value
     */
    private getUserNonce;
    /**
     * Composes the EIP-712 typed data for PermissionGrant (new simplified format).
     *
     * @param params - The parameters for composing the permission grant message
     * @param params.to - The recipient address for the permission grant
     * @param params.operation - The type of operation being granted permission for
     * @param params.files - Array of file IDs that the permission applies to
     * @param params.grantUrl - URL where the grant details are stored
     * @param params.serializedParameters - Serialized parameters for the operation
     * @param params.nonce - Unique number to prevent replay attacks
     * @returns Promise resolving to the typed data structure
     */
    private composePermissionGrantMessage;
    /**
     * Gets the EIP-712 domain for PermissionGrant signatures.
     *
     * @returns Promise resolving to the EIP-712 domain configuration
     */
    private getPermissionDomain;
    /**
     * Signs typed data using the wallet client.
     *
     * @param typedData - The EIP-712 typed data structure to sign
     * @returns Promise resolving to the cryptographic signature
     */
    private signTypedData;
    /**
     * Gets the user's address from the wallet client.
     *
     * @returns Promise resolving to the user's wallet address
     */
    private getUserAddress;
    /**
     * Retrieves all permissions granted by the current user using subgraph queries.
     *
     * @remarks
     * This method queries the Vana subgraph to find permissions directly granted by the user
     * using the Permission entity. It efficiently handles millions of permissions by leveraging
     * indexed subgraph data instead of scanning contract logs. The method fetches complete
     * grant files from IPFS to provide detailed permission information including operation
     * parameters and grantee details.
     * @param params - Optional query parameters
     * @param params.limit - Maximum number of permissions to return (default: 50)
     * @param params.subgraphUrl - Optional subgraph URL to override the default endpoint
     * @returns A Promise that resolves to an array of `GrantedPermission` objects
     * @throws {BlockchainError} When subgraph is unavailable or returns invalid data
     * @example
     * ```typescript
     * // Get all permissions granted by current user
     * const permissions = await vana.permissions.getUserPermissions();
     *
     * permissions.forEach(permission => {
     *   console.log(`Granted ${permission.operation} to ${permission.grantee}`);
     * });
     *
     * // Limit results
     * const recent = await vana.permissions.getUserPermissions({ limit: 10 });
     * ```
     */
    getUserPermissions(params?: {
        limit?: number;
        subgraphUrl?: string;
    }): Promise<GrantedPermission[]>;
    /**
     * Gets all permission IDs for a specific file.
     *
     * @param fileId - The file ID to query permissions for
     * @returns Promise resolving to array of permission IDs
     */
    getFilePermissionIds(fileId: bigint): Promise<bigint[]>;
    /**
     * Gets all file IDs associated with a permission.
     *
     * @param permissionId - The permission ID to query files for
     * @returns Promise resolving to array of file IDs
     */
    getPermissionFileIds(permissionId: bigint): Promise<bigint[]>;
    /**
     * Checks if a permission is active.
     *
     * @param permissionId - The permission ID to check
     * @returns Promise resolving to boolean indicating if permission is active
     */
    isActivePermission(permissionId: bigint): Promise<boolean>;
    /**
     * Gets permission details from the contract.
     *
     * @param permissionId - The permission ID to query
     * @returns Promise resolving to permission info
     */
    getPermissionInfo(permissionId: bigint): Promise<PermissionInfo>;
    /**
     * Normalizes grant ID to hex format.
     * Handles conversion from permission ID (bigint/number/string) to proper hex hash format.
     *
     * @param grantId - Permission ID or grant hash in various formats
     * @returns Normalized hex hash
     */
    private normalizeGrantId;
    /**
     * Trusts a server for data processing.
     *
     * @param params - Parameters for trusting the server
     * @returns Promise resolving to transaction hash
     * @example
     * ```typescript
     * // Trust a server by providing its ID and URL
     * const txHash = await vana.permissions.trustServer({
     *   serverId: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
     *   serverUrl: 'https://myserver.example.com'
     * });
     * console.log('Server trusted in transaction:', txHash);
     *
     * // Verify the server was added to trusted list
     * const trustedServers = await vana.permissions.getTrustedServers();
     * console.log('Trusted servers:', trustedServers.length);
     * ```
     */
    trustServer(params: TrustServerParams): Promise<Hash>;
    /**
     * Trusts a server using a signature (gasless transaction).
     *
     * @param params - Parameters for trusting the server
     * @returns Promise resolving to transaction hash
     */
    trustServerWithSignature(params: TrustServerParams): Promise<Hash>;
    /**
     * Submits a direct untrust server transaction (without signature).
     *
     * @param params - The untrust server parameters containing server details
     * @returns Promise resolving to the transaction hash
     */
    private submitDirectUntrustTransaction;
    /**
     * Untrusts a server.
     *
     * @param params - Parameters for untrusting the server
     * @returns Promise resolving to transaction hash
     */
    untrustServer(params: UntrustServerParams): Promise<Hash>;
    /**
     * Untrusts a server using a signature (gasless transaction).
     *
     * @param params - Parameters for untrusting the server
     * @returns Promise resolving to transaction hash
     */
    untrustServerWithSignature(params: UntrustServerParams): Promise<Hash>;
    /**
     * Gets all servers trusted by a user.
     *
     * @param userAddress - Optional user address (defaults to current user)
     * @returns Promise resolving to array of trusted server addresses
     */
    getTrustedServers(userAddress?: Address): Promise<Address[]>;
    /**
     * Gets server information by server ID.
     *
     * @param serverId - Server address
     * @returns Promise resolving to server information
     */
    getServerInfo(serverId: Address): Promise<Server>;
    /**
     * Gets the total count of trusted servers for a user.
     *
     * @param userAddress - Optional user address (defaults to current user)
     * @returns Promise resolving to the number of trusted servers
     */
    getTrustedServersCount(userAddress?: Address): Promise<number>;
    /**
     * Gets trusted servers with pagination support.
     *
     * @param options - Query options including pagination parameters
     * @returns Promise resolving to paginated trusted servers
     */
    getTrustedServersPaginated(options?: TrustedServerQueryOptions): Promise<PaginatedTrustedServers>;
    /**
     * Gets trusted servers with their complete information.
     *
     * @param options - Query options
     * @returns Promise resolving to array of trusted server info
     */
    getTrustedServersWithInfo(options?: TrustedServerQueryOptions): Promise<TrustedServerInfo[]>;
    /**
     * Gets server information for multiple servers efficiently.
     *
     * @param serverIds - Array of server IDs to query
     * @returns Promise resolving to batch result with successes and failures
     */
    getServerInfoBatch(serverIds: Address[]): Promise<BatchServerInfoResult>;
    /**
     * Checks whether a specific server is trusted by a user.
     *
     * @param serverId - Server ID to check
     * @param userAddress - Optional user address (defaults to current user)
     * @returns Promise resolving to server trust status
     */
    checkServerTrustStatus(serverId: Address, userAddress?: Address): Promise<ServerTrustStatus>;
    /**
     * Composes EIP-712 typed data for TrustServer.
     *
     * @param input - The trust server input data containing server details
     * @returns Promise resolving to the typed data structure for server trust
     */
    private composeTrustServerMessage;
    /**
     * Composes EIP-712 typed data for UntrustServer.
     *
     * @param input - The untrust server input data containing server details
     * @returns Promise resolving to the typed data structure for server untrust
     */
    private composeUntrustServerMessage;
    /**
     * Submits a trust server transaction directly to the blockchain.
     *
     * @param trustServerInput - The trust server input data containing server details
     * @param signature - The cryptographic signature for the transaction
     * @returns Promise resolving to the transaction hash
     */
    private submitTrustServerTransaction;
    /**
     * Submits a revoke transaction directly to the blockchain with signature.
     *
     * @param typedData - The EIP-712 typed data structure for the revoke operation
     * @param signature - The cryptographic signature authorizing the revoke
     * @returns Promise resolving to the transaction hash
     */
    private submitDirectRevokeTransaction;
    /**
     * Submits an untrust server transaction with signature.
     *
     * @param typedData - The EIP-712 typed data structure for the untrust operation
     * @param signature - The cryptographic signature authorizing the untrust
     * @returns Promise resolving to the transaction hash
     */
    private submitSignedUntrustTransaction;
}

/**
 * Manages encrypted user data files and their blockchain registration on the Vana network.
 *
 * @remarks
 * This controller handles the complete file lifecycle from encrypted upload to
 * blockchain registration and decryption. It provides methods for querying user files,
 * uploading new encrypted content, managing file schemas, and handling permissions for
 * secure data sharing. All operations respect the user's privacy through client-side
 * encryption before any data leaves the user's device.
 *
 * The controller integrates with multiple storage providers (IPFS, Pinata, Google Drive)
 * and supports both gasless transactions via relayers and direct blockchain interaction.
 * File metadata and access permissions are stored on the Vana blockchain while encrypted
 * file content is stored on decentralized storage networks.
 * @example
 * ```typescript
 * // Upload an encrypted file with automatic schema validation
 * const result = await vana.data.uploadEncryptedFile(
 *   encryptedBlob,
 *   "personal-data.json"
 * );
 *
 * // Query files owned by a user
 * const files = await vana.data.getUserFiles({
 *   owner: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
 * });
 *
 * // Decrypt accessible file content
 * const decryptedData = await vana.data.decryptFile(files[0]);
 * ```
 * @category Data Management
 * @see {@link [URL_PLACEHOLDER] | Vana Data Registry Documentation} for conceptual overview
 */
declare class DataController {
    private readonly context;
    private readonly serverController;
    constructor(context: ControllerContext);
    /**
     * Retrieves all data files owned by a specific user address.
     *
     * @remarks
     * This method queries the Vana subgraph to find files directly owned by the user.
     * It efficiently handles large datasets by using the File entity's owner field
     * and returns complete file metadata without additional contract calls.
     * @param params - The query parameters object
     * @param params.owner - The wallet address of the file owner to query
     * @param params.subgraphUrl - Optional subgraph URL to override the default endpoint
     * @returns A Promise that resolves to an array of UserFile objects with metadata
     * @throws {Error} When the subgraph is unavailable or returns invalid data
     * @example
     * ```typescript
     * // Query files for a specific user
     * const files = await vana.data.getUserFiles({
     *   owner: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
     * });
     *
     * files.forEach(file => {
     *   console.log(`File ${file.id}: ${file.url} (Schema: ${file.schemaId})`);
     * });
     * ```
     */
    getUserFiles(params: {
        owner: Address;
        subgraphUrl?: string;
    }): Promise<UserFile$1[]>;
    /**
     * Retrieves a list of permissions granted by a user using the new subgraph entities.
     *
     * This method queries the Vana subgraph to find permissions directly granted by the user
     * using the new Permission entity. It efficiently handles millions of permissions by:
     * 1. Querying the subgraph for user's directly granted permissions
     * 2. Returning complete permission information from subgraph
     * 3. No need for additional contract calls as all data comes from subgraph
     *
     * @param params - Object containing the user address and optional subgraph URL
     * @param params.user - The wallet address of the user to query permissions for
     * @param params.subgraphUrl - Optional subgraph URL to override the default
     * @returns Promise resolving to an array of permission objects
     * @throws Error if subgraph is unavailable or returns invalid data
     */
    getUserPermissions(params: {
        user: Address;
        subgraphUrl?: string;
    }): Promise<Array<{
        id: string;
        grant: string;
        nonce: bigint;
        signature: string;
        addedAtBlock: bigint;
        addedAtTimestamp: bigint;
        transactionHash: Address;
        user: Address;
    }>>;
    /**
     * Retrieves a list of trusted servers for a user using the new subgraph entities.
     *
     * This method queries the Vana subgraph to find trusted servers directly associated with the user
     * with support for both subgraph and direct RPC queries.
     *
     * This method supports multiple query modes:
     * - 'subgraph': Fast query via subgraph (requires subgraphUrl)
     * - 'rpc': Direct contract queries (slower but no external dependencies)
     * - 'auto': Try subgraph first, fallback to RPC if unavailable
     *
     * @param params - Query parameters including user address and mode selection
     * @returns Promise resolving to trusted servers with metadata about the query
     * @throws Error if query fails in both modes (when using 'auto')
     * @example
     * ```typescript
     * // Use subgraph for fast queries
     * const result = await vana.data.getUserTrustedServers({
     *   user: '0x...',
     *   mode: 'subgraph',
     *   subgraphUrl: 'https://...'
     * });
     *
     * // Use direct RPC (no external dependencies)
     * const result = await vana.data.getUserTrustedServers({
     *   user: '0x...',
     *   mode: 'rpc',
     *   limit: 10
     * });
     *
     * // Auto-fallback mode
     * const result = await vana.data.getUserTrustedServers({
     *   user: '0x...',
     *   mode: 'auto' // tries subgraph first, falls back to RPC
     * });
     * ```
     */
    getUserTrustedServers(params: GetUserTrustedServersParams): Promise<GetUserTrustedServersResult>;
    /**
     * Internal method: Query trusted servers via subgraph
     *
     * @param params - Query parameters object
     * @param params.user - The user address to query trusted servers for
     * @param params.subgraphUrl - The subgraph URL endpoint to query
     * @returns Promise resolving to an array of trusted server objects
     */
    private _getUserTrustedServersViaSubgraph;
    /**
     * Internal method: Query trusted servers via direct RPC
     *
     * @param params - Query parameters object
     * @param params.user - The user address to query trusted servers for
     * @param params.limit - Maximum number of results to return
     * @param params.offset - Number of results to skip for pagination
     * @returns Promise resolving to pagination result with servers, total count, and hasMore flag
     */
    private _getUserTrustedServersViaRpc;
    /**
     * Gets the total number of files in the registry from the contract.
     *
     * @returns Promise resolving to the total file count
     * @example
     * ```typescript
     * const totalFiles = await vana.data.getTotalFilesCount();
     * console.log(`Total files in registry: ${totalFiles}`);
     *
     * // Use for pagination calculations
     * const filesPerPage = 20;
     * const totalPages = Math.ceil(totalFiles / filesPerPage);
     * console.log(`Total pages: ${totalPages}`);
     * ```
     */
    getTotalFilesCount(): Promise<number>;
    /**
     * Retrieves details for a specific file by its ID.
     *
     * @param fileId - The file ID to look up
     * @returns Promise resolving to UserFile object
     * @example
     * ```typescript
     * try {
     *   const file = await vana.data.getFileById(123);
     *   console.log('File details:', {
     *     id: file.id,
     *     url: file.url,
     *     owner: file.ownerAddress,
     *     addedAt: file.addedAtBlock
     *   });
     * } catch (error) {
     *   console.error('File not found or error retrieving file:', error);
     * }
     * ```
     *
     * This method queries the DataRegistry contract directly
     * to get file details for any file ID, regardless of user ownership.
     * This is useful for file lookup functionality where users can search
     * for specific files by ID.
     */
    getFileById(fileId: number): Promise<UserFile$1>;
    /**
     * Uploads an encrypted file to storage and registers it on the blockchain.
     *
     * @param encryptedFile - The encrypted file blob to upload
     * @param filename - Optional filename for the upload
     * @param providerName - Optional storage provider to use
     * @returns Promise resolving to upload result with file ID and storage URL
     *
     * This method handles the complete flow of:
     * 1. Uploading the encrypted file to the specified storage provider
     * 2. Registering the file URL on the DataRegistry contract via relayer
     * 3. Returning the assigned file ID and storage URL
     */
    uploadEncryptedFile(encryptedFile: Blob, filename?: string, providerName?: string): Promise<UploadEncryptedFileResult>;
    /**
     * Uploads an encrypted file to storage and registers it on the blockchain with a schema.
     *
     * @param encryptedFile - The encrypted file blob to upload
     * @param schemaId - The schema ID to associate with the file
     * @param filename - Optional filename for the upload
     * @param providerName - Optional storage provider to use
     * @returns Promise resolving to upload result with file ID and storage URL
     *
     * This method handles the complete flow of:
     * 1. Uploading the encrypted file to the specified storage provider
     * 2. Registering the file URL on the DataRegistry contract with a schema ID
     * 3. Returning the assigned file ID and storage URL
     */
    uploadEncryptedFileWithSchema(encryptedFile: Blob, schemaId: number, filename?: string, providerName?: string): Promise<UploadEncryptedFileResult>;
    /**
     * Decrypts a file that was encrypted using the Vana protocol.
     *
     * @param file - The UserFile object containing the file URL and metadata
     * @param encryptionSeed - Optional custom encryption seed (defaults to Vana standard)
     * @returns Promise resolving to the decrypted file as a Blob
     *
     * This method handles the complete flow of:
     * 1. Generating the encryption key from the user's wallet signature
     * 2. Fetching the encrypted file from the stored URL
     * 3. Decrypting the file using the canonical Vana decryption method
     */
    decryptFile(file: UserFile$1, encryptionSeed?: string): Promise<Blob>;
    /**
     * Registers a file URL directly on the blockchain with a schema ID.
     *
     * @param url - The URL of the file to register
     * @param schemaId - The schema ID to associate with the file
     * @returns Promise resolving to the file ID and transaction hash
     *
     * This method registers an existing file URL on the DataRegistry
     * contract with a schema ID, without uploading any data.
     */
    registerFileWithSchema(url: string, schemaId: number): Promise<{
        fileId: number;
        transactionHash: Address;
    }>;
    /**
     * Converts IPFS and Google Drive URLs to direct download URLs for fetching.
     *
     * @param url - The URL to convert to a direct download URL
     * @returns The converted direct download URL or the original URL if not a special URL
     */
    private convertToDownloadUrl;
    /**
     * Gets the user's address from the wallet client.
     *
     * @returns Promise resolving to the user's wallet address
     */
    private getUserAddress;
    /**
     * Adds a file with permissions to the DataRegistry contract.
     *
     * @param url - The file URL to register
     * @param ownerAddress - The address of the file owner
     * @param permissions - Array of permissions to set for the file
     * @returns Promise resolving to file ID and transaction hash
     *
     * This method handles the core logic of registering a file
     * with specific permissions on the DataRegistry contract. It can be used
     * by both direct transactions and relayer services.
     */
    addFileWithPermissions(url: string, ownerAddress: Address, permissions?: Array<{
        account: Address;
        key: string;
    }>): Promise<{
        fileId: number;
        transactionHash: string;
    }>;
    /**
     * Adds a new schema to the DataRefinerRegistry.
     *
     * @param params - Schema parameters including name, type, and definition URL
     * @returns Promise resolving to the new schema ID and transaction hash
     */
    addSchema(params: AddSchemaParams): Promise<AddSchemaResult>;
    /**
     * Retrieves a schema by its ID.
     *
     * @param schemaId - The schema ID to retrieve
     * @returns Promise resolving to the schema information
     */
    getSchema(schemaId: number): Promise<Schema>;
    /**
     * Gets the total number of schemas in the registry.
     *
     * @returns Promise resolving to the total schema count
     */
    getSchemasCount(): Promise<number>;
    /**
     * Adds a new refiner to the DataRefinerRegistry.
     *
     * @param params - Refiner parameters including DLP ID, name, schema ID, and instruction URL
     * @returns Promise resolving to the new refiner ID and transaction hash
     */
    addRefiner(params: AddRefinerParams): Promise<AddRefinerResult>;
    /**
     * Retrieves a refiner by its ID.
     *
     * @param refinerId - The refiner ID to retrieve
     * @returns Promise resolving to the refiner information
     */
    getRefiner(refinerId: number): Promise<Refiner>;
    /**
     * Validates if a schema ID exists in the registry.
     *
     * @param schemaId - The schema ID to validate
     * @returns Promise resolving to boolean indicating if the schema ID is valid
     */
    isValidSchemaId(schemaId: number): Promise<boolean>;
    /**
     * Gets the total number of refiners in the registry.
     *
     * @returns Promise resolving to the total refiner count
     */
    getRefinersCount(): Promise<number>;
    /**
     * Updates the schema ID for an existing refiner.
     *
     * @param params - Parameters including refiner ID and new schema ID
     * @returns Promise resolving to the transaction hash
     */
    updateSchemaId(params: UpdateSchemaIdParams): Promise<UpdateSchemaIdResult>;
    /**
     * Uploads an encrypted file and grants permission to a party with a public key.
     *
     * This method handles the complete workflow:
     * 1. Encrypts the file with the user's encryption key
     * 2. Uploads the encrypted file to storage
     * 3. Encrypts the user's encryption key with the provided public key
     * 4. Registers the file with permissions
     *
     * @param data - The file data to encrypt and upload
     * @param permissions - Array of permissions to grant, each with account address and public key
     * @param filename - Optional filename for the upload
     * @param providerName - Optional storage provider to use
     * @returns Promise resolving to upload result with file ID and storage URL
     */
    uploadFileWithPermissions(data: Blob, permissions: Array<{
        account: Address;
        publicKey: string;
    }>, filename?: string, providerName?: string): Promise<UploadEncryptedFileResult>;
    /**
     * Adds a permission for a party to access an existing file.
     *
     * This method handles the complete workflow:
     * 1. Gets the user's encryption key
     * 2. Encrypts the user's encryption key with the provided public key
     * 3. Adds the permission to the file
     *
     * @param fileId - The ID of the file to add permissions for
     * @param account - The address of the account to grant permission to
     * @param publicKey - The public key to encrypt the user's encryption key with
     * @returns Promise resolving to the transaction hash
     */
    addPermissionToFile(fileId: number, account: Address, publicKey: string): Promise<string>;
    /**
     * Gets the encrypted key for a specific account's permission to access a file.
     *
     * @param fileId - The ID of the file
     * @param account - The account address to get the permission for
     * @returns Promise resolving to the encrypted key for that account
     */
    getFilePermission(fileId: number, account: Address): Promise<string>;
    /**
     * Gets the trusted server public key for a given server address.
     * This method reads from the permissions contract to find servers and their public keys.
     *
     * @param serverAddress - The address of the trusted server
     * @returns Promise resolving to the server's public key
     */
    getTrustedServerPublicKey(serverAddress: Address): Promise<string>;
    /**
     * Decrypts a file that the user has permission to access using their private key.
     *
     * This method handles the complete workflow for servers or other permitted parties:
     * 1. Gets the encrypted encryption key from file permissions
     * 2. Decrypts the encryption key using the provided private key
     * 3. Downloads and decrypts the file data
     *
     * @param file - The file to decrypt
     * @param privateKey - The private key to decrypt the user's encryption key
     * @param account - The account address that has permission (defaults to current wallet account)
     * @returns Promise resolving to the decrypted file data
     */
    decryptFileWithPermission(file: UserFile$1, privateKey: string, account?: Address): Promise<Blob>;
    /**
     * Validates a data schema against the Vana meta-schema.
     *
     * @param schema - The data schema to validate
     * @returns Assertion that schema is valid (throws if invalid)
     * @throws SchemaValidationError if invalid
     * @example
     * ```typescript
     * const schema = {
     *   name: "User Profile",
     *   version: "1.0.0",
     *   dialect: "json",
     *   schema: {
     *     type: "object",
     *     properties: {
     *       name: { type: "string" },
     *       age: { type: "number" }
     *     }
     *   }
     * };
     *
     * vana.data.validateDataSchema(schema);
     * ```
     */
    validateDataSchema(schema: unknown): asserts schema is DataSchema;
    /**
     * Validates data against a JSON Schema from a data schema.
     *
     * @param data - The data to validate
     * @param schema - The data schema containing the schema
     * @returns Void (throws if validation fails)
     * @throws SchemaValidationError if invalid
     * @example
     * ```typescript
     * const schema = {
     *   name: "User Profile",
     *   version: "1.0.0",
     *   dialect: "json",
     *   schema: {
     *     type: "object",
     *     properties: {
     *       name: { type: "string" },
     *       age: { type: "number" }
     *     },
     *     required: ["name"]
     *   }
     * };
     *
     * const userData = { name: "Alice", age: 30 };
     * vana.data.validateDataAgainstSchema(userData, schema);
     * ```
     */
    validateDataAgainstSchema(data: unknown, schema: DataSchema): void;
    /**
     * Fetches and validates a schema from a URL, then returns the parsed data schema.
     *
     * @param url - The URL to fetch the schema from
     * @returns The validated data schema
     * @throws SchemaValidationError if invalid or fetch fails
     * @example
     * ```typescript
     * // Fetch and validate a schema from IPFS or HTTP
     * const schema = await vana.data.fetchAndValidateSchema("https://example.com/schema.json");
     * console.log(schema.name, schema.dialect);
     *
     * // Use the schema to validate user data
     * if (schema.dialect === "json") {
     *   vana.data.validateDataAgainstSchema(userData, schema);
     * }
     * ```
     */
    fetchAndValidateSchema(url: string): Promise<DataSchema>;
    /**
     * Retrieves a schema by ID and fetches its definition URL to get the full data schema.
     *
     * @param schemaId - The schema ID to retrieve and validate
     * @returns The validated data schema
     * @throws SchemaValidationError if schema is invalid
     * @example
     * ```typescript
     * // Get schema from registry and validate its schema
     * const schema = await vana.data.getValidatedSchema(123);
     *
     * // Use it to validate user data
     * if (schema.dialect === "json") {
     *   vana.data.validateDataAgainstSchema(userData, schema);
     * }
     * ```
     */
    getValidatedSchema(schemaId: number): Promise<DataSchema>;
}

/**
 * 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.
 *
 * Personal servers enable privacy-preserving computation on user data, while identity
 * servers provide deterministic key derivation for secure communication without
 * requiring servers to be online during key retrieval.
 * @example
 * ```typescript
 * // Post a request to a personal server
 * const response = await vana.server.postRequest({
 *   permissionId: 123,
 * });
 *
 * // Get a server's public key for encryption
 * const publicKey = await vana.server.getTrustedServerPublicKey(
 *   "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36"
 * );
 *
 * // Poll for computation results
 * const result = await vana.server.pollStatus(response.urls.get);
 * ```
 * @category Server Management
 * @see {@link [URL_PLACEHOLDER] | Vana Personal Servers} for conceptual overview
 */
declare class ServerController {
    private readonly context;
    private readonly REPLICATE_API_URL;
    private readonly PERSONAL_SERVER_VERSION;
    private readonly IDENTITY_SERVER_VERSION;
    constructor(context: ControllerContext);
    /**
     * Posts a computation request to a user's personal server.
     *
     * @remarks
     * This method submits a computation request to the specified user's personal server
     * via the Replicate API. It creates a signed request with the user address and
     * permission ID, then submits it for processing. The response includes URLs for
     * polling results and canceling the computation if needed.
     *
     * The method requires a valid Replicate API token and uses the application's
     * wallet client for request signing to ensure authenticity.
     * @param params - The request parameters object
     * @param params.permissionId - The permission ID authorizing this computation
     * @returns A Promise that resolves to a prediction response with status and control URLs
     * @throws {PersonalServerError} When server request fails or parameters are invalid
     * @throws {SignatureError} When request signing fails
     * @throws {NetworkError} When Replicate API communication fails
     * @example
     * ```typescript
     * const response = await vana.server.postRequest({
     *   permissionId: 123,
     * });
     *
     * console.log(`Request submitted: ${response.id}`);
     * console.log(`Poll for results: ${response.urls.get}`);
     * ```
     */
    postRequest(params: PostRequestParams): Promise<ReplicatePredictionResponse>;
    /**
     * Initializes the personal server and fetches user identity.
     *
     * @param params - The request parameters containing user address
     * @returns Promise resolving to the user's identity information
     */
    initPersonalServer(params: InitPersonalServerParams): Promise<PersonalServerResponse$1>;
    /**
     * Retrieves the public key for a user's personal server via the Identity Server.
     *
     * @remarks
     * This method uses the Identity Server to deterministically derive the personal server's
     * public key from the user's EVM address. This enables anyone to encrypt data for a
     * specific user's server without requiring that server to be online. The Identity Server
     * provides a reliable way to obtain encryption keys for secure data sharing across the
     * Vana network.
     *
     * The derived public key is deterministic and consistent, allowing for predictable
     * encryption workflows in decentralized applications.
     * @param userAddress - The user's EVM address to derive the server public key for
     * @returns A Promise that resolves to the server's public key as a hex string
     * @throws {PersonalServerError} When user address is invalid or server lookup fails
     * @throws {NetworkError} When Identity Server API request fails
     * @example
     * ```typescript
     * // Get public key for encrypting data to a user's server
     * const publicKey = await vana.server.getTrustedServerPublicKey(
     *   "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36"
     * );
     *
     * // Use the public key for encryption
     * const encryptedData = await encryptForServer(data, publicKey);
     * ```
     */
    getTrustedServerPublicKey(userAddress: Address): Promise<string>;
    /**
     * Polls the status of a computation request for updates and results.
     *
     * @remarks
     * This method checks the current status of a computation request by querying
     * the Replicate API using the provided polling URL. It returns the current
     * status, any available output, and error information. The method should be
     * called periodically until the computation completes or fails.
     *
     * Common status values include: `starting`, `processing`, `succeeded`, `failed`, `canceled`.
     * @param getUrl - The polling URL returned from the initial request submission
     * @returns A Promise that resolves to the current prediction response with status and results
     * @throws {NetworkError} When the polling request fails or returns invalid data
     * @example
     * ```typescript
     * // Poll until completion
     * let result = await vana.server.pollStatus(response.urls.get);
     *
     * while (result.status === "processing") {
     *   await new Promise(resolve => setTimeout(resolve, 1000));
     *   result = await vana.server.pollStatus(response.urls.get);
     * }
     *
     * if (result.status === "succeeded") {
     *   console.log("Computation completed:", result.output);
     * }
     * ```
     */
    pollStatus(getUrl: string): Promise<ReplicatePredictionResponse>;
    /**
     * Validates the post request parameters.
     *
     * @param params - The post request parameters to validate
     */
    private validatePostRequestParams;
    /**
     * Validates the init personal server parameters.
     *
     * @param params - The initialization parameters to validate
     */
    private validateInitPersonalServerParams;
    /**
     * Creates the request JSON string for the personal server.
     *
     * @param params - The post request parameters to serialize
     * @returns JSON string representation of the request data
     */
    private createRequestJson;
    /**
     * Creates a signature for the request JSON.
     *
     * @param requestJson - The JSON string to sign
     * @returns Promise resolving to the cryptographic signature
     */
    private createSignature;
    /**
     * Gets the Replicate API token from environment.
     *
     * @returns The Replicate API token from environment variables
     */
    private getReplicateApiToken;
    /**
     * Makes the request to the Replicate API.
     *
     * @param input - The input parameters for the Replicate API request
     * @returns Promise resolving to the Replicate prediction response
     */
    private makeReplicateRequest;
    /**
     * Makes the request to the personal server.
     *
     * @param params - The initialization parameters for the personal server
     * @returns Promise resolving to the Replicate prediction response
     */
    private makePersonalServerRequest;
    /**
     * Polls the identity server result until completion and extracts the public key.
     *
     * @param initialResponse - The initial response from the identity server
     * @returns Promise resolving to the extracted public key
     */
    private pollIdentityServerResult;
    /**
     * Polls the personal server result until completion.
     *
     * @param initialResponse - The initial response from the personal server
     * @returns Promise resolving to the personal server response data
     */
    private pollPersonalServerResult;
}

declare const contractAbis: {
    readonly DataPermissions: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ECDSAInvalidSignature";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "length";
            readonly type: "uint256";
        }];
        readonly name: "ECDSAInvalidSignatureLength";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "s";
            readonly type: "bytes32";
        }];
        readonly name: "ECDSAInvalidSignatureS";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EmptyGrant";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EmptyUrl";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "GrantAlreadyUsed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }];
        readonly name: "InactivePermission";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "expectedNonce";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "providedNonce";
            readonly type: "uint256";
        }];
        readonly name: "InvalidNonce";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidSignature";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "fileOwner";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "requestor";
            readonly type: "address";
        }];
        readonly name: "NotFileOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "permissionOwner";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "requestor";
            readonly type: "address";
        }];
        readonly name: "NotPermissionGrantor";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ServerAlreadyRegistered";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ServerNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ServerNotTrusted";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "existingUrl";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "providedUrl";
            readonly type: "string";
        }];
        readonly name: "ServerUrlMismatch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [];
        readonly name: "EIP712DomainChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "grant";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256[]";
            readonly name: "fileIds";
            readonly type: "uint256[]";
        }];
        readonly name: "PermissionAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }];
        readonly name: "PermissionRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "serverId";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }];
        readonly name: "ServerAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "serverId";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "serverUrl";
            readonly type: "string";
        }];
        readonly name: "ServerTrusted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "serverId";
            readonly type: "address";
        }];
        readonly name: "ServerUntrusted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "nonce";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "grant";
                readonly type: "string";
            }, {
                readonly internalType: "uint256[]";
                readonly name: "fileIds";
                readonly type: "uint256[]";
            }];
            readonly internalType: "struct IDataPermissions.PermissionInput";
            readonly name: "permission";
            readonly type: "tuple";
        }, {
            readonly internalType: "bytes";
            readonly name: "signature";
            readonly type: "bytes";
        }];
        readonly name: "addPermission";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dataRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDataRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "eip712Domain";
        readonly outputs: readonly [{
            readonly internalType: "bytes1";
            readonly name: "fields";
            readonly type: "bytes1";
        }, {
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "version";
            readonly type: "string";
        }, {
            readonly internalType: "uint256";
            readonly name: "chainId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "verifyingContract";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "salt";
            readonly type: "bytes32";
        }, {
            readonly internalType: "uint256[]";
            readonly name: "extensions";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "filePermissionIds";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "contract IDataRegistry";
            readonly name: "dataRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }];
        readonly name: "isActivePermission";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "forwarder";
            readonly type: "address";
        }];
        readonly name: "isTrustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "data";
            readonly type: "bytes[]";
        }];
        readonly name: "multicall";
        readonly outputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "results";
            readonly type: "bytes[]";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }];
        readonly name: "permissionFileIds";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "grant";
            readonly type: "string";
        }];
        readonly name: "permissionIdByGrant";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }];
        readonly name: "permissions";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "id";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "grantor";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "nonce";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "grant";
                readonly type: "string";
            }, {
                readonly internalType: "bytes";
                readonly name: "signature";
                readonly type: "bytes";
            }, {
                readonly internalType: "bool";
                readonly name: "isActive";
                readonly type: "bool";
            }, {
                readonly internalType: "uint256[]";
                readonly name: "fileIds";
                readonly type: "uint256[]";
            }];
            readonly internalType: "struct IDataPermissions.PermissionInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "permissionsCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }];
        readonly name: "revokePermission";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "nonce";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "permissionId";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDataPermissions.RevokePermissionInput";
            readonly name: "revokePermissionInput";
            readonly type: "tuple";
        }, {
            readonly internalType: "bytes";
            readonly name: "signature";
            readonly type: "bytes";
        }];
        readonly name: "revokePermissionWithSignature";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "serverId";
            readonly type: "address";
        }];
        readonly name: "servers";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }];
            readonly internalType: "struct IDataPermissions.Server";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "bytes32";
            readonly name: "adminRole";
            readonly type: "bytes32";
        }];
        readonly name: "setRoleAdmin";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "serverId";
            readonly type: "address";
        }, {
            readonly internalType: "string";
            readonly name: "serverUrl";
            readonly type: "string";
        }];
        readonly name: "trustServer";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "nonce";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "serverId";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "serverUrl";
                readonly type: "string";
            }];
            readonly internalType: "struct IDataPermissions.TrustServerInput";
            readonly name: "trustServerInput";
            readonly type: "tuple";
        }, {
            readonly internalType: "bytes";
            readonly name: "signature";
            readonly type: "bytes";
        }];
        readonly name: "trustServerWithSignature";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "trustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "serverId";
            readonly type: "address";
        }];
        readonly name: "untrustServer";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "nonce";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "serverId";
                readonly type: "address";
            }];
            readonly internalType: "struct IDataPermissions.UntrustServerInput";
            readonly name: "untrustServerInput";
            readonly type: "tuple";
        }, {
            readonly internalType: "bytes";
            readonly name: "signature";
            readonly type: "bytes";
        }];
        readonly name: "untrustServerWithSignature";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IDataRegistry";
            readonly name: "newDataRegistry";
            readonly type: "address";
        }];
        readonly name: "updateDataRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }];
        readonly name: "updateTrustedForwarder";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }];
        readonly name: "userNonce";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "permissionIndex";
            readonly type: "uint256";
        }];
        readonly name: "userPermissionIdsAt";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }];
        readonly name: "userPermissionIdsLength";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }];
        readonly name: "userPermissionIdsValues";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "permissionIndex";
            readonly type: "uint256";
        }];
        readonly name: "userRevokedPermissionIdsAt";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }];
        readonly name: "userRevokedPermissionIdsLength";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }];
        readonly name: "userRevokedPermissionIdsValues";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "serverIndex";
            readonly type: "uint256";
        }];
        readonly name: "userServerIdsAt";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }];
        readonly name: "userServerIdsLength";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }];
        readonly name: "userServerIdsValues";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly DataRegistry: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FileNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FileUrlAlreadyUsed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "schemaId";
            readonly type: "uint256";
        }];
        readonly name: "InvalidSchemaId";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidUrl";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NoPermission";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotFileOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }];
        readonly name: "FileAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "PermissionGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "proofIndex";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "score";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "proofUrl";
            readonly type: "string";
        }];
        readonly name: "ProofAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }];
        readonly name: "RefinementAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }];
        readonly name: "RefinementUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "REFINEMENT_SERVICE_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }];
        readonly name: "addFile";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "string";
            readonly name: "key";
            readonly type: "string";
        }];
        readonly name: "addFilePermission";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "account";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "key";
                readonly type: "string";
            }];
            readonly internalType: "struct IDataRegistry.Permission[]";
            readonly name: "permissions";
            readonly type: "tuple[]";
        }];
        readonly name: "addFileWithPermissions";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "account";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "key";
                readonly type: "string";
            }];
            readonly internalType: "struct IDataRegistry.Permission[]";
            readonly name: "permissions";
            readonly type: "tuple[]";
        }, {
            readonly internalType: "uint256";
            readonly name: "schemaId";
            readonly type: "uint256";
        }];
        readonly name: "addFileWithPermissionsAndSchema";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly internalType: "uint256";
            readonly name: "schemaId";
            readonly type: "uint256";
        }];
        readonly name: "addFileWithSchema";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "bytes";
                readonly name: "signature";
                readonly type: "bytes";
            }, {
                readonly components: readonly [{
                    readonly internalType: "uint256";
                    readonly name: "score";
                    readonly type: "uint256";
                }, {
                    readonly internalType: "uint256";
                    readonly name: "dlpId";
                    readonly type: "uint256";
                }, {
                    readonly internalType: "string";
                    readonly name: "metadata";
                    readonly type: "string";
                }, {
                    readonly internalType: "string";
                    readonly name: "proofUrl";
                    readonly type: "string";
                }, {
                    readonly internalType: "string";
                    readonly name: "instruction";
                    readonly type: "string";
                }];
                readonly internalType: "struct IDataRegistry.ProofData";
                readonly name: "data";
                readonly type: "tuple";
            }];
            readonly internalType: "struct IDataRegistry.Proof";
            readonly name: "proof";
            readonly type: "tuple";
        }];
        readonly name: "addProof";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "string";
            readonly name: "key";
            readonly type: "string";
        }];
        readonly name: "addRefinementWithPermission";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dataRefinerRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDataRefinerRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }];
        readonly name: "fileIdByUrl";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "filePermissions";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "fileProofs";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "bytes";
                readonly name: "signature";
                readonly type: "bytes";
            }, {
                readonly components: readonly [{
                    readonly internalType: "uint256";
                    readonly name: "score";
                    readonly type: "uint256";
                }, {
                    readonly internalType: "uint256";
                    readonly name: "dlpId";
                    readonly type: "uint256";
                }, {
                    readonly internalType: "string";
                    readonly name: "metadata";
                    readonly type: "string";
                }, {
                    readonly internalType: "string";
                    readonly name: "proofUrl";
                    readonly type: "string";
                }, {
                    readonly internalType: "string";
                    readonly name: "instruction";
                    readonly type: "string";
                }];
                readonly internalType: "struct IDataRegistry.ProofData";
                readonly name: "data";
                readonly type: "tuple";
            }];
            readonly internalType: "struct IDataRegistry.Proof";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }];
        readonly name: "fileRefinements";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "files";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "id";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "addedAtBlock";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDataRegistry.FileResponse";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "filesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "forwarder";
            readonly type: "address";
        }];
        readonly name: "isTrustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "data";
            readonly type: "bytes[]";
        }];
        readonly name: "multicall";
        readonly outputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "results";
            readonly type: "bytes[]";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "bytes32";
            readonly name: "adminRole";
            readonly type: "bytes32";
        }];
        readonly name: "setRoleAdmin";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "trustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IDataRefinerRegistry";
            readonly name: "newDataRefinerRegistry";
            readonly type: "address";
        }];
        readonly name: "updateDataRefinerRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }];
        readonly name: "updateTrustedForwarder";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly TeePoolPhala: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "CancelDelayNotPassed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InsufficientFee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidJobStatus";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidJobTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "JobCompleted";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NoActiveTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotJobOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NothingToClaim";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeeAlreadyAdded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeeNotActive";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TransferFailed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "Claimed";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobCanceled";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "bidAmount";
            readonly type: "uint256";
        }];
        readonly name: "JobSubmitted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "attestator";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "ProofAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "activeTeeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum ITeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "withdrawnAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct ITeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "bytes";
                readonly name: "signature";
                readonly type: "bytes";
            }, {
                readonly components: readonly [{
                    readonly internalType: "uint256";
                    readonly name: "score";
                    readonly type: "uint256";
                }, {
                    readonly internalType: "uint256";
                    readonly name: "dlpId";
                    readonly type: "uint256";
                }, {
                    readonly internalType: "string";
                    readonly name: "metadata";
                    readonly type: "string";
                }, {
                    readonly internalType: "string";
                    readonly name: "proofUrl";
                    readonly type: "string";
                }, {
                    readonly internalType: "string";
                    readonly name: "instruction";
                    readonly type: "string";
                }];
                readonly internalType: "struct IDataRegistry.ProofData";
                readonly name: "data";
                readonly type: "tuple";
            }];
            readonly internalType: "struct IDataRegistry.Proof";
            readonly name: "proof";
            readonly type: "tuple";
        }];
        readonly name: "addProof";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "publicKey";
            readonly type: "string";
        }];
        readonly name: "addTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "cancelDelay";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "cancelJob";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "claim";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dataRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDataRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "fileJobIds";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "dataRegistryAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "initialCancelDelay";
            readonly type: "uint256";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "isTee";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "forwarder";
            readonly type: "address";
        }];
        readonly name: "isTrustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "jobs";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "fileId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "bidAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "enum ITeePool.JobStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "addedTimestamp";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }];
            readonly internalType: "struct ITeePool.Job";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "jobsCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "data";
            readonly type: "bytes[]";
        }];
        readonly name: "multicall";
        readonly outputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "results";
            readonly type: "bytes[]";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "removeTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "requestContributionProof";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "submitJob";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teeFee";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "start";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "limit";
            readonly type: "uint256";
        }];
        readonly name: "teeJobIdsPaginated";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "teeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum ITeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "withdrawnAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct ITeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "tees";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum ITeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "withdrawnAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct ITeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "trustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newCancelDelay";
            readonly type: "uint256";
        }];
        readonly name: "updateCancelDelay";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IDataRegistry";
            readonly name: "newDataRegistry";
            readonly type: "address";
        }];
        readonly name: "updateDataRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newTeeFee";
            readonly type: "uint256";
        }];
        readonly name: "updateTeeFee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }];
        readonly name: "updateTrustedForwarder";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly ComputeEngine: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "AddressInsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedToAssignTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "computeInstructionId";
            readonly type: "uint256";
        }];
        readonly name: "InstructionNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidAmount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "enum IComputeEngine.JobStatus";
            readonly name: "currentStatus";
            readonly type: "uint8";
        }, {
            readonly internalType: "enum IComputeEngine.JobStatus";
            readonly name: "newStatus";
            readonly type: "uint8";
        }];
        readonly name: "InvalidStatusTransition";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidVanaAmount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "JobAlreadyDone";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "JobLifeCycleEnded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobNotSubmitted";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotJobOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotLongRunningJob";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotQueryEngine";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "OnlyRegisteredJobStatus";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "SafeERC20FailedOperation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "TeeAlreadyAssigned";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeePoolNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UnauthorizedPaymentRequestor";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UnexpectedVanaDeposit";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroTeeAddress";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "Deposit";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobCanceled";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }];
        readonly name: "JobRegistered";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "enum IComputeEngine.JobStatus";
            readonly name: "status";
            readonly type: "uint8";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "statusMessage";
            readonly type: "string";
        }];
        readonly name: "JobStatusUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "PaymentExecuted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "bytes";
            readonly name: "reason";
            readonly type: "bytes";
        }];
        readonly name: "TeeAssignmentFailed";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teePoolAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeAssignmentSucceeded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "Withdraw";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEDICATED_TIMEOUT";
        readonly outputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "";
            readonly type: "uint80";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "VANA";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "balanceOf";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "cancelJob";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "computeEngineTreasury";
        readonly outputs: readonly [{
            readonly internalType: "contract IDataAccessTreasury";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "deposit";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly internalType: "bytes";
            readonly name: "metadata";
            readonly type: "bytes";
        }];
        readonly name: "executePaymentRequest";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initQueryEngine";
            readonly type: "address";
        }, {
            readonly internalType: "contract IComputeEngineTeePoolFactory";
            readonly name: "initTeePoolFactory";
            readonly type: "address";
        }, {
            readonly internalType: "contract DataAccessTreasuryProxyFactory";
            readonly name: "initDataAccessTreasuryFactory";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "instructionRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IComputeInstructionRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "jobs";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "uint80";
                readonly name: "maxTimeout";
                readonly type: "uint80";
            }, {
                readonly internalType: "bool";
                readonly name: "gpuRequired";
                readonly type: "bool";
            }, {
                readonly internalType: "enum IComputeEngine.JobStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "uint32";
                readonly name: "computeInstructionId";
                readonly type: "uint32";
            }, {
                readonly internalType: "uint48";
                readonly name: "addedTimestamp";
                readonly type: "uint48";
            }, {
                readonly internalType: "string";
                readonly name: "statusMessage";
                readonly type: "string";
            }, {
                readonly internalType: "address";
                readonly name: "teePoolAddress";
                readonly type: "address";
            }];
            readonly internalType: "struct IComputeEngine.Job";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "jobsCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "paymentInfo";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "queryEngine";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "resubmitJob";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "resubmitJobWithTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "maxTimeout";
            readonly type: "uint80";
        }, {
            readonly internalType: "bool";
            readonly name: "gpuRequired";
            readonly type: "bool";
        }, {
            readonly internalType: "uint256";
            readonly name: "computeInstructionId";
            readonly type: "uint256";
        }];
        readonly name: "submitJob";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "maxTimeout";
            readonly type: "uint80";
        }, {
            readonly internalType: "bool";
            readonly name: "gpuRequired";
            readonly type: "bool";
        }, {
            readonly internalType: "uint256";
            readonly name: "computeInstructionId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "submitJobWithTee";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolFactory";
        readonly outputs: readonly [{
            readonly internalType: "contract IComputeEngineTeePoolFactory";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IDataAccessTreasury";
            readonly name: "newComputeEngineTreasuryAddress";
            readonly type: "address";
        }];
        readonly name: "updateComputeEngineTreasury";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IComputeInstructionRegistry";
            readonly name: "newInstructionRegistry";
            readonly type: "address";
        }];
        readonly name: "updateInstructionRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly internalType: "enum IComputeEngine.JobStatus";
            readonly name: "status";
            readonly type: "uint8";
        }, {
            readonly internalType: "string";
            readonly name: "statusMessage";
            readonly type: "string";
        }];
        readonly name: "updateJobStatus";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newQueryEngineAddress";
            readonly type: "address";
        }];
        readonly name: "updateQueryEngine";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IComputeEngineTeePoolFactory";
            readonly name: "newTeePoolFactory";
            readonly type: "address";
        }];
        readonly name: "updateTeePoolFactory";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "vanaPaymentInfo";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "withdraw";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }];
    readonly DataRefinerRegistry: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "schemaId";
            readonly type: "uint256";
        }];
        readonly name: "InvalidSchemaId";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotDlpOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "schemaId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "refinementInstructionUrl";
            readonly type: "string";
        }];
        readonly name: "RefinerAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "schemaId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "typ";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "definitionUrl";
            readonly type: "string";
        }];
        readonly name: "SchemaAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "refinementService";
            readonly type: "address";
        }];
        readonly name: "addRefinementService";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly internalType: "uint256";
            readonly name: "schemaId";
            readonly type: "uint256";
        }, {
            readonly internalType: "string";
            readonly name: "refinementInstructionUrl";
            readonly type: "string";
        }];
        readonly name: "addRefiner";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "typ";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "definitionUrl";
            readonly type: "string";
        }];
        readonly name: "addSchema";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "dlpRefinementServices";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "dlpRefiners";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initDlpRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "refinementService";
            readonly type: "address";
        }];
        readonly name: "isRefinementService";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "schemaId";
            readonly type: "uint256";
        }];
        readonly name: "isValidSchemaId";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }];
        readonly name: "refiners";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "dlpId";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "owner";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "schemaDefinitionUrl";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "refinementInstructionUrl";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "schemaId";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDataRefinerRegistry.RefinerInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "refinersCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "refinementService";
            readonly type: "address";
        }];
        readonly name: "removeRefinementService";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "schemaId";
            readonly type: "uint256";
        }];
        readonly name: "schemas";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "typ";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "definitionUrl";
                readonly type: "string";
            }];
            readonly internalType: "struct IDataRefinerRegistry.Schema";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "schemasCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "updateDlpRefinersOwner";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newDlpRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }];
        readonly name: "updateRefinerOwner";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "newSchemaId";
            readonly type: "uint256";
        }];
        readonly name: "updateSchemaId";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly QueryEngine: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "AddressInsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ColumnNameUnexpected";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DlpNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidDlpPaymentPercentage";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidDlpTreasuryAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "InvalidPaymentToken";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotDlpOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotRefinerOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "PaymentNotReceived";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "PermissionNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "RefinerNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "SafeERC20FailedOperation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "TokenAlreadyWhitelisted";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "dlpTreasuryAddress";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "DlpPaymentClaimed";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }];
        readonly name: "PaymentReceived";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "grantee";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "tableName";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "columnName";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "tokenAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "price";
            readonly type: "uint256";
        }];
        readonly name: "PermissionAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "bool";
            readonly name: "approved";
            readonly type: "bool";
        }];
        readonly name: "PermissionApprovalUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "ONE_HUNDRED_PERCENT";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "QUERY_ENGINE_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "VANA";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly internalType: "string";
            readonly name: "tableName";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "columnName";
            readonly type: "string";
        }, {
            readonly internalType: "address";
            readonly name: "tokenAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "price";
            readonly type: "uint256";
        }];
        readonly name: "addGenericPermission";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "addPaymentToken";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "grantee";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly internalType: "string";
            readonly name: "tableName";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "columnName";
            readonly type: "string";
        }, {
            readonly internalType: "address";
            readonly name: "tokenAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "price";
            readonly type: "uint256";
        }];
        readonly name: "addPermission";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "balanceOf";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "claimDlpPayment";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "computeEngine";
        readonly outputs: readonly [{
            readonly internalType: "contract IComputeEngine";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpPaymentPercentage";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "dlpPubKeys";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "pubKey";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "grantee";
            readonly type: "address";
        }];
        readonly name: "getPermissions";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "permissionId";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "grantee";
                readonly type: "address";
            }, {
                readonly internalType: "bool";
                readonly name: "approved";
                readonly type: "bool";
            }, {
                readonly internalType: "uint256";
                readonly name: "refinerId";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "tableName";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "columnName";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "price";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "tokenAddress";
                readonly type: "address";
            }];
            readonly internalType: "struct IQueryEngine.PermissionInfo[]";
            readonly name: "";
            readonly type: "tuple[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initRefinerRegistryAddress";
            readonly type: "address";
        }, {
            readonly internalType: "contract DataAccessTreasuryProxyFactory";
            readonly name: "initDataAccessTreasuryFactory";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }];
        readonly name: "permissions";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "grantee";
                readonly type: "address";
            }, {
                readonly internalType: "bool";
                readonly name: "approved";
                readonly type: "bool";
            }, {
                readonly internalType: "uint256";
                readonly name: "refinerId";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "tableName";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "columnName";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "price";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "tokenAddress";
                readonly type: "address";
            }];
            readonly internalType: "struct IQueryEngine.Permission";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "permissionsCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "queryEngineTreasury";
        readonly outputs: readonly [{
            readonly internalType: "contract IDataAccessTreasury";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "refinerRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDataRefinerRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "removePaymentToken";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly internalType: "bytes";
            readonly name: "metadata";
            readonly type: "bytes";
        }];
        readonly name: "requestPayment";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }];
        readonly name: "requestPaymentInToken";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "refinerId";
            readonly type: "uint256";
        }];
        readonly name: "requestPaymentInVana";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newComputeEngineAddress";
            readonly type: "address";
        }];
        readonly name: "updateComputeEngine";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newDlpPaymentPercentage";
            readonly type: "uint256";
        }];
        readonly name: "updateDlpPaymentPercentage";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "string";
            readonly name: "pubKey";
            readonly type: "string";
        }];
        readonly name: "updateDlpPubKey";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "permissionId";
            readonly type: "uint256";
        }, {
            readonly internalType: "bool";
            readonly name: "approved";
            readonly type: "bool";
        }];
        readonly name: "updatePermissionApproval";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IDataAccessTreasury";
            readonly name: "newQueryEngineTreasury";
            readonly type: "address";
        }];
        readonly name: "updateQueryEngineTreasury";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newRefinerRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "updateRefinerRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newVanaTreasury";
            readonly type: "address";
        }];
        readonly name: "updateVanaTreasury";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "vanaTreasury";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly stateMutability: "payable";
        readonly type: "receive";
    }];
    readonly ComputeInstructionRegistry: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "instructionId";
            readonly type: "uint256";
        }];
        readonly name: "ComputeInstructionNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotDlpOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "computeInstructionId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "computeInstructionUrl";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "bytes32";
            readonly name: "computeInstructionHash";
            readonly type: "bytes32";
        }];
        readonly name: "ComputeInstructionAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "computeInstructionId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "bool";
            readonly name: "approved";
            readonly type: "bool";
        }];
        readonly name: "ComputeInstructionUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "hash";
            readonly type: "bytes32";
        }, {
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }];
        readonly name: "addComputeInstruction";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "computeInstructionId";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initDlpRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "instructionId";
            readonly type: "uint256";
        }];
        readonly name: "instructions";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "bytes32";
                readonly name: "hash";
                readonly type: "bytes32";
            }, {
                readonly internalType: "address";
                readonly name: "owner";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeInstructionRegistry.ComputeInstructionInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "instructionsCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "instructionId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "isApproved";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "instructionId";
            readonly type: "uint256";
        }];
        readonly name: "isValidInstructionId";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "instructionId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "bool";
            readonly name: "approved";
            readonly type: "bool";
        }];
        readonly name: "updateComputeInstruction";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newDlpRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly TeePoolEphemeralStandard: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "HWRequirementNotMet";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "MaxTimeoutExceeded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teePoolAddress";
            readonly type: "address";
        }];
        readonly name: "NoActiveTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotComputeEngine";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotTeePoolFactory";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeeAlreadyAdded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeNotActive";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "newHardwareType";
            readonly type: "uint8";
        }];
        readonly name: "HardwareTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "JobSubmitted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "publicKey";
            readonly type: "string";
        }];
        readonly name: "TeeAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "newTeePoolType";
            readonly type: "uint8";
        }];
        readonly name: "TeePoolTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "activeTeeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "addTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "computeEngine";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "hardwareType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initComputeEngine";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initTeePoolFactory";
            readonly type: "address";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "initTeePoolType";
            readonly type: "uint8";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "initHardwareType";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint80";
            readonly name: "initMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "isTee";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "maxTimeout";
        readonly outputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "";
            readonly type: "uint80";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "removeJob";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "removeTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "submitJob";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "";
            readonly type: "bytes";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "teeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolFactory";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "tees";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newComputeEngine";
            readonly type: "address";
        }];
        readonly name: "updateComputeEngine";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "newMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "updateMaxTimeout";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newTeePoolFactory";
            readonly type: "address";
        }];
        readonly name: "updateTeePoolFactory";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly TeePoolPersistentStandard: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "HWRequirementNotMet";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "MaxTimeoutExceeded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teePoolAddress";
            readonly type: "address";
        }];
        readonly name: "NoActiveTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotComputeEngine";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotTeePoolFactory";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeeAlreadyAdded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeNotActive";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "newHardwareType";
            readonly type: "uint8";
        }];
        readonly name: "HardwareTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "JobSubmitted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "publicKey";
            readonly type: "string";
        }];
        readonly name: "TeeAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "newTeePoolType";
            readonly type: "uint8";
        }];
        readonly name: "TeePoolTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "activeTeeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "addTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "computeEngine";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "hardwareType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initComputeEngine";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initTeePoolFactory";
            readonly type: "address";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "initTeePoolType";
            readonly type: "uint8";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "initHardwareType";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint80";
            readonly name: "initMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "isTee";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "maxTimeout";
        readonly outputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "";
            readonly type: "uint80";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "removeJob";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "removeTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "submitJob";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "";
            readonly type: "bytes";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "teeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolFactory";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "tees";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newComputeEngine";
            readonly type: "address";
        }];
        readonly name: "updateComputeEngine";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "newMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "updateMaxTimeout";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newTeePoolFactory";
            readonly type: "address";
        }];
        readonly name: "updateTeePoolFactory";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly TeePoolPersistentGpu: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "HWRequirementNotMet";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "MaxTimeoutExceeded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teePoolAddress";
            readonly type: "address";
        }];
        readonly name: "NoActiveTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotComputeEngine";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotTeePoolFactory";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeeAlreadyAdded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeNotActive";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "newHardwareType";
            readonly type: "uint8";
        }];
        readonly name: "HardwareTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "JobSubmitted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "publicKey";
            readonly type: "string";
        }];
        readonly name: "TeeAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "newTeePoolType";
            readonly type: "uint8";
        }];
        readonly name: "TeePoolTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "activeTeeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "addTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "computeEngine";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "hardwareType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initComputeEngine";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initTeePoolFactory";
            readonly type: "address";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "initTeePoolType";
            readonly type: "uint8";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "initHardwareType";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint80";
            readonly name: "initMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "isTee";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "maxTimeout";
        readonly outputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "";
            readonly type: "uint80";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "removeJob";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "removeTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "submitJob";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "";
            readonly type: "bytes";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "teeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolFactory";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "tees";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newComputeEngine";
            readonly type: "address";
        }];
        readonly name: "updateComputeEngine";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "newMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "updateMaxTimeout";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newTeePoolFactory";
            readonly type: "address";
        }];
        readonly name: "updateTeePoolFactory";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly TeePoolDedicatedStandard: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "HWRequirementNotMet";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "MaxTimeoutExceeded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teePoolAddress";
            readonly type: "address";
        }];
        readonly name: "NoActiveTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotComputeEngine";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotTeePoolFactory";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeeAlreadyAdded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeNotActive";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "newHardwareType";
            readonly type: "uint8";
        }];
        readonly name: "HardwareTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "JobSubmitted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "publicKey";
            readonly type: "string";
        }];
        readonly name: "TeeAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "newTeePoolType";
            readonly type: "uint8";
        }];
        readonly name: "TeePoolTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "activeTeeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "addTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "computeEngine";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "hardwareType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initComputeEngine";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initTeePoolFactory";
            readonly type: "address";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "initTeePoolType";
            readonly type: "uint8";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "initHardwareType";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint80";
            readonly name: "initMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "isTee";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "maxTimeout";
        readonly outputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "";
            readonly type: "uint80";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "removeJob";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "removeTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "submitJob";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "";
            readonly type: "bytes";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "teeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolFactory";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "tees";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newComputeEngine";
            readonly type: "address";
        }];
        readonly name: "updateComputeEngine";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "newMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "updateMaxTimeout";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newTeePoolFactory";
            readonly type: "address";
        }];
        readonly name: "updateTeePoolFactory";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly TeePoolDedicatedGpu: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "HWRequirementNotMet";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "MaxTimeoutExceeded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teePoolAddress";
            readonly type: "address";
        }];
        readonly name: "NoActiveTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotComputeEngine";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotTeePoolFactory";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeeAlreadyAdded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeNotActive";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "newHardwareType";
            readonly type: "uint8";
        }];
        readonly name: "HardwareTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "JobSubmitted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "publicKey";
            readonly type: "string";
        }];
        readonly name: "TeeAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "newTeePoolType";
            readonly type: "uint8";
        }];
        readonly name: "TeePoolTypeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "activeTeeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "addTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "computeEngine";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "hardwareType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initComputeEngine";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initTeePoolFactory";
            readonly type: "address";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "initTeePoolType";
            readonly type: "uint8";
        }, {
            readonly internalType: "enum IComputeEngineTeePool.HardwareType";
            readonly name: "initHardwareType";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint80";
            readonly name: "initMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "isTee";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "maxTimeout";
        readonly outputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "";
            readonly type: "uint80";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "removeJob";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "removeTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes";
            readonly name: "params";
            readonly type: "bytes";
        }];
        readonly name: "submitJob";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "";
            readonly type: "bytes";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "teeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolFactory";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePoolType";
        readonly outputs: readonly [{
            readonly internalType: "enum IComputeEngineTeePool.TeePoolType";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "tees";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum IComputeEngineTeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct IComputeEngineTeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newComputeEngine";
            readonly type: "address";
        }];
        readonly name: "updateComputeEngine";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint80";
            readonly name: "newMaxTimeout";
            readonly type: "uint80";
        }];
        readonly name: "updateMaxTimeout";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newTeePoolFactory";
            readonly type: "address";
        }];
        readonly name: "updateTeePoolFactory";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly VanaEpoch: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EpochAlreadyFinalized";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EpochNotEnded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "totalRewardAmount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "epochRewardAmount";
            readonly type: "uint256";
        }];
        readonly name: "EpochRewardExceeded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EpochRewardNotDistributed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidEpoch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "startBlock";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "endBlock";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "rewardAmount";
            readonly type: "uint256";
        }];
        readonly name: "EpochCreated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newDaySize";
            readonly type: "uint256";
        }];
        readonly name: "EpochDayUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "rewardAmount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "penaltyAmount";
            readonly type: "uint256";
        }];
        readonly name: "EpochDlpRewardAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "rewardAmount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "penaltyAmount";
            readonly type: "uint256";
        }];
        readonly name: "EpochDlpRewardOverridden";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }];
        readonly name: "EpochFinalized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newEpochRewardAmount";
            readonly type: "uint256";
        }];
        readonly name: "EpochRewardAmountUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newEpochSize";
            readonly type: "uint256";
        }];
        readonly name: "EpochSizeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "startBlock";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "endBlock";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "rewardAmount";
            readonly type: "uint256";
        }];
        readonly name: "EpochUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLP_PERFORMANCE_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "createEpochs";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "blockNumber";
            readonly type: "uint256";
        }];
        readonly name: "createEpochsUntilBlockNumber";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "daySize";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpPerformance";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPPerformance";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRewardDeployer";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRewardDeployer";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }];
        readonly name: "epochDlpIds";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "epochDlps";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "bool";
                readonly name: "isTopDlp";
                readonly type: "bool";
            }, {
                readonly internalType: "uint256";
                readonly name: "rewardAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "penaltyAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "distributedAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IVanaEpoch.EpochDlpInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "epochRewardAmount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "epochSize";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }];
        readonly name: "epochs";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "startBlock";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "endBlock";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "rewardAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "bool";
                readonly name: "isFinalized";
                readonly type: "bool";
            }];
            readonly internalType: "struct IVanaEpoch.EpochInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "epochsCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }];
        readonly name: "forceFinalizedEpoch";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "dlpRegistryAddress";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "daySize";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "epochSize";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "epochRewardAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct VanaEpochImplementation.InitializeParams";
            readonly name: "params";
            readonly type: "tuple";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "rewardAmount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "penaltyAmount";
            readonly type: "uint256";
        }];
        readonly name: "overrideEpochDlpReward";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "dlpId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "rewardAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "penaltyAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IVanaEpoch.Rewards[]";
            readonly name: "dlpRewards";
            readonly type: "tuple[]";
        }];
        readonly name: "saveEpochDlpRewards";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newDaySize";
            readonly type: "uint256";
        }];
        readonly name: "updateDaySize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "dlpPerformanceAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpPerformance";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "dlpRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "dlpRewardDeployerAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRewardDeployer";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "startBlock";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "endBlock";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "rewardAmount";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "dlpId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "rewardAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "penaltyAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IVanaEpoch.Rewards[]";
            readonly name: "dlpRewards";
            readonly type: "tuple[]";
        }, {
            readonly internalType: "bool";
            readonly name: "isFinalized";
            readonly type: "bool";
        }];
        readonly name: "updateEpoch";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newEpochRewardAmount";
            readonly type: "uint256";
        }];
        readonly name: "updateEpochRewardAmount";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newEpochSizeInDays";
            readonly type: "uint256";
        }];
        readonly name: "updateEpochSize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newEpochsCount";
            readonly type: "uint256";
        }];
        readonly name: "updateEpochsCount";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly DLPRegistry: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DlpAddressCannotBeChanged";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DlpLpTokenIdNotSet";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DlpTokenNotSet";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidDepositAmount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidDlpStatus";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidDlpVerification";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidLpTokenId";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidName";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidTokenAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "LastEpochMustBeFinalized";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotDlpOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TransferFailed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "lpTokenId";
            readonly type: "uint256";
        }];
        readonly name: "DlpLpTokenIdUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "dlpAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "treasuryAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "iconUrl";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "website";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "metadata";
            readonly type: "string";
        }];
        readonly name: "DlpRegistered";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newDlpRegistrationDepositAmount";
            readonly type: "uint256";
        }];
        readonly name: "DlpRegistrationDepositAmountUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "enum IDLPRegistry.DlpStatus";
            readonly name: "newStatus";
            readonly type: "uint8";
        }];
        readonly name: "DlpStatusUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "tokenAddress";
            readonly type: "address";
        }];
        readonly name: "DlpTokenUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "dlpAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "treasuryAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "iconUrl";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "website";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "metadata";
            readonly type: "string";
        }];
        readonly name: "DlpUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "verificationBlockNumber";
            readonly type: "uint256";
        }];
        readonly name: "DlpVerificationBlockUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "bool";
            readonly name: "verified";
            readonly type: "bool";
        }];
        readonly name: "DlpVerificationUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "deregisterDlp";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "dlpAddress";
            readonly type: "address";
        }];
        readonly name: "dlpIds";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "dlpName";
            readonly type: "string";
        }];
        readonly name: "dlpNameToId";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRegistrationDepositAmount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "dlps";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "id";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "dlpAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "tokenAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "treasuryAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "iconUrl";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "website";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "metadata";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "registrationBlockNumber";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "depositAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "enum IDLPRegistry.DlpStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "lpTokenId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "verificationBlockNumber";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPRegistry.DlpInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "dlpAddress";
            readonly type: "address";
        }];
        readonly name: "dlpsByAddress";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "id";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "dlpAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "tokenAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "treasuryAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "iconUrl";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "website";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "metadata";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "registrationBlockNumber";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "depositAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "enum IDLPRegistry.DlpStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "lpTokenId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "verificationBlockNumber";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPRegistry.DlpInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "dlpName";
            readonly type: "string";
        }];
        readonly name: "dlpsByName";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "id";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "dlpAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "tokenAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "treasuryAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "iconUrl";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "website";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "metadata";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "registrationBlockNumber";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "depositAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "enum IDLPRegistry.DlpStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "lpTokenId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "verificationBlockNumber";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPRegistry.DlpInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpsCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "eligibleDlpsListAt";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "eligibleDlpsListCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "eligibleDlpsListValues";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "isEligibleDlp";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "dlpRootCoreAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "startDlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "endDlpId";
            readonly type: "uint256";
        }];
        readonly name: "migrateDlpData";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "dlpAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address payable";
                readonly name: "treasuryAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "iconUrl";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "website";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "metadata";
                readonly type: "string";
            }];
            readonly internalType: "struct IDLPRegistry.DlpRegistration";
            readonly name: "registrationInfo";
            readonly type: "tuple";
        }];
        readonly name: "registerDlp";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "treasury";
        readonly outputs: readonly [{
            readonly internalType: "contract ITreasury";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "unverifyDlp";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "dlpAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address payable";
                readonly name: "treasuryAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "iconUrl";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "website";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "metadata";
                readonly type: "string";
            }];
            readonly internalType: "struct IDLPRegistry.DlpRegistration";
            readonly name: "dlpUpdateInfo";
            readonly type: "tuple";
        }];
        readonly name: "updateDlp";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newDlpRegistrationDepositAmount";
            readonly type: "uint256";
        }];
        readonly name: "updateDlpRegistrationDepositAmount";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "tokenAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "lpTokenId";
            readonly type: "uint256";
        }];
        readonly name: "updateDlpToken";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "tokenAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "lpTokenId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "verificationBlockNumber";
            readonly type: "uint256";
        }];
        readonly name: "updateDlpTokenAndVerification";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "verificationBlockNumber";
            readonly type: "uint256";
        }];
        readonly name: "updateDlpVerificationBlock";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "treasuryAddress";
            readonly type: "address";
        }];
        readonly name: "updateTreasury";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "vanaEpochAddress";
            readonly type: "address";
        }];
        readonly name: "updateVanaEpoch";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "vanaEpoch";
        readonly outputs: readonly [{
            readonly internalType: "contract IVanaEpoch";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly DLPRegistryTreasury: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "AddressInsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "SafeERC20FailedOperation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAmount";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "Transfer";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "CUSTODIAN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "VANA";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "custodian";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initCustodian";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "transfer";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newCustodian";
            readonly type: "address";
        }];
        readonly name: "updateCustodian";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly stateMutability: "payable";
        readonly type: "receive";
    }];
    readonly DLPRewardDeployerTreasury: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "AddressInsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "SafeERC20FailedOperation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAmount";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "Transfer";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "CUSTODIAN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "VANA";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "custodian";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initCustodian";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "transfer";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newCustodian";
            readonly type: "address";
        }];
        readonly name: "updateCustodian";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly stateMutability: "payable";
        readonly type: "receive";
    }];
    readonly DLPRegistryTreasuryImplementation: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "AddressInsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "SafeERC20FailedOperation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAmount";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "Transfer";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "CUSTODIAN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "VANA";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "custodian";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initCustodian";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "transfer";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newCustodian";
            readonly type: "address";
        }];
        readonly name: "updateCustodian";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly stateMutability: "payable";
        readonly type: "receive";
    }];
    readonly DLPPerformance: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "DlpNotEligible";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EpochAlreadyFinalized";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EpochNotEnded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EpochNotFinalized";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidDataAccessFeesScore";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidEpochDlpPerformancesCount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidMetricWeights";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidTradingVolumeScore";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidUniqueContributorsScore";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "tradingVolumeScorePenalty";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "uniqueContributorsScorePenalty";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "dataAccessFeesScorePenalty";
            readonly type: "uint256";
        }];
        readonly name: "EpochDlpPenaltyUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "tradingVolume";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "uniqueContributors";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "dataAccessFees";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "tradingVolumeScore";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "uniqueContributorsScore";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "dataAccessFeesScore";
            readonly type: "uint256";
        }];
        readonly name: "EpochDlpPerformancesOverridden";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "tradingVolume";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "uniqueContributors";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "dataAccessFees";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "tradingVolumeScore";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "uniqueContributorsScore";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "dataAccessFeesScore";
            readonly type: "uint256";
        }];
        readonly name: "EpochDlpPerformancesSaved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "tradingVolume";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "uniqueContributors";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "dataAccessFees";
            readonly type: "uint256";
        }];
        readonly name: "MetricWeightsUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MANAGER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "calculateEpochDlpRewards";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "rewardAmount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "penaltyAmount";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }];
        readonly name: "confirmEpochFinalScores";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "epochDlpPerformances";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "totalScore";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "tradingVolume";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributors";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFees";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "tradingVolumeScore";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributorsScore";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFeesScore";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "tradingVolumeScorePenalty";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributorsScorePenalty";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFeesScorePenalty";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPPerformance.EpochDlpPerformanceInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }];
        readonly name: "epochMetricWeights";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "tradingVolume";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributors";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFees";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPPerformance.MetricWeights";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "dlpRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "metricWeights";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "tradingVolume";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributors";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFees";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPPerformance.MetricWeights";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "tradingVolumeScorePenalty";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "uniqueContributorsScorePenalty";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dataAccessFeesScorePenalty";
            readonly type: "uint256";
        }];
        readonly name: "overrideEpochDlpPenalty";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "overrideEpochDlpReward";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "dlpId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "tradingVolume";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributors";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFees";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "tradingVolumeScore";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributorsScore";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFeesScore";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPPerformance.EpochDlpPerformanceInput[]";
            readonly name: "newEpochDlpPerformances";
            readonly type: "tuple[]";
        }];
        readonly name: "overrideEpochPerformances";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "dlpId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "tradingVolume";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributors";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFees";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "tradingVolumeScore";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributorsScore";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFeesScore";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPPerformance.EpochDlpPerformanceInput[]";
            readonly name: "newEpochDlpPerformances";
            readonly type: "tuple[]";
        }];
        readonly name: "saveEpochPerformances";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "dlpRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "tradingVolume";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "uniqueContributors";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "dataAccessFees";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPPerformance.MetricWeights";
            readonly name: "newMetricWeights";
            readonly type: "tuple";
        }];
        readonly name: "updateMetricWeights";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "vanaEpochAddress";
            readonly type: "address";
        }];
        readonly name: "updateVanaEpoch";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "vanaEpoch";
        readonly outputs: readonly [{
            readonly internalType: "contract IVanaEpoch";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly DLPRewardDeployer: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EpochNotFinalized";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "NothingToDistribute";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NothingToWithdraw";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "distributedAmount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "totalPenaltyAmount";
            readonly type: "uint256";
        }];
        readonly name: "EpochDlpPenaltyDistributed";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "trancheId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "trancheAmount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "tokenRewardAmount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "spareToken";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "spareVana";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "usedVanaAmount";
            readonly type: "uint256";
        }];
        readonly name: "EpochDlpRewardDistributed";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "REWARD_DEPLOYER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256[]";
            readonly name: "dlpIds";
            readonly type: "uint256[]";
        }];
        readonly name: "distributeRewards";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRewardSwap";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRewardSwap";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "epochDlpDistributedRewards";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "blockNumber";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "tokenRewardAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "spareToken";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "spareVana";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "usedVanaAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPRewardDeployer.DistributedReward[]";
            readonly name: "";
            readonly type: "tuple[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "epochDlpRewards";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "totalDistributedAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "tranchesCount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPRewardDeployer.EpochDlpRewardInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "dlpRegistryAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "vanaEpochAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "dlpRewardSwapAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "newNumberOfTranches";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "newRewardPercentage";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "newMaximumSlippagePercentage";
            readonly type: "uint256";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "maximumSlippagePercentage";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "numberOfTranches";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "rewardPercentage";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "treasury";
        readonly outputs: readonly [{
            readonly internalType: "contract ITreasury";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "dlpRegistryAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "dlpRewardSwapAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRewardSwap";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newMaximumSlippagePercentage";
            readonly type: "uint256";
        }];
        readonly name: "updateMaximumSlippagePercentage";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newRewardPercentage";
            readonly type: "uint256";
        }];
        readonly name: "updateRewardPercentage";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "treasuryAddress";
            readonly type: "address";
        }];
        readonly name: "updateTreasury";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "vanaEpochAddress";
            readonly type: "address";
        }];
        readonly name: "updateVanaEpoch";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "vanaEpoch";
        readonly outputs: readonly [{
            readonly internalType: "contract IVanaEpoch";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "recipientAddress";
            readonly type: "address";
        }];
        readonly name: "withdrawEpochDlpPenaltyAmount";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly stateMutability: "payable";
        readonly type: "receive";
    }];
    readonly DLPRewardSwap: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "AddressInsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "amountIn";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "used";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "spareVana";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "unusedVana";
            readonly type: "uint256";
        }];
        readonly name: "DLPRewardSwap__AmountMismatch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "expected";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "actual";
            readonly type: "uint256";
        }];
        readonly name: "DLPRewardSwap__InsufficientAmount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLPRewardSwap__InvalidLpTokenId";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLPRewardSwap__InvalidRange";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLPRewardSwap__InvalidRewardPercentage";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLPRewardSwap__InvalidSlippagePercentage";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLPRewardSwap__LPAmountMismatch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint128";
            readonly name: "expected";
            readonly type: "uint128";
        }, {
            readonly internalType: "uint128";
            readonly name: "actual";
            readonly type: "uint128";
        }];
        readonly name: "DLPRewardSwap__LiquidityMismatch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "expected";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "actual";
            readonly type: "uint256";
        }];
        readonly name: "DLPRewardSwap__SpareAmountMismatch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "expected";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "actual";
            readonly type: "uint256";
        }];
        readonly name: "DLPRewardSwap__VanaInMismatch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLPRewardSwap__ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLPRewardSwap__ZeroAmount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLPRewardSwap__ZeroAmountSwapIn";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "DLPRewardSwap__ZeroLiquidity";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "SafeERC20FailedOperation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "T";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "recipient";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "usedVanaForReward";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "tokenRewardAmount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "usedVanaForLp";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "liquidityDelta";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "spareVana";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "spareToken";
            readonly type: "uint256";
        }];
        readonly name: "Reward";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "ONE_HUNDRED_PERCENT";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "VANA";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "contract ISwapHelper";
            readonly name: "initSwapHelper";
            readonly type: "address";
        }, {
            readonly internalType: "contract INonfungiblePositionManager";
            readonly name: "initPositionManager";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "positionManager";
        readonly outputs: readonly [{
            readonly internalType: "contract INonfungiblePositionManager";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "amountIn";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "lpTokenId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "rewardPercentage";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "maximumSlippagePercentage";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPRewardSwap.QuoteSplitRewardSwapParams";
            readonly name: "params";
            readonly type: "tuple";
        }];
        readonly name: "quoteSplitRewardSwap";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "tokenRewardAmount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "spareToken";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "spareVana";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "usedVanaAmount";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "lpTokenId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "rewardPercentage";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "maximumSlippagePercentage";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "rewardRecipient";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "spareRecipient";
                readonly type: "address";
            }];
            readonly internalType: "struct IDLPRewardSwap.SplitRewardSwapParams";
            readonly name: "params";
            readonly type: "tuple";
        }];
        readonly name: "splitRewardSwap";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "tokenRewardAmount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "spareToken";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "spareVana";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "usedVanaAmount";
            readonly type: "uint256";
        }];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "swapHelper";
        readonly outputs: readonly [{
            readonly internalType: "contract ISwapHelper";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract INonfungiblePositionManager";
            readonly name: "newPositionManager";
            readonly type: "address";
        }];
        readonly name: "updatePositionManager";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract ISwapHelper";
            readonly name: "newSwapHelper";
            readonly type: "address";
        }];
        readonly name: "updateSwapHelper";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly stateMutability: "payable";
        readonly type: "receive";
    }];
    readonly SwapHelper: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "AddressInsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "MathOverflowedMulDiv";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "R";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint8";
            readonly name: "bits";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "SafeCastOverflowedUintDowncast";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "SafeCastOverflowedUintToInt";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "SafeERC20FailedOperation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "SwapHelper__InvalidAmountIn";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "SwapHelper__InvalidSlippagePercentage";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "SwapHelper__ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "T";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "Uniswap__AS";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "Uniswap__SPL";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "recipient";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "tokenIn";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amountIn";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "tokenOut";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amountOut";
            readonly type: "uint256";
        }];
        readonly name: "Swap";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "ONE_HUNDRED_PERCENT";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "VANA";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "WVANA";
        readonly outputs: readonly [{
            readonly internalType: "contract IWVANA";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "tokenIn";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "tokenOut";
                readonly type: "address";
            }, {
                readonly internalType: "uint24";
                readonly name: "fee";
                readonly type: "uint24";
            }, {
                readonly internalType: "address";
                readonly name: "recipient";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "amountIn";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "amountOutMinimum";
                readonly type: "uint256";
            }];
            readonly internalType: "struct ISwapHelper.ExactInputSingleParams";
            readonly name: "params";
            readonly type: "tuple";
        }];
        readonly name: "exactInputSingle";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "amountOut";
            readonly type: "uint256";
        }];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "tokenA";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "tokenB";
            readonly type: "address";
        }, {
            readonly internalType: "uint24";
            readonly name: "fee";
            readonly type: "uint24";
        }];
        readonly name: "getPool";
        readonly outputs: readonly [{
            readonly internalType: "contract IUniswapV3Pool";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "initUniswapV3Router";
            readonly type: "address";
        }, {
            readonly internalType: "contract IQuoterV2";
            readonly name: "initUniswapV3Quoter";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "tokenIn";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "tokenOut";
                readonly type: "address";
            }, {
                readonly internalType: "uint24";
                readonly name: "fee";
                readonly type: "uint24";
            }, {
                readonly internalType: "uint256";
                readonly name: "amountIn";
                readonly type: "uint256";
            }];
            readonly internalType: "struct ISwapHelper.QuoteExactInputSingleParams";
            readonly name: "params";
            readonly type: "tuple";
        }];
        readonly name: "quoteExactInputSingle";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "amountOut";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "tokenIn";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "tokenOut";
                readonly type: "address";
            }, {
                readonly internalType: "uint24";
                readonly name: "fee";
                readonly type: "uint24";
            }, {
                readonly internalType: "uint256";
                readonly name: "amountIn";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint160";
                readonly name: "sqrtPriceX96";
                readonly type: "uint160";
            }, {
                readonly internalType: "uint128";
                readonly name: "liquidity";
                readonly type: "uint128";
            }, {
                readonly internalType: "uint256";
                readonly name: "maximumSlippagePercentage";
                readonly type: "uint256";
            }];
            readonly internalType: "struct ISwapHelper.QuoteSlippageExactInputSingleParams";
            readonly name: "params";
            readonly type: "tuple";
        }];
        readonly name: "quoteSlippageExactInputSingle";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "int256";
                readonly name: "amount0Delta";
                readonly type: "int256";
            }, {
                readonly internalType: "int256";
                readonly name: "amount1Delta";
                readonly type: "int256";
            }, {
                readonly internalType: "uint256";
                readonly name: "amountToPay";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "amountReceived";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint160";
                readonly name: "sqrtPriceX96After";
                readonly type: "uint160";
            }, {
                readonly internalType: "uint160";
                readonly name: "sqrtPriceLimitX96";
                readonly type: "uint160";
            }];
            readonly internalType: "struct ISwapHelper.Quote";
            readonly name: "quote";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IUniswapV3Pool";
            readonly name: "pool";
            readonly type: "address";
        }, {
            readonly internalType: "bool";
            readonly name: "zeroForOne";
            readonly type: "bool";
        }, {
            readonly internalType: "int256";
            readonly name: "amountSpecified";
            readonly type: "int256";
        }, {
            readonly internalType: "uint160";
            readonly name: "sqrtPriceLimitX96";
            readonly type: "uint160";
        }, {
            readonly components: readonly [{
                readonly internalType: "uint160";
                readonly name: "sqrtPriceX96";
                readonly type: "uint160";
            }, {
                readonly internalType: "int24";
                readonly name: "tick";
                readonly type: "int24";
            }, {
                readonly internalType: "uint128";
                readonly name: "liquidity";
                readonly type: "uint128";
            }];
            readonly internalType: "struct SwapHelperImplementation.Slot0";
            readonly name: "slot0Start";
            readonly type: "tuple";
        }];
        readonly name: "simulateSwap";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "int256";
                readonly name: "amount0Delta";
                readonly type: "int256";
            }, {
                readonly internalType: "int256";
                readonly name: "amount1Delta";
                readonly type: "int256";
            }, {
                readonly internalType: "uint256";
                readonly name: "amountToPay";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "amountReceived";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint160";
                readonly name: "sqrtPriceX96After";
                readonly type: "uint160";
            }, {
                readonly internalType: "uint160";
                readonly name: "sqrtPriceLimitX96";
                readonly type: "uint160";
            }];
            readonly internalType: "struct ISwapHelper.Quote";
            readonly name: "quote";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "tokenIn";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "tokenOut";
                readonly type: "address";
            }, {
                readonly internalType: "uint24";
                readonly name: "fee";
                readonly type: "uint24";
            }, {
                readonly internalType: "address";
                readonly name: "recipient";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "amountIn";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "maximumSlippagePercentage";
                readonly type: "uint256";
            }];
            readonly internalType: "struct ISwapHelper.SlippageSwapParams";
            readonly name: "params";
            readonly type: "tuple";
        }];
        readonly name: "slippageExactInputSingle";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "amountInUsed";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "amountOut";
            readonly type: "uint256";
        }];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "uniswapV3Quoter";
        readonly outputs: readonly [{
            readonly internalType: "contract IQuoterV2";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "uniswapV3Router";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IQuoterV2";
            readonly name: "newUniswapV3Quoter";
            readonly type: "address";
        }];
        readonly name: "updateUniswapV3Quoter";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newUniswapV3Router";
            readonly type: "address";
        }];
        readonly name: "updateUniswapV3Router";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly stateMutability: "payable";
        readonly type: "receive";
    }];
    readonly DataLiquidityPool: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "AddressInsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ECDSAInvalidSignature";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "length";
            readonly type: "uint256";
        }];
        readonly name: "ECDSAInvalidSignatureLength";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "s";
            readonly type: "bytes32";
        }];
        readonly name: "ECDSAInvalidSignatureS";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FileAlreadyAdded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidAttestator";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidProof";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }];
        readonly name: "OwnableInvalidOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "OwnableUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }];
        readonly name: "SafeERC20FailedOperation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "FileInvalidated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newFileRewardFactor";
            readonly type: "uint256";
        }];
        readonly name: "FileRewardFactorUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "FileValidated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "previousOwner";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "newOwner";
            readonly type: "address";
        }];
        readonly name: "OwnershipTransferStarted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "previousOwner";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "newOwner";
            readonly type: "address";
        }];
        readonly name: "OwnershipTransferred";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "newProofInstruction";
            readonly type: "string";
        }];
        readonly name: "ProofInstructionUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "newPublicKey";
            readonly type: "string";
        }];
        readonly name: "PublicKeyUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "contributorAddress";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "proofIndex";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "rewardAmount";
            readonly type: "uint256";
        }];
        readonly name: "RewardRequested";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "newTeePool";
            readonly type: "address";
        }];
        readonly name: "TeePoolUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "acceptOwnership";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "contributorsRewardAmount";
            readonly type: "uint256";
        }];
        readonly name: "addRewardsForContributors";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "contributorAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "contributorFiles";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "fileId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "timestamp";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "proofIndex";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "rewardAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDataLiquidityPool.FileResponse";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "contributorAddress";
            readonly type: "address";
        }];
        readonly name: "contributorInfo";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "contributorAddress";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "filesListCount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDataLiquidityPool.ContributorInfoResponse";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "contributors";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "contributorAddress";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "filesListCount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDataLiquidityPool.ContributorInfoResponse";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "contributorsCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dataRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDataRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "fileRewardFactor";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "files";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "fileId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "timestamp";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "proofIndex";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "rewardAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDataLiquidityPool.FileResponse";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "filesListAt";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "filesListCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "tokenAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "dataRegistryAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "teePoolAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "proofInstruction";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "fileRewardFactor";
                readonly type: "uint256";
            }];
            readonly internalType: "struct DataLiquidityPoolImplementation.InitParams";
            readonly name: "params";
            readonly type: "tuple";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "data";
            readonly type: "bytes[]";
        }];
        readonly name: "multicall";
        readonly outputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "results";
            readonly type: "bytes[]";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "name";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "owner";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pendingOwner";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proofInstruction";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "publicKey";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "renounceOwnership";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "proofIndex";
            readonly type: "uint256";
        }];
        readonly name: "requestReward";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teePool";
        readonly outputs: readonly [{
            readonly internalType: "contract ITeePool";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "token";
        readonly outputs: readonly [{
            readonly internalType: "contract IERC20";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "totalContributorsRewardAmount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newOwner";
            readonly type: "address";
        }];
        readonly name: "transferOwnership";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newFileRewardFactor";
            readonly type: "uint256";
        }];
        readonly name: "updateFileRewardFactor";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "newProofInstruction";
            readonly type: "string";
        }];
        readonly name: "updateProofInstruction";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "newPublicKey";
            readonly type: "string";
        }];
        readonly name: "updatePublicKey";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newTeePool";
            readonly type: "address";
        }];
        readonly name: "updateTeePool";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly VanaPoolStaking: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "CannotRemoveRegistrationStake";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EntityNotActive";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EntityNotFound";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InsufficientShares";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InsufficientStakeAmount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidAmount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidEntity";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidRecipient";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidSlippage";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotAuthorized";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotEntityOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TransferFailed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }];
        readonly name: "EntityStakeRegistered";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newMinStake";
            readonly type: "uint256";
        }];
        readonly name: "MinStakeUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "staker";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "sharesIssued";
            readonly type: "uint256";
        }];
        readonly name: "Staked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "staker";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "sharesBurned";
            readonly type: "uint256";
        }];
        readonly name: "Unstaked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "VANA_POOL_ENTITY";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "initialMinStake";
            readonly type: "uint256";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "forwarder";
            readonly type: "address";
        }];
        readonly name: "isTrustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "minStakeAmount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "data";
            readonly type: "bytes[]";
        }];
        readonly name: "multicall";
        readonly outputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "results";
            readonly type: "bytes[]";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "registrationStake";
            readonly type: "uint256";
        }];
        readonly name: "registerEntityStake";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "recipient";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "shareAmountMin";
            readonly type: "uint256";
        }];
        readonly name: "stake";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "staker";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "stakerEntities";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "shares";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IVanaPoolStaking.StakerEntity";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "trustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "shareAmount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "vanaAmountMin";
            readonly type: "uint256";
        }];
        readonly name: "unstake";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newMinStake";
            readonly type: "uint256";
        }];
        readonly name: "updateMinStakeAmount";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }];
        readonly name: "updateTrustedForwarder";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newVanaPoolEntityAddress";
            readonly type: "address";
        }];
        readonly name: "updateVanaPoolEntity";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newVanaPoolTreasuryAddress";
            readonly type: "address";
        }];
        readonly name: "updateVanaPoolTreasury";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "vanaPoolEntity";
        readonly outputs: readonly [{
            readonly internalType: "contract IVanaPoolEntity";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "vanaPoolTreasury";
        readonly outputs: readonly [{
            readonly internalType: "contract IVanaPoolTreasury";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly VanaPoolEntity: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EntityNameAlreadyExists";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidEntityId";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidEntityStatus";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidName";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidParam";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidRegistrationStake";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NameTooShort";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotAuthorized";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotEntityOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "StakersStillPresent";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TransferFailed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "maxAPY";
            readonly type: "uint256";
        }];
        readonly name: "EntityCreated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newMaxAPY";
            readonly type: "uint256";
        }];
        readonly name: "EntityMaxAPYUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "enum IVanaPoolEntity.EntityStatus";
            readonly name: "newStatus";
            readonly type: "uint8";
        }];
        readonly name: "EntityStatusUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }];
        readonly name: "EntityUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "RewardsAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "distributedAmount";
            readonly type: "uint256";
        }];
        readonly name: "RewardsProcessed";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "VANA_POOL_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "exponent";
            readonly type: "uint256";
        }];
        readonly name: "_calculateExponential";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "r";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeEntitiesValues";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "addRewards";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "calculateContinuousAPYByEntity";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "apy";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "principal";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "time";
            readonly type: "uint256";
        }];
        readonly name: "calculateContinuousCompoundingYield";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }];
            readonly internalType: "struct IVanaPoolEntity.EntityRegistrationInfo";
            readonly name: "entityRegistrationInfo";
            readonly type: "tuple";
        }];
        readonly name: "createEntity";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "entities";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "entityId";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "enum IVanaPoolEntity.EntityStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "maxAPY";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "lockedRewardPool";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "activeRewardPool";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "totalShares";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "lastUpdateTimestamp";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IVanaPoolEntity.EntityInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "entitiesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "entityName";
            readonly type: "string";
        }];
        readonly name: "entityByName";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "entityId";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "enum IVanaPoolEntity.EntityStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "uint256";
                readonly name: "maxAPY";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "lockedRewardPool";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "activeRewardPool";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "totalShares";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "lastUpdateTimestamp";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IVanaPoolEntity.EntityInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "entityName";
            readonly type: "string";
        }];
        readonly name: "entityNameToId";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "entityShareToVana";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "vanaPoolStakingAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "initialMinRegistrationStake";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "initialMaxAPYDefault";
            readonly type: "uint256";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "maxAPYDefault";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "minRegistrationStake";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly internalType: "uint256";
            readonly name: "maxAPY";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "lockedRewardPool";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "activeRewardPool";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "totalShares";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "lastUpdateTimestamp";
            readonly type: "uint256";
        }];
        readonly name: "overrideEntity";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "processRewards";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }];
            readonly internalType: "struct IVanaPoolEntity.EntityRegistrationInfo";
            readonly name: "entityRegistrationInfo";
            readonly type: "tuple";
        }];
        readonly name: "updateEntity";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "newMaxAPY";
            readonly type: "uint256";
        }];
        readonly name: "updateEntityMaxAPY";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "shares";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly internalType: "bool";
            readonly name: "isStake";
            readonly type: "bool";
        }];
        readonly name: "updateEntityPool";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newMinRegistrationStake";
            readonly type: "uint256";
        }];
        readonly name: "updateMinRegistrationStake";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newVanaPoolStakingAddress";
            readonly type: "address";
        }];
        readonly name: "updateVanaPool";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "vanaPoolStaking";
        readonly outputs: readonly [{
            readonly internalType: "contract IVanaPoolStaking";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "vanaToEntityShare";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
    readonly VanaPoolTreasury: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "vanaPoolAddress";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address payable";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "transferVana";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "vanaPoolAddress";
            readonly type: "address";
        }];
        readonly name: "updateVanaPool";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "vanaPool";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly stateMutability: "payable";
        readonly type: "receive";
    }];
    readonly DAT: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccountBlocked";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "length1";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "length2";
            readonly type: "uint256";
        }];
        readonly name: "ArrayLengthMismatch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "BlockListDoesNotContain";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }, {
            readonly internalType: "string";
            readonly name: "reason";
            readonly type: "string";
        }];
        readonly name: "BlockingRejected";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "increasedSupply";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "ERC20ExceededCap";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "allowance";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "needed";
            readonly type: "uint256";
        }];
        readonly name: "ERC20InsufficientAllowance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "balance";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "needed";
            readonly type: "uint256";
        }];
        readonly name: "ERC20InsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "approver";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidApprover";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "ERC20InvalidCap";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "receiver";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidReceiver";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidSender";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidSpender";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "paramName";
            readonly type: "string";
        }];
        readonly name: "EmptyString";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "length";
            readonly type: "uint256";
        }];
        readonly name: "IndexOutOfBounds";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAmount";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly name: "AddressBlocked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly name: "AddressUnblocked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "Approval";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "from";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "Transfer";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MINTER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }];
        readonly name: "allowance";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "approve";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "balanceOf";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "blockAddress";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "i";
            readonly type: "uint256";
        }];
        readonly name: "blockListAt";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "blockListLength";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "burn";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "burnFrom";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "cap";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "decimals";
        readonly outputs: readonly [{
            readonly internalType: "uint8";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "name_";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "symbol_";
            readonly type: "string";
        }, {
            readonly internalType: "address";
            readonly name: "owner_";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "cap_";
            readonly type: "uint256";
        }, {
            readonly internalType: "address[]";
            readonly name: "receivers";
            readonly type: "address[]";
        }, {
            readonly internalType: "uint256[]";
            readonly name: "amounts";
            readonly type: "uint256[]";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "isBlocked";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "mint";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "name";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "id";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "symbol";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "templateName";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "totalSupply";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "transfer";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "from";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "transferFrom";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "unblockAddress";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }];
    readonly DATFactory: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "CapTooLow";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint64";
            readonly name: "duration";
            readonly type: "uint64";
        }, {
            readonly internalType: "uint64";
            readonly name: "cliff";
            readonly type: "uint64";
        }];
        readonly name: "DurationTooShort";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1167FailedCreateClone";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "total";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "ExceedsCap";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExcessiveCap";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "enum IDATFactory.DATType";
            readonly name: "datType";
            readonly type: "uint8";
        }];
        readonly name: "InvalidDATType";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidDefaultCap";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint64";
            readonly name: "start";
            readonly type: "uint64";
        }, {
            readonly internalType: "uint64";
            readonly name: "cliff";
            readonly type: "uint64";
        }];
        readonly name: "StartTimeOverflow";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAmount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroDuration";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroSalt";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroStartTime";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "salt";
            readonly type: "bytes32";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "symbol";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "DATCreated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "wallet";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "beneficiary";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "start";
            readonly type: "uint64";
        }, {
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "cliff";
            readonly type: "uint64";
        }, {
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "duration";
            readonly type: "uint64";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "VestingWalletCreated";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "enum IDATFactory.DATType";
                readonly name: "datType";
                readonly type: "uint8";
            }, {
                readonly internalType: "string";
                readonly name: "name";
                readonly type: "string";
            }, {
                readonly internalType: "string";
                readonly name: "symbol";
                readonly type: "string";
            }, {
                readonly internalType: "address";
                readonly name: "owner";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "cap";
                readonly type: "uint256";
            }, {
                readonly components: readonly [{
                    readonly internalType: "address";
                    readonly name: "beneficiary";
                    readonly type: "address";
                }, {
                    readonly internalType: "uint64";
                    readonly name: "start";
                    readonly type: "uint64";
                }, {
                    readonly internalType: "uint64";
                    readonly name: "cliff";
                    readonly type: "uint64";
                }, {
                    readonly internalType: "uint64";
                    readonly name: "duration";
                    readonly type: "uint64";
                }, {
                    readonly internalType: "uint256";
                    readonly name: "amount";
                    readonly type: "uint256";
                }];
                readonly internalType: "struct IDATFactory.VestingParams[]";
                readonly name: "schedules";
                readonly type: "tuple[]";
            }, {
                readonly internalType: "bytes32";
                readonly name: "salt";
                readonly type: "bytes32";
            }];
            readonly internalType: "struct IDATFactory.CreateTokenParams";
            readonly name: "params";
            readonly type: "tuple";
        }];
        readonly name: "createToken";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "tokenAddr";
            readonly type: "address";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "datListAt";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "datListCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "datListValues";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "enum IDATFactory.DATType";
            readonly name: "datType";
            readonly type: "uint8";
        }];
        readonly name: "datTemplates";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "templateAddress";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "minCap";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "maxCap";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "datImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "datVotesImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "datPausableImplementation";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "maxCapDefault";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "minCapDefault";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "enum IDATFactory.DATType";
            readonly name: "datType";
            readonly type: "uint8";
        }, {
            readonly internalType: "bytes32";
            readonly name: "salt";
            readonly type: "bytes32";
        }];
        readonly name: "predictAddress";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }];
    readonly DATPausable: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccountBlocked";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "length1";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "length2";
            readonly type: "uint256";
        }];
        readonly name: "ArrayLengthMismatch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "BlockListDoesNotContain";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }, {
            readonly internalType: "string";
            readonly name: "reason";
            readonly type: "string";
        }];
        readonly name: "BlockingRejected";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "CheckpointUnorderedInsertion";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ECDSAInvalidSignature";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "length";
            readonly type: "uint256";
        }];
        readonly name: "ECDSAInvalidSignatureLength";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "s";
            readonly type: "bytes32";
        }];
        readonly name: "ECDSAInvalidSignatureS";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "increasedSupply";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "ERC20ExceededCap";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "increasedSupply";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "ERC20ExceededSafeSupply";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "allowance";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "needed";
            readonly type: "uint256";
        }];
        readonly name: "ERC20InsufficientAllowance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "balance";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "needed";
            readonly type: "uint256";
        }];
        readonly name: "ERC20InsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "approver";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidApprover";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "ERC20InvalidCap";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "receiver";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidReceiver";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidSender";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidSpender";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "deadline";
            readonly type: "uint256";
        }];
        readonly name: "ERC2612ExpiredSignature";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "signer";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }];
        readonly name: "ERC2612InvalidSigner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "timepoint";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint48";
            readonly name: "clock";
            readonly type: "uint48";
        }];
        readonly name: "ERC5805FutureLookup";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC6372InconsistentClock";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "paramName";
            readonly type: "string";
        }];
        readonly name: "EmptyString";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "length";
            readonly type: "uint256";
        }];
        readonly name: "IndexOutOfBounds";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "currentNonce";
            readonly type: "uint256";
        }];
        readonly name: "InvalidAccountNonce";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint8";
            readonly name: "bits";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "SafeCastOverflowedUintDowncast";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "expiry";
            readonly type: "uint256";
        }];
        readonly name: "VotesExpiredSignature";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAmount";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly name: "AddressBlocked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly name: "AddressUnblocked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "Approval";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "delegator";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "fromDelegate";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "toDelegate";
            readonly type: "address";
        }];
        readonly name: "DelegateChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "delegate";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "previousVotes";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newVotes";
            readonly type: "uint256";
        }];
        readonly name: "DelegateVotesChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [];
        readonly name: "EIP712DomainChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "from";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "Transfer";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "CLOCK_MODE";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "DOMAIN_SEPARATOR";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MINTER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }];
        readonly name: "allowance";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "approve";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "balanceOf";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "blockAddress";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "i";
            readonly type: "uint256";
        }];
        readonly name: "blockListAt";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "blockListLength";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "burn";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "burnFrom";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "cap";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "uint32";
            readonly name: "pos";
            readonly type: "uint32";
        }];
        readonly name: "checkpoints";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint48";
                readonly name: "_key";
                readonly type: "uint48";
            }, {
                readonly internalType: "uint208";
                readonly name: "_value";
                readonly type: "uint208";
            }];
            readonly internalType: "struct Checkpoints.Checkpoint208";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "clock";
        readonly outputs: readonly [{
            readonly internalType: "uint48";
            readonly name: "";
            readonly type: "uint48";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "decimals";
        readonly outputs: readonly [{
            readonly internalType: "uint8";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "delegatee";
            readonly type: "address";
        }];
        readonly name: "delegate";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "delegatee";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "nonce";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "expiry";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint8";
            readonly name: "v";
            readonly type: "uint8";
        }, {
            readonly internalType: "bytes32";
            readonly name: "r";
            readonly type: "bytes32";
        }, {
            readonly internalType: "bytes32";
            readonly name: "s";
            readonly type: "bytes32";
        }];
        readonly name: "delegateBySig";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "delegates";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "eip712Domain";
        readonly outputs: readonly [{
            readonly internalType: "bytes1";
            readonly name: "fields";
            readonly type: "bytes1";
        }, {
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "version";
            readonly type: "string";
        }, {
            readonly internalType: "uint256";
            readonly name: "chainId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "verifyingContract";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "salt";
            readonly type: "bytes32";
        }, {
            readonly internalType: "uint256[]";
            readonly name: "extensions";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "timepoint";
            readonly type: "uint256";
        }];
        readonly name: "getPastTotalSupply";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "timepoint";
            readonly type: "uint256";
        }];
        readonly name: "getPastVotes";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "getVotes";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "name_";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "symbol_";
            readonly type: "string";
        }, {
            readonly internalType: "address";
            readonly name: "owner_";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "cap_";
            readonly type: "uint256";
        }, {
            readonly internalType: "address[]";
            readonly name: "receivers";
            readonly type: "address[]";
        }, {
            readonly internalType: "uint256[]";
            readonly name: "amounts";
            readonly type: "uint256[]";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "isBlocked";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "mint";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "name";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }];
        readonly name: "nonces";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "numCheckpoints";
        readonly outputs: readonly [{
            readonly internalType: "uint32";
            readonly name: "";
            readonly type: "uint32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "deadline";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint8";
            readonly name: "v";
            readonly type: "uint8";
        }, {
            readonly internalType: "bytes32";
            readonly name: "r";
            readonly type: "bytes32";
        }, {
            readonly internalType: "bytes32";
            readonly name: "s";
            readonly type: "bytes32";
        }];
        readonly name: "permit";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "id";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "symbol";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "templateName";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "totalSupply";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "transfer";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "from";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "transferFrom";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "unblockAddress";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }];
    readonly DATVotes: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccountBlocked";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "length1";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "length2";
            readonly type: "uint256";
        }];
        readonly name: "ArrayLengthMismatch";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "BlockListDoesNotContain";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }, {
            readonly internalType: "string";
            readonly name: "reason";
            readonly type: "string";
        }];
        readonly name: "BlockingRejected";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "CheckpointUnorderedInsertion";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ECDSAInvalidSignature";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "length";
            readonly type: "uint256";
        }];
        readonly name: "ECDSAInvalidSignatureLength";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "s";
            readonly type: "bytes32";
        }];
        readonly name: "ECDSAInvalidSignatureS";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "increasedSupply";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "ERC20ExceededCap";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "increasedSupply";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "ERC20ExceededSafeSupply";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "allowance";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "needed";
            readonly type: "uint256";
        }];
        readonly name: "ERC20InsufficientAllowance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "balance";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "needed";
            readonly type: "uint256";
        }];
        readonly name: "ERC20InsufficientBalance";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "approver";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidApprover";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "cap";
            readonly type: "uint256";
        }];
        readonly name: "ERC20InvalidCap";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "receiver";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidReceiver";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidSender";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }];
        readonly name: "ERC20InvalidSpender";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "deadline";
            readonly type: "uint256";
        }];
        readonly name: "ERC2612ExpiredSignature";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "signer";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }];
        readonly name: "ERC2612InvalidSigner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "timepoint";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint48";
            readonly name: "clock";
            readonly type: "uint48";
        }];
        readonly name: "ERC5805FutureLookup";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC6372InconsistentClock";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "paramName";
            readonly type: "string";
        }];
        readonly name: "EmptyString";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "length";
            readonly type: "uint256";
        }];
        readonly name: "IndexOutOfBounds";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "currentNonce";
            readonly type: "uint256";
        }];
        readonly name: "InvalidAccountNonce";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint8";
            readonly name: "bits";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "SafeCastOverflowedUintDowncast";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "expiry";
            readonly type: "uint256";
        }];
        readonly name: "VotesExpiredSignature";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ZeroAmount";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly name: "AddressBlocked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly name: "AddressUnblocked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "Approval";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "delegator";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "fromDelegate";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "toDelegate";
            readonly type: "address";
        }];
        readonly name: "DelegateChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "delegate";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "previousVotes";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newVotes";
            readonly type: "uint256";
        }];
        readonly name: "DelegateVotesChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [];
        readonly name: "EIP712DomainChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "from";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "Transfer";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "CLOCK_MODE";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "DOMAIN_SEPARATOR";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MINTER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }];
        readonly name: "allowance";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "approve";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "balanceOf";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "blockAddress";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "i";
            readonly type: "uint256";
        }];
        readonly name: "blockListAt";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "blockListLength";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "burn";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "burnFrom";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "cap";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "uint32";
            readonly name: "pos";
            readonly type: "uint32";
        }];
        readonly name: "checkpoints";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint48";
                readonly name: "_key";
                readonly type: "uint48";
            }, {
                readonly internalType: "uint208";
                readonly name: "_value";
                readonly type: "uint208";
            }];
            readonly internalType: "struct Checkpoints.Checkpoint208";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "clock";
        readonly outputs: readonly [{
            readonly internalType: "uint48";
            readonly name: "";
            readonly type: "uint48";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "decimals";
        readonly outputs: readonly [{
            readonly internalType: "uint8";
            readonly name: "";
            readonly type: "uint8";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "delegatee";
            readonly type: "address";
        }];
        readonly name: "delegate";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "delegatee";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "nonce";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "expiry";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint8";
            readonly name: "v";
            readonly type: "uint8";
        }, {
            readonly internalType: "bytes32";
            readonly name: "r";
            readonly type: "bytes32";
        }, {
            readonly internalType: "bytes32";
            readonly name: "s";
            readonly type: "bytes32";
        }];
        readonly name: "delegateBySig";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "delegates";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "eip712Domain";
        readonly outputs: readonly [{
            readonly internalType: "bytes1";
            readonly name: "fields";
            readonly type: "bytes1";
        }, {
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "version";
            readonly type: "string";
        }, {
            readonly internalType: "uint256";
            readonly name: "chainId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "verifyingContract";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "salt";
            readonly type: "bytes32";
        }, {
            readonly internalType: "uint256[]";
            readonly name: "extensions";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "timepoint";
            readonly type: "uint256";
        }];
        readonly name: "getPastTotalSupply";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "timepoint";
            readonly type: "uint256";
        }];
        readonly name: "getPastVotes";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "getVotes";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "string";
            readonly name: "name_";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "symbol_";
            readonly type: "string";
        }, {
            readonly internalType: "address";
            readonly name: "owner_";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "cap_";
            readonly type: "uint256";
        }, {
            readonly internalType: "address[]";
            readonly name: "receivers";
            readonly type: "address[]";
        }, {
            readonly internalType: "uint256[]";
            readonly name: "amounts";
            readonly type: "uint256[]";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "isBlocked";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "mint";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "name";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }];
        readonly name: "nonces";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "numCheckpoints";
        readonly outputs: readonly [{
            readonly internalType: "uint32";
            readonly name: "";
            readonly type: "uint32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "owner";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "spender";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "deadline";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint8";
            readonly name: "v";
            readonly type: "uint8";
        }, {
            readonly internalType: "bytes32";
            readonly name: "r";
            readonly type: "bytes32";
        }, {
            readonly internalType: "bytes32";
            readonly name: "s";
            readonly type: "bytes32";
        }];
        readonly name: "permit";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "id";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "symbol";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "templateName";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "totalSupply";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "transfer";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "from";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "to";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }];
        readonly name: "transferFrom";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "addr";
            readonly type: "address";
        }];
        readonly name: "unblockAddress";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }];
    readonly DLPRoot: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "CheckpointUnorderedInsertion";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EpochNotEnded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidAddress";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidDlpId";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidDlpStatus";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidParam";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidStakeAmount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidStakersPercentage";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "LastEpochMustBeFinalised";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotStakeOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NothingToClaim";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "StakeActionPaused";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "StakeAlreadyClosed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "StakeAlreadyWithdrawn";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "StakeNotClosed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "StakeWithdrawalTooEarly";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TransferFailed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newMinStakeAmount";
            readonly type: "uint256";
        }];
        readonly name: "MinStakeAmountUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newRewardClaimDelay";
            readonly type: "uint256";
        }];
        readonly name: "RewardClaimDelayUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "RewardMigratedToVanaPool";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }];
        readonly name: "StakeClosed";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "staker";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "StakeCreated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "oldStakeId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newStakeId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "newDlpId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newAmount";
            readonly type: "uint256";
        }];
        readonly name: "StakeMigrated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "StakeMigratedToVanaPool";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "bool";
            readonly name: "isFinal";
            readonly type: "bool";
        }];
        readonly name: "StakeRewardClaimed";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "newStakeWithdrawalDelay";
            readonly type: "uint256";
        }];
        readonly name: "StakeWithdrawalDelayUpdated";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }];
        readonly name: "StakeWithdrawn";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "NEW_MULTIPLIER_EPOCH";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }];
        readonly name: "calculateStakeClaimableAmount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeAmount";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "stakeStartBlock";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "blockNumber";
            readonly type: "uint256";
        }];
        readonly name: "calculateStakeScore";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "lastEpochToClaim";
            readonly type: "uint256";
        }];
        readonly name: "claimStakeRewardUntilEpoch";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "stakeIds";
            readonly type: "uint256[]";
        }];
        readonly name: "claimStakesReward";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "stakeIds";
            readonly type: "uint256[]";
        }];
        readonly name: "closeStakes";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "createStake";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "stakeOwner";
            readonly type: "address";
        }];
        readonly name: "createStakeOnBehalf";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRootCore";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRootCore";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRootEpoch";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRootEpoch";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRootMetrics";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRootMetrics";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRootRewardsTreasury";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRootTreasury";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dlpRootStakesTreasury";
        readonly outputs: readonly [{
            readonly internalType: "contract IDLPRootTreasury";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "forwarder";
            readonly type: "address";
        }];
        readonly name: "isTrustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "migrateRewardToVanaPool";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "newDlpId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "newAmount";
            readonly type: "uint256";
        }];
        readonly name: "migrateStake";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "migrateStakeAndRewardToVanaPool";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "entityId";
            readonly type: "uint256";
        }];
        readonly name: "migrateStakeToVanaPool";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "minStakeAmount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "rewardClaimDelay";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }];
        readonly name: "stakeClaimedAmounts";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "epochId";
            readonly type: "uint256";
        }];
        readonly name: "stakeEpochReward";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "stakeWithdrawalDelay";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "stakerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "dlpId";
            readonly type: "uint256";
        }];
        readonly name: "stakerDlpStakeAmount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "staker";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "stakerDlpsListAt";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "staker";
            readonly type: "address";
        }];
        readonly name: "stakerDlpsListCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "staker";
            readonly type: "address";
        }];
        readonly name: "stakerDlpsListValues";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "stakerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "stakerStakesListAt";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "stakerAddress";
            readonly type: "address";
        }];
        readonly name: "stakerStakesListCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "stakerAddress";
            readonly type: "address";
        }];
        readonly name: "stakerStakesListValues";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "stakerAddress";
            readonly type: "address";
        }];
        readonly name: "stakerTotalStakeAmount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "stakersListAt";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "stakersListCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "stakeId";
            readonly type: "uint256";
        }];
        readonly name: "stakes";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "id";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "stakerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "dlpId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "startBlock";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "endBlock";
                readonly type: "uint256";
            }, {
                readonly internalType: "bool";
                readonly name: "withdrawn";
                readonly type: "bool";
            }, {
                readonly internalType: "uint256";
                readonly name: "lastClaimedEpochId";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IDLPRoot.StakeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "stakesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "stakingLastBlockNumber";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "trustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newDlpRootCoreAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRootCore";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newDlpRootEpochAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRootEpoch";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newDlpRootMetricsAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRootMetrics";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newDlpRootRewardsTreasuryAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRootRewardsTreasury";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newDlpRootStakesTreasuryAddress";
            readonly type: "address";
        }];
        readonly name: "updateDlpRootStakesTreasury";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newMinStakeAmount";
            readonly type: "uint256";
        }];
        readonly name: "updateMinStakeAmount";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newRewardClaimDelay";
            readonly type: "uint256";
        }];
        readonly name: "updateRewardClaimDelay";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newStakingLastBlockNumber";
            readonly type: "uint256";
        }];
        readonly name: "updateStakeLastBlockNumber";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newStakeWithdrawalDelay";
            readonly type: "uint256";
        }];
        readonly name: "updateStakeWithdrawalDelay";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }];
        readonly name: "updateTrustedForwarder";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newVanaPoolStakingAddress";
            readonly type: "address";
        }];
        readonly name: "updateVanaPoolStaking";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "vanaPoolStaking";
        readonly outputs: readonly [{
            readonly internalType: "contract IVanaPoolStaking";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "stakeIds";
            readonly type: "uint256[]";
        }];
        readonly name: "withdrawStakes";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly stateMutability: "payable";
        readonly type: "receive";
    }];
    readonly TeePool: readonly [{
        readonly inputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
    }, {
        readonly inputs: readonly [];
        readonly name: "AccessControlBadConfirmation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly internalType: "bytes32";
            readonly name: "neededRole";
            readonly type: "bytes32";
        }];
        readonly name: "AccessControlUnauthorizedAccount";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }];
        readonly name: "AddressEmptyCode";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "CancelDelayNotPassed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "ERC1967InvalidImplementation";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ERC1967NonPayable";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "EnforcedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ExpectedPause";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "FailedInnerCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InsufficientFee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidInitialization";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidJobStatus";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "InvalidJobTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "JobCompleted";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NoActiveTee";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotInitializing";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NotJobOwner";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "NothingToClaim";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "ReentrancyGuardReentrantCall";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeeAlreadyAdded";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TeeNotActive";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "TransferFailed";
        readonly type: "error";
    }, {
        readonly inputs: readonly [];
        readonly name: "UUPSUnauthorizedCallContext";
        readonly type: "error";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "slot";
            readonly type: "bytes32";
        }];
        readonly name: "UUPSUnsupportedProxiableUUID";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly name: "Claimed";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "uint64";
            readonly name: "version";
            readonly type: "uint64";
        }];
        readonly name: "Initialized";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "JobCanceled";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly indexed: false;
            readonly internalType: "uint256";
            readonly name: "bidAmount";
            readonly type: "uint256";
        }];
        readonly name: "JobSubmitted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "attestator";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "ProofAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "previousAdminRole";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "newAdminRole";
            readonly type: "bytes32";
        }];
        readonly name: "RoleAdminChanged";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleGranted";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "sender";
            readonly type: "address";
        }];
        readonly name: "RoleRevoked";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeAdded";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "TeeRemoved";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly name: "Upgraded";
        readonly type: "event";
    }, {
        readonly inputs: readonly [];
        readonly name: "DEFAULT_ADMIN_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "MAINTAINER_ROLE";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "UPGRADE_INTERFACE_VERSION";
        readonly outputs: readonly [{
            readonly internalType: "string";
            readonly name: "";
            readonly type: "string";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "activeTeeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum ITeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "withdrawnAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct ITeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "activeTeesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "bytes";
                readonly name: "signature";
                readonly type: "bytes";
            }, {
                readonly components: readonly [{
                    readonly internalType: "uint256";
                    readonly name: "score";
                    readonly type: "uint256";
                }, {
                    readonly internalType: "uint256";
                    readonly name: "dlpId";
                    readonly type: "uint256";
                }, {
                    readonly internalType: "string";
                    readonly name: "metadata";
                    readonly type: "string";
                }, {
                    readonly internalType: "string";
                    readonly name: "proofUrl";
                    readonly type: "string";
                }, {
                    readonly internalType: "string";
                    readonly name: "instruction";
                    readonly type: "string";
                }];
                readonly internalType: "struct IDataRegistry.ProofData";
                readonly name: "data";
                readonly type: "tuple";
            }];
            readonly internalType: "struct IDataRegistry.Proof";
            readonly name: "proof";
            readonly type: "tuple";
        }];
        readonly name: "addProof";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly internalType: "string";
            readonly name: "url";
            readonly type: "string";
        }, {
            readonly internalType: "string";
            readonly name: "publicKey";
            readonly type: "string";
        }];
        readonly name: "addTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "cancelDelay";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "cancelJob";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "claim";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "dataRegistry";
        readonly outputs: readonly [{
            readonly internalType: "contract IDataRegistry";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "fileJobIds";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }];
        readonly name: "getRoleAdmin";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "grantRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "hasRole";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "ownerAddress";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "dataRegistryAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "initialCancelDelay";
            readonly type: "uint256";
        }];
        readonly name: "initialize";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "isTee";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "forwarder";
            readonly type: "address";
        }];
        readonly name: "isTrustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "jobId";
            readonly type: "uint256";
        }];
        readonly name: "jobs";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint256";
                readonly name: "fileId";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "bidAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "enum ITeePool.JobStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "addedTimestamp";
                readonly type: "uint256";
            }, {
                readonly internalType: "address";
                readonly name: "ownerAddress";
                readonly type: "address";
            }, {
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }];
            readonly internalType: "struct ITeePool.Job";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "jobsCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "data";
            readonly type: "bytes[]";
        }];
        readonly name: "multicall";
        readonly outputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "results";
            readonly type: "bytes[]";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "proxiableUUID";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "removeTee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "callerConfirmation";
            readonly type: "address";
        }];
        readonly name: "renounceRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "requestContributionProof";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "role";
            readonly type: "bytes32";
        }, {
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "revokeRole";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "fileId";
            readonly type: "uint256";
        }];
        readonly name: "submitJob";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "bytes4";
            readonly name: "interfaceId";
            readonly type: "bytes4";
        }];
        readonly name: "supportsInterface";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teeFee";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "start";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "limit";
            readonly type: "uint256";
        }];
        readonly name: "teeJobIdsPaginated";
        readonly outputs: readonly [{
            readonly internalType: "uint256[]";
            readonly name: "";
            readonly type: "uint256[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teeList";
        readonly outputs: readonly [{
            readonly internalType: "address[]";
            readonly name: "";
            readonly type: "address[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "teeListAt";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum ITeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "withdrawnAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct ITeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "teeAddress";
            readonly type: "address";
        }];
        readonly name: "tees";
        readonly outputs: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "teeAddress";
                readonly type: "address";
            }, {
                readonly internalType: "string";
                readonly name: "url";
                readonly type: "string";
            }, {
                readonly internalType: "enum ITeePool.TeeStatus";
                readonly name: "status";
                readonly type: "uint8";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "withdrawnAmount";
                readonly type: "uint256";
            }, {
                readonly internalType: "uint256";
                readonly name: "jobsCount";
                readonly type: "uint256";
            }, {
                readonly internalType: "string";
                readonly name: "publicKey";
                readonly type: "string";
            }];
            readonly internalType: "struct ITeePool.TeeInfo";
            readonly name: "";
            readonly type: "tuple";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "teesCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "trustedForwarder";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newCancelDelay";
            readonly type: "uint256";
        }];
        readonly name: "updateCancelDelay";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract IDataRegistry";
            readonly name: "newDataRegistry";
            readonly type: "address";
        }];
        readonly name: "updateDataRegistry";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "newTeeFee";
            readonly type: "uint256";
        }];
        readonly name: "updateTeeFee";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "trustedForwarderAddress";
            readonly type: "address";
        }];
        readonly name: "updateTrustedForwarder";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newImplementation";
            readonly type: "address";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly name: "upgradeToAndCall";
        readonly outputs: readonly [];
        readonly stateMutability: "payable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "version";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "pure";
        readonly type: "function";
    }];
};
type ContractAbis = typeof contractAbis;
type VanaContract = keyof ContractAbis;
/**
 * Retrieves the ABI for a specific Vana contract
 *
 * @param contract - The name of the contract to get the ABI for
 * @returns The ABI array for the specified contract
 */
declare function getAbi<T extends VanaContract>(contract: T): ContractAbis[T];

declare const mokshaTestnet: {
    blockExplorers: {
        readonly default: {
            readonly url: "https://moksha.vanascan.io";
            readonly name: "Vanascan - Moksha";
        };
        readonly blockscout: {
            readonly url: "https://moksha.vanascan.io";
            readonly name: "Vanascan - Moksha";
        };
    };
    blockTime?: number | undefined | undefined;
    contracts: {};
    ensTlds?: readonly string[] | undefined;
    id: 14800;
    name: "Moksha Testnet";
    nativeCurrency: {
        readonly name: "VANA";
        readonly symbol: "VANA";
        readonly decimals: 18;
    };
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://rpc.moksha.vana.org"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    readonly caipNetworkId: "eip155:14800";
    readonly chainNamespace: "eip155";
    readonly abis: {};
};
declare const vanaMainnet: {
    blockExplorers: {
        readonly default: {
            readonly url: "https://vanascan.io";
            readonly name: "Vanascan";
        };
        readonly blockscout: {
            readonly url: "https://vanascan.io";
            readonly name: "Vanascan";
        };
    };
    blockTime?: number | undefined | undefined;
    contracts: {};
    ensTlds?: readonly string[] | undefined;
    id: 1480;
    name: "Vana";
    nativeCurrency: {
        readonly name: "VANA";
        readonly symbol: "VANA";
        readonly decimals: 18;
    };
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://rpc.vana.org"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    readonly caipNetworkId: "eip155:1480";
    readonly chainNamespace: "eip155";
    readonly abis: {};
};
interface Chains {
    [key: number]: Chain & {
        abis?: Record<string, Abi>;
    };
}
declare const chains: Chains;

declare const createClient: (chainId?: keyof typeof chains) => PublicClient & {
    chain: Chain;
};

declare const __contractCache: Map<string, {
    address: `0x${string}`;
    abi: Abi$1;
}>;
/**
 * Gets a typed contract instance for the specified contract name with full type inference.
 * This function provides complete type safety following viem's patterns.
 *
 * @param contract - Name of the contract to instantiate (must be a const assertion for full typing)
 * @param client - Optional viem client instance
 * @returns A fully typed contract instance with methods corresponding to the contract's ABI
 * @example
 * ```typescript
 * // Full type inference with const assertion
 * const dataRegistry = getContractController("DataRegistry" as const, client);
 *
 * // Now dataRegistry has full type inference for all methods
 * const result = await dataRegistry.read.getFileCount(); // Type: bigint
 * await dataRegistry.write.addFile([url, proof]); // Typed parameters
 * ```
 */
declare function getContractController<T extends VanaContract>(contract: T, client?: PublicClient | WalletClient | ReturnType<typeof createClient>): GetContractReturnType<ContractAbis[T]>;
/**
 * Gets contract information (address and ABI) without creating a contract instance.
 * Useful for cases where you need contract details but don't want to create a client connection.
 *
 * @param contract - Name of the contract
 * @param chainId - Chain ID (defaults to Vana mainnet)
 * @returns Contract information with typed ABI
 * @example
 * ```typescript
 * const info = getContractInfo("DataRegistry" as const, 14800);
 * console.log(info.address); // Typed as Address
 * console.log(info.abi); // Fully typed ABI
 * ```
 */
declare function getContractInfo<T extends VanaContract>(contract: T, chainId?: VanaChainId): ContractInfo<ContractAbis[T]>;
/**
 * Type-safe contract factory that creates contract instances with full type inference.
 * This provides an alternative API that's more explicit about typing.
 */
declare class ContractFactory {
    private readonly client;
    private readonly chainId;
    constructor(client: PublicClient | WalletClient | ReturnType<typeof createClient>);
    /**
     * Creates a typed contract instance
     *
     * @param contract - Contract name (use const assertion for full typing)
     * @returns Fully typed contract instance
     */
    create<T extends VanaContract>(contract: T): GetContractReturnType<ContractAbis[T]>;
    /**
     * Gets contract information without creating an instance
     *
     * @param contract - Contract name
     * @returns Contract information with typed ABI
     */
    getInfo<T extends VanaContract>(contract: T): ContractInfo<ContractAbis[T]>;
    /**
     * Lists all available contracts for the current chain
     *
     * @returns Array of contract names available on this chain
     */
    getAvailableContracts(): VanaContract[];
}
/**
 * Clears the contract cache. Useful for testing or when chain configurations change.
 *
 * @param contract - Optional specific contract to clear, or clear all if not provided
 * @param chainId - Optional specific chain to clear, or clear all if not provided
 */
declare function clearContractCache(contract?: VanaContract, chainId?: number): void;

/**
 * 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.
 *
 * 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.
 *
 * **Use this controller when:**
 * - High-level controllers don't provide needed functionality
 * - You need direct contract method calls or event access
 * - You're building custom integrations or tooling
 * - You need advanced querying capabilities
 *
 * **Most developers should use instead:**
 * - `vana.data.*` for file management operations
 * - `vana.permissions.*` for access control workflows
 * @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 [URL_PLACEHOLDER] | 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
     * @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
     */
    getChainId(): number;
    /**
     * Gets the current chain name from the wallet client.
     *
     * @returns The chain name
     */
    getChainName(): string;
}

/**
 * Provides the core SDK functionality for interacting with the Vana network.
 *
 * @remarks
 * This environment-agnostic class contains all SDK logic and accepts a platform
 * adapter to handle environment-specific operations. It initializes all controllers
 * and manages shared context between them.
 *
 * For public usage, use the platform-specific Vana classes that extend this core:
 * - Use `new Vana(config)` from the main package import
 * @example
 * ```typescript
 * // Direct instantiation (typically used internally)
 * const core = new VanaCore({
 *   walletClient: myWalletClient,
 * }, platformAdapter);
 * ```
 * @category Core SDK
 */
declare class VanaCore {
    /** Manages gasless data access permissions and trusted server registry. */
    readonly permissions: PermissionsController;
    /** Handles user data file operations and schema management. */
    readonly data: DataController;
    /** Provides personal server setup and trusted server interactions. */
    readonly server: ServerController;
    /** Offers low-level access to Vana protocol smart contracts. */
    readonly protocol: ProtocolController;
    /** Handles environment-specific operations like encryption and file systems. */
    protected platform: VanaPlatformAdapter;
    private readonly relayerCallbacks?;
    private readonly storageManager?;
    /**
     * Initializes a new VanaCore client instance with the provided configuration.
     *
     * @remarks
     * The constructor validates the configuration, initializes storage providers if configured,
     * creates wallet and public clients, and sets up all SDK controllers with shared context.
     * @param platform - The platform adapter for environment-specific operations
     * @param config - The configuration object specifying wallet or chain settings
     * @throws {InvalidConfigurationError} When the configuration is invalid or incomplete
     * @example
     * ```typescript
     * // Direct instantiation (consider using factory methods instead)
     * const vanaCore = new VanaCore(platformAdapter, {
     *   walletClient: myWalletClient,
     * });
     * ```
     */
    constructor(platform: VanaPlatformAdapter, config: VanaConfig);
    /**
     * Validates the provided configuration object against all requirements.
     *
     * @remarks
     * This method performs comprehensive validation of wallet client configuration,
     * chain configuration, storage providers, and relayer callbacks.
     * @param config - The configuration object to validate
     * @throws {InvalidConfigurationError} When any configuration parameter is invalid
     */
    private validateConfig;
    /**
     * Gets the current chain ID from the wallet client.
     *
     * @returns The numeric chain ID of the connected network
     * @example
     * ```typescript
     * const chainId = vana.chainId;
     * console.log(`Connected to chain: ${chainId}`); // e.g., "Connected to chain: 14800"
     * ```
     */
    get chainId(): number;
    /**
     * Gets the current chain name from the wallet client.
     *
     * @returns The human-readable name of the connected network
     * @example
     * ```typescript
     * const chainName = vana.chainName;
     * console.log(`Connected to: ${chainName}`); // e.g., "Connected to: Moksha Testnet"
     * ```
     */
    get chainName(): string;
    /**
     * Retrieves the user's wallet address from the connected client.
     *
     * @returns A Promise that resolves to the user's Ethereum address
     * @example
     * ```typescript
     * const address = await vana.getUserAddress();
     * console.log(`User address: ${address}`); // e.g., "User address: 0x742d35..."
     * ```
     */
    getUserAddress(): Promise<`0x${string}`>;
    /**
     * Retrieves comprehensive runtime configuration information.
     *
     * @returns The current runtime configuration including chain, storage, and relayer settings
     * @example
     * ```typescript
     * const config = vana.getConfig();
     * console.log(`Chain: ${config.chainName} (${config.chainId})`);
     * console.log(`Storage providers: ${config.storageProviders.join(", ")}`);
     * ```
     */
    getConfig(): RuntimeConfig;
    /**
     * Sets the platform adapter for environment-specific operations.
     * This is useful for testing and advanced use cases where you need
     * to override the default platform detection.
     *
     * @param adapter - The platform adapter to use
     * @example
     * ```typescript
     * // For testing with a mock adapter
     * const mockAdapter = new MockPlatformAdapter();
     * vana.setPlatformAdapter(mockAdapter);
     *
     * // For advanced use cases with custom adapters
     * const customAdapter = new CustomPlatformAdapter();
     * vana.setPlatformAdapter(customAdapter);
     * ```
     */
    setPlatformAdapter(adapter: VanaPlatformAdapter): void;
    /**
     * Gets the current platform adapter.
     * This is useful for advanced use cases where you need to access
     * the platform adapter directly.
     *
     * @returns The current platform adapter
     * @example
     * ```typescript
     * const adapter = vana.getPlatformAdapter();
     * const encrypted = await adapter.encrypt(data, key);
     * ```
     */
    getPlatformAdapter(): VanaPlatformAdapter;
    /**
     * Encrypts user data using the Vana protocol standard encryption.
     * This method automatically uses the correct platform adapter for the current environment.
     *
     * @param data The data to encrypt (string or Blob)
     * @param walletSignature The wallet signature to use as encryption key
     * @returns The encrypted data as Blob
     * @example
     * ```typescript
     * const encryptionKey = await generateEncryptionKey(walletClient);
     * const encrypted = await vana.encryptUserData("sensitive data", encryptionKey);
     * ```
     */
    encryptUserData(data: string | Blob, walletSignature: string): Promise<Blob>;
    /**
     * Decrypts user data using the Vana protocol standard decryption.
     * This method automatically uses the correct platform adapter for the current environment.
     *
     * @param encryptedData The encrypted data (string or Blob)
     * @param walletSignature The wallet signature to use as decryption key
     * @returns The decrypted data as Blob
     * @example
     * ```typescript
     * const encryptionKey = await generateEncryptionKey(walletClient);
     * const decrypted = await vana.decryptUserData(encryptedData, encryptionKey);
     * const text = await decrypted.text();
     * ```
     */
    decryptUserData(encryptedData: string | Blob, walletSignature: string): Promise<Blob>;
}

/**
 * Base error class for all Vana SDK errors with structured error codes.
 *
 * @remarks
 * This abstract base class provides a foundation for all SDK-specific errors with
 * consistent error codes and stack trace handling. All Vana SDK errors extend this
 * class to provide structured error information that applications can handle
 * programmatically. The error code enables differentiation between error types
 * without relying on string matching.
 * @category Error Handling
 */
declare class VanaError extends Error {
    readonly code?: string | undefined;
    constructor(message: string, code?: string | undefined);
}
/**
 * Thrown when gasless transaction submission via relayer fails.
 *
 * @remarks
 * This error occurs when the relayer service is unavailable, returns an error,
 * or fails to process a gasless transaction. It includes the HTTP status code
 * and response details when available to help with debugging relayer issues.
 * @category Error Handling
 */
declare class RelayerError extends VanaError {
    readonly statusCode?: number | undefined;
    readonly response?: unknown | undefined;
    constructor(message: string, statusCode?: number | undefined, response?: unknown | undefined);
}
/**
 * Thrown when the user rejects a wallet signature request.
 *
 * @remarks
 * This error occurs when users decline to sign transactions or typed data through
 * their wallet interface. It's a normal part of user interaction and should be
 * handled gracefully by applications without treating it as a system error.
 * @category Error Handling
 */
declare class UserRejectedRequestError extends VanaError {
    constructor(message?: string);
}
/**
 * Error thrown when the SDK configuration is invalid.
 */
declare class InvalidConfigurationError extends VanaError {
    constructor(message: string);
}
/**
 * Thrown when a required Vana protocol contract is not deployed on the current chain.
 *
 * @remarks
 * This error occurs when attempting to interact with contracts that are not
 * available on the connected blockchain network. It includes the contract name
 * and chain ID to help identify deployment issues or incorrect network configuration.
 * @category Error Handling
 */
declare class ContractNotFoundError extends VanaError {
    constructor(contractName: string, chainId: number);
}
/**
 * Error thrown when a blockchain operation fails.
 */
declare class BlockchainError extends VanaError {
    readonly originalError?: Error | undefined;
    constructor(message: string, originalError?: Error | undefined);
}
/**
 * Error thrown when parameter serialization fails.
 */
declare class SerializationError extends VanaError {
    constructor(message: string);
}
/**
 * Error thrown when a signature operation fails.
 */
declare class SignatureError extends VanaError {
    readonly originalError?: Error | undefined;
    constructor(message: string, originalError?: Error | undefined);
}
/**
 * Error thrown when a network operation fails.
 */
declare class NetworkError extends VanaError {
    readonly originalError?: Error | undefined;
    constructor(message: string, originalError?: Error | undefined);
}
/**
 * Error thrown when the nonce retrieval fails.
 */
declare class NonceError extends VanaError {
    constructor(message: string);
}
/**
 * Error thrown when a personal server operation fails.
 */
declare class PersonalServerError extends VanaError {
    readonly originalError?: Error | undefined;
    constructor(message: string, originalError?: Error | undefined);
}
/**
 * Error thrown when trying to register a server with a URL that doesn't match the existing registration.
 */
declare class ServerUrlMismatchError extends VanaError {
    constructor(existingUrl: string, providedUrl: string, serverId: string);
    readonly existingUrl: string;
    readonly providedUrl: string;
    readonly serverId: string;
}
/**
 * Error thrown when a permission operation fails.
 */
declare class PermissionError extends VanaError {
    readonly originalError?: Error | undefined;
    constructor(message: string, originalError?: Error | undefined);
}

/**
 * Canonical Vana Protocol Encryption Functions
 *
 * These functions define the standard way user data is encrypted/decrypted in Vana.
 * All applications should use these canonical functions to ensure compatibility
 * with existing encrypted data on the Vana network.
 *
 * This module uses the platform adapter pattern to provide consistent
 * encryption functionality across Node.js and browser environments.
 */

/**
 * Default encryption seed message used throughout Vana protocol
 */
declare const DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
/**
 * Generate an encryption key by signing the canonical Vana encryption seed
 *
 * This is the standard protocol function for creating encryption keys in Vana.
 * The signature serves as a symmetric encryption key for user data.
 *
 * @param wallet The user's wallet client for signing
 * @param seed Optional custom encryption seed (defaults to Vana standard)
 * @returns The signature that serves as the encryption key
 * @throws {Error} When wallet account is required but not provided
 * @example
 * ```typescript
 * const encryptionKey = await generateEncryptionKey(walletClient);
 * console.log('Generated encryption key:', encryptionKey);
 *
 * // Use with custom seed
 * const customKey = await generateEncryptionKey(walletClient, 'my-custom-seed');
 * ```
 */
declare function generateEncryptionKey(wallet: WalletClient, seed?: string): Promise<string>;
/**
 * Encrypt data with a wallet's public key using platform-appropriate cryptography
 *
 * @param data The data to encrypt (as string or Blob)
 * @param publicKey The public key for encryption
 * @param platformAdapter - The platform adapter for crypto operations
 * @returns The encrypted data
 */
declare function encryptWithWalletPublicKey(data: string | Blob, publicKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
/**
 * Decrypt data with a wallet's private key using platform-appropriate cryptography
 *
 * @param encryptedData The encrypted data
 * @param privateKey The private key for decryption
 * @param platformAdapter - The platform adapter for crypto operations
 * @returns The decrypted data as string
 */
declare function decryptWithWalletPrivateKey(encryptedData: string, privateKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
/**
 * Encrypt a file key with a DLP's public key using platform-appropriate cryptography
 *
 * @param fileKey The symmetric key used to encrypt the file
 * @param publicKey The DLP's public key
 * @param platformAdapter - The platform adapter for crypto operations
 * @returns The encrypted key that can be stored on-chain
 */
declare function encryptFileKey(fileKey: string, publicKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
/**
 * Generate encryption parameters for secure file storage
 *
 * @param platformAdapter - The platform adapter for crypto operations
 * @returns An object containing the initialization vector and encryption key
 */
declare function getEncryptionParameters(platformAdapter: VanaPlatformAdapter): Promise<{
    iv: string;
    key: string;
}>;
/**
 * Decrypt data that was encrypted with the DLP's public key using platform-appropriate cryptography
 *
 * @param encryptedData The encrypted data
 * @param privateKey The private key corresponding to the public key used for encryption
 * @param platformAdapter - The platform adapter for crypto operations
 * @returns The decrypted data
 */
declare function decryptWithPrivateKey(encryptedData: string, privateKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
/**
 * Encrypt user data using PGP with platform-appropriate configuration
 *
 * @param data The data to encrypt (string or Blob)
 * @param walletSignature The wallet signature to use as password
 * @param platformAdapter - The platform adapter for crypto operations
 * @returns The encrypted data as Blob
 */
declare function encryptUserData(data: string | Blob, walletSignature: string, platformAdapter: VanaPlatformAdapter): Promise<Blob>;
/**
 * Decrypt user data using PGP with platform-appropriate configuration
 *
 * @param encryptedData The encrypted data (string or Blob)
 * @param walletSignature The wallet signature to use as password
 * @param platformAdapter - The platform adapter for crypto operations
 * @returns The decrypted data as Blob
 */
declare function decryptUserData(encryptedData: string | Blob, walletSignature: string, platformAdapter: VanaPlatformAdapter): Promise<Blob>;
/**
 * Generate a new key pair for asymmetric encryption
 *
 * @param platformAdapter - The platform adapter for crypto operations
 * @returns Promise resolving to public and private key pair
 */
declare function generateEncryptionKeyPair(platformAdapter: VanaPlatformAdapter): Promise<{
    publicKey: string;
    privateKey: string;
}>;
/**
 * Generate a new PGP key pair with platform-appropriate configuration
 *
 * @param platformAdapter - The platform adapter for crypto operations
 * @param options - Key generation options
 * @param options.name - The name for the PGP key
 * @param options.email - The email for the PGP key
 * @param options.passphrase - Optional passphrase to protect the private key
 * @returns Promise resolving to public and private key pair
 */
declare function generatePGPKeyPair(platformAdapter: VanaPlatformAdapter, options?: {
    name?: string;
    email?: string;
    passphrase?: string;
}): Promise<{
    publicKey: string;
    privateKey: string;
}>;

/**
 * Format a bigint or BigNumber to a regular number
 *
 * @param value BigInt, BigNumber or numeric string to convert
 * @returns Regular JavaScript number
 */
declare function formatNumber(value: bigint | string | number): number;
/**
 * Format wei value to ETH with specified decimal places
 *
 * @param wei Value in wei (as bigint, string, or number)
 * @param decimals Number of decimal places to display (default: 4)
 * @returns Formatted ETH value as string
 */
declare function formatEth(wei: bigint | string | number, decimals?: number): string;
/**
 * Format a token amount based on its decimals
 *
 * @param amount Raw token amount
 * @param decimals Token decimals (default: 18)
 * @param displayDecimals Decimals to show in formatted output (default: 4)
 * @returns Formatted token amount as string
 */
declare function formatToken(amount: bigint | string | number, decimals?: number, displayDecimals?: number): string;
/**
 * Format an address for display (showing first 6 and last 4 characters)
 *
 * @param address EVM address
 * @returns Shortened address string
 */
declare function shortenAddress(address: string): string;

/**
 * Creates a grant file structure from permission parameters.
 *
 * @param params - The permission parameters to create the grant file from
 * @returns The constructed grant file object
 */
declare function createGrantFile(params: GrantPermissionParams$1): GrantFile;
/**
 * Stores a grant file in IPFS via the relayer service.
 *
 * @param grantFile - The grant file to store
 * @param relayerUrl - URL of the relayer service
 * @returns Promise resolving to the IPFS URL
 */
declare function storeGrantFile(grantFile: GrantFile, relayerUrl: string): Promise<string>;
/**
 * Retrieves a grant file from any URL.
 *
 * @param grantUrl - The grant file URL (supports HTTP/HTTPS, ipfs:// protocol, or IPFS gateway URLs)
 * @param _relayerUrl - URL of the relayer service (optional)
 * @returns Promise resolving to the grant file
 */
declare function retrieveGrantFile(grantUrl: string, _relayerUrl?: string): Promise<GrantFile>;
/**
 * Generates a content hash for a grant file.
 * This can be used for integrity verification.
 *
 * @param grantFile - The grant file to generate a hash for
 * @returns The keccak256 hash of the grant file as a hex string
 */
declare function getGrantFileHash(grantFile: GrantFile): string;
/**
 * Validates that a grant file has the required structure.
 *
 * @param data - The data to validate as a grant file
 * @returns True if the data is a valid grant file, false otherwise
 */
declare function validateGrantFile(data: unknown): data is GrantFile;

/**
 * Base error class for grant validation failures
 *
 * @category Permissions
 */
declare class GrantValidationError extends Error {
    details?: Record<string, unknown> | undefined;
    constructor(message: string, details?: Record<string, unknown> | undefined);
}
/**
 * Error thrown when a grant has expired
 *
 * @category Permissions
 */
declare class GrantExpiredError extends GrantValidationError {
    expires: number;
    currentTime: number;
    constructor(message: string, expires: number, currentTime: number);
}
/**
 * Error thrown when grantee doesn't match requesting address
 *
 * @category Permissions
 */
declare class GranteeMismatchError extends GrantValidationError {
    grantee: Address;
    requestingAddress: Address;
    constructor(message: string, grantee: Address, requestingAddress: Address);
}
/**
 * Error thrown when operation is not allowed by grant
 *
 * @category Permissions
 */
declare class OperationNotAllowedError extends GrantValidationError {
    grantedOperation: string;
    requestedOperation: string;
    constructor(message: string, grantedOperation: string, requestedOperation: string);
}
/**
 * Error thrown when grant file structure is invalid
 *
 * @category Permissions
 */
declare class GrantSchemaError extends GrantValidationError {
    schemaErrors: unknown[];
    invalidData: unknown;
    constructor(message: string, schemaErrors: unknown[], invalidData: unknown);
}
/**
 * Options for grant validation
 *
 * @category Permissions
 */
interface GrantValidationOptions {
    /** Enable JSON schema validation (default: true) */
    schema?: boolean;
    /** Grantee address to validate access for */
    grantee?: Address;
    /** Operation to validate permission for */
    operation?: string;
    /** Override current time for expiry checking (Unix timestamp) */
    currentTime?: number;
    /** Return detailed results instead of throwing (default: false) */
    throwOnError?: boolean;
}
/**
 * Detailed validation result
 *
 * @category Permissions
 */
interface GrantValidationResult {
    /** Whether validation passed */
    valid: boolean;
    /** Validation errors encountered */
    errors: Array<{
        type: "schema" | "business";
        field?: string;
        message: string;
        error?: Error;
    }>;
    /** The validated grant file (if validation passed) */
    grant?: GrantFile;
}
/**
 * Validates a grant file with comprehensive schema and business rule checking.
 *
 * This function provides flexible validation with TypeScript overloads:
 * - When `throwOnError` is false (or `{ throwOnError: false }`), returns a detailed validation result
 * - When `throwOnError` is true (default), throws specific errors or returns the validated grant
 *
 * @param data - The grant file data to validate (unknown type for safety)
 * @param options - Validation options including grantee, operation, files, etc.
 * @returns Either a GrantFile (when throwing) or GrantValidationResult (when not throwing)
 * @throws {GrantSchemaError} When the grant file structure is invalid
 * @throws {GrantExpiredError} When the grant has expired
 * @throws {GranteeMismatchError} When the grantee doesn't match the requesting address
 * @throws {OperationNotAllowedError} When the requested operation is not allowed
 * @example
 * ```typescript
 * // Throwing mode (default) - returns GrantFile or throws
 * const grant = validateGrant(data, {
 *   grantee: '0x123...',
 *   operation: 'llm_inference',
 * });
 *
 * // Non-throwing mode - returns validation result
 * const result = validateGrant(data, {
 *   grantee: '0x123...',
 *   throwOnError: false
 * });
 * if (result.valid) {
 *   console.log('Grant is valid:', result.grant);
 * } else {
 *   console.log('Validation errors:', result.errors);
 * }
 * ```
 */
declare function validateGrant(data: unknown, options: GrantValidationOptions & {
    throwOnError: false;
}): GrantValidationResult;
declare function validateGrant(data: unknown, options?: Omit<GrantValidationOptions, "throwOnError"> | (GrantValidationOptions & {
    throwOnError?: true;
})): GrantFile;
/**
 * Validates that a grant file allows access for a specific grantee
 *
 * @param grantFile - The grant file to validate access for
 * @param requestingAddress - The address requesting access to check against the grantee
 */
declare function validateGranteeAccess(grantFile: GrantFile, requestingAddress: Address): void;
/**
 * Validates that a grant has not expired (if expiry is set)
 *
 * @param grantFile - The grant file to check expiration for
 * @param currentTime - Optional override for current time (Unix timestamp)
 */
declare function validateGrantExpiry(grantFile: GrantFile, currentTime?: number): void;
/**
 * Validates that a grant allows a specific operation
 *
 * @param grantFile - The grant file to validate operation access for
 * @param requestedOperation - The operation being requested to validate against the grant
 */
declare function validateOperationAccess(grantFile: GrantFile, requestedOperation: string): void;

/**
 * High-level utilities for working with grants in the Vana SDK
 */
/**
 * Creates and validates a grant file from permission parameters
 *
 * @param params - The permission parameters to create and validate the grant from
 * @returns The validated grant file object
 */
declare function createValidatedGrant(params: GrantPermissionParams$1): GrantFile;
/**
 * Creates a grant file and stores it in IPFS
 *
 * @param params - The permission parameters to create the grant from
 * @param relayerUrl - The URL of the relayer service for IPFS storage
 * @returns Promise resolving to an object containing the grant file and its IPFS URL
 */
declare function createAndStoreGrant(params: GrantPermissionParams$1, relayerUrl: string): Promise<{
    grantFile: GrantFile;
    grantUrl: string;
}>;
/**
 * Retrieves and validates a grant file from IPFS
 *
 * @param grantUrl - The IPFS URL of the grant file to retrieve
 * @param relayerUrl - Optional URL of the relayer service
 * @returns Promise resolving to the validated grant file
 */
declare function retrieveAndValidateGrant(grantUrl: string, relayerUrl?: string): Promise<GrantFile>;
/**
 * Checks if a grant allows access for a specific request
 *
 * @param grantUrl - The IPFS URL of the grant file to check
 * @param requestingAddress - The address making the access request
 * @param operation - The operation being requested
 * @param fileIds - Array of file IDs being accessed (currently unused but part of interface)
 * @param relayerUrl - Optional URL of the relayer service
 * @returns Promise resolving to access result with allowed status, reason, and grant file
 */
declare function checkGrantAccess(grantUrl: string, requestingAddress: Address, operation: string, fileIds: number[], relayerUrl?: string): Promise<{
    allowed: boolean;
    reason?: string;
    grantFile?: GrantFile;
}>;
/**
 * Utility to check if a grant has expired
 *
 * @param grantFile - The grant file to check for expiration
 * @returns True if the grant has expired, false otherwise
 */
declare function isGrantExpired(grantFile: GrantFile): boolean;
/**
 * Utility to get the time remaining before grant expires (in seconds)
 *
 * @param grantFile - The grant file to check time remaining for
 * @returns Number of seconds remaining, or null if no expiration is set
 */
declare function getGrantTimeRemaining(grantFile: GrantFile): number | null;
/**
 * Creates a human-readable summary of a grant
 *
 * @param grantFile - The grant file to create a summary for
 * @returns A human-readable string describing the grant
 */
declare function summarizeGrant(grantFile: GrantFile): string;

/**
 * IPFS URL utilities for the Vana SDK
 *
 * Centralized functions for handling IPFS URLs, converting them to gateway URLs,
 * and extracting IPFS hashes from various URL formats.
 */
/**
 * Default IPFS gateway URL
 */
declare const DEFAULT_IPFS_GATEWAY = "https://dweb.link/ipfs/";
/**
 * Alternative IPFS gateways for fallback - ordered by reliability and rate limits
 */
declare const IPFS_GATEWAYS: readonly ["https://dweb.link/ipfs/", "https://ipfs.io/ipfs/", "https://cloudflare-ipfs.com/ipfs/", "https://gateway.pinata.cloud/ipfs/", "https://ipfs.filebase.io/ipfs/"];
/**
 * Check if a URL is an IPFS URL (starts with ipfs://)
 *
 * @param url - The URL to check
 * @returns True if the URL is an IPFS URL
 */
declare function isIpfsUrl(url: string): boolean;
/**
 * Convert an IPFS URL to an HTTP gateway URL
 *
 * @param url - The IPFS URL to convert (e.g., "ipfs://QmHash...")
 * @param gateway - Optional gateway URL (defaults to DEFAULT_IPFS_GATEWAY)
 * @returns The HTTP gateway URL or original URL if not an IPFS URL
 * @example
 * ```ts
 * convertIpfsUrl("ipfs://QmHash123")
 * // Returns: "https://ipfs.io/ipfs/QmHash123"
 *
 * convertIpfsUrl("ipfs://QmHash123", "https://gateway.pinata.cloud/ipfs/")
 * // Returns: "https://gateway.pinata.cloud/ipfs/QmHash123"
 * ```
 */
declare function convertIpfsUrl(url: string, gateway?: string): string;
/**
 * Extract IPFS hash from various URL formats
 *
 * @param url - The URL to extract hash from
 * @returns The IPFS hash or null if not found
 * @example
 * ```ts
 * extractIpfsHash("ipfs://QmHash123") // Returns: "QmHash123"
 * extractIpfsHash("https://gateway.pinata.cloud/ipfs/QmHash123") // Returns: "QmHash123"
 * extractIpfsHash("QmHash123456789012345678901234567890123456") // Returns: "QmHash123456789012345678901234567890123456"
 * ```
 */
declare function extractIpfsHash(url: string): string | null;
/**
 * Get multiple gateway URLs for an IPFS hash (useful for fallback)
 *
 * @param hash - The IPFS hash
 * @returns Array of gateway URLs
 */
declare function getGatewayUrls(hash: string): string[];
/**
 * Convert an IPFS URL to multiple gateway URLs for fallback
 *
 * @param url - The IPFS URL
 * @returns Array of gateway URLs or original URL if not IPFS
 */
declare function convertIpfsUrlWithFallbacks(url: string): string[];
/**
 * Fetch content from IPFS with automatic gateway fallbacks
 *
 * @param url - The IPFS URL to fetch
 * @param options - Optional fetch options
 * @returns Promise resolving to Response object
 * @throws Error if all gateways fail
 */
declare function fetchWithFallbacks(url: string, options?: RequestInit): Promise<Response>;

declare const CONTRACT_ADDRESSES: Record<number, Record<string, string>>;
/**
 * Retrieves the deployed contract address for a specific contract on a given chain.
 *
 * @param chainId - The chain ID to look up the contract on
 * @param contract - The contract name to get the address for
 * @returns The contract address as a hex string
 * @throws {Error} When contract address not found for the specified contract and chain
 * @example
 * ```typescript
 * try {
 *   const dataRegistryAddress = getContractAddress(1480, 'DataRegistry');
 *   console.log('DataRegistry address:', dataRegistryAddress);
 * } catch (error) {
 *   console.error('Contract not deployed on this chain:', error.message);
 * }
 * ```
 */
declare const getContractAddress: (chainId: keyof typeof CONTRACT_ADDRESSES, contract: VanaContract) => `0x${string}`;

/**
 * Chain configuration definitions for Vana networks
 *
 * These provide default configurations for known Vana chains.
 * Applications can use these as-is or override specific values.
 */

interface VanaChainConfig extends Chain {
    /** URL for the subgraph API endpoint used to query on-chain data */
    subgraphUrl: string;
}
/**
 * Moksha Testnet configuration
 */
declare const moksha: VanaChainConfig;
/**
 * Retrieves the chain configuration for a given chain ID.
 *
 * @param chainId - The numeric chain ID to look up
 * @returns The chain configuration if found, undefined otherwise
 * @example
 * ```typescript
 * const config = getChainConfig(1480);
 * if (config) {
 *   console.log('Chain name:', config.name);
 *   console.log('Subgraph URL:', config.subgraphUrl);
 * }
 * ```
 */
declare function getChainConfig(chainId: number): VanaChainConfig | undefined;
/**
 * Retrieves all available Vana chain configurations.
 *
 * @returns Array of all supported Vana chain configurations
 * @example
 * ```typescript
 * const chains = getAllChains();
 * console.log('Supported chains:');
 * chains.forEach(chain => {
 *   console.log(`- ${chain.name} (ID: ${chain.id})`);
 * });
 * ```
 */
declare function getAllChains(): VanaChainConfig[];

/**
 * Base controller class with common functionality
 */
declare abstract class BaseController<TContext extends ControllerContext$1 = ControllerContext$1> implements Controller<TContext> {
    readonly context: TContext;
    constructor(context: TContext);
    /**
     * Execute a request with optional middleware pipeline
     *
     * @param request - The generic request object containing parameters and metadata
     * @param handler - The function that processes the request parameters
     * @param middleware - Optional array of middleware functions to apply
     * @returns Promise resolving to a generic response object
     */
    protected executeRequest<TParams, TResponse>(request: GenericRequest<TParams>, handler: (params: TParams) => Promise<TResponse>, middleware?: Middleware[]): Promise<GenericResponse<TResponse>>;
    /**
     * Validate parameters with optional custom validator
     *
     * @param params - The parameters to validate
     * @param validator - Optional function to validate parameter types
     * @throws Error if validation fails, asserts type if successful
     */
    protected validateParams<T>(params: unknown, validator?: (params: unknown) => params is T): asserts params is T;
}
/**
 * Generic retry utility with exponential backoff
 */
declare class RetryUtility {
    private static delay;
    static withRetry<T>(operation: () => Promise<T>, config: RetryConfig): Promise<T>;
}
/**
 * Generic rate limiter
 */
declare class RateLimiter {
    private config;
    private requests;
    constructor(config: RateLimiterConfig);
    checkLimit(): Promise<boolean>;
    waitForSlot(): Promise<void>;
    getRemainingRequests(): number;
    getResetTime(): number;
}
/**
 * Generic in-memory cache implementation
 */
declare class MemoryCache<TKey = string, TValue = unknown> implements Cache<TKey, TValue> {
    private cache;
    get(key: TKey): Promise<TValue | undefined>;
    set(key: TKey, value: TValue, ttl?: number): Promise<void>;
    delete(key: TKey): Promise<boolean>;
    clear(): Promise<void>;
    has(key: TKey): Promise<boolean>;
    size(): number;
    keys(): TKey[];
}
/**
 * Generic event emitter implementation
 */
declare class EventEmitter<TEvent = unknown> implements Observable<TEvent> {
    private observers;
    subscribe(observer: Observer<TEvent>): () => void;
    unsubscribe(observer: Observer<TEvent>): void;
    emit(event: TEvent): void;
    getObserverCount(): number;
    removeAllObservers(): void;
}
/**
 * Generic middleware pipeline
 */
declare class MiddlewarePipeline {
    private middleware;
    use(middleware: Middleware<any, any>): void;
    processRequest<TRequest>(request: TRequest): Promise<TRequest>;
    processResponse<TResponse>(response: TResponse): Promise<TResponse>;
    handleError<TRequest, TResponse>(error: Error, request: TRequest): Promise<TResponse | void>;
    getMiddleware(): Middleware<any, any>[];
    clear(): void;
}
/**
 * Generic async queue for managing concurrent operations
 */
declare class AsyncQueue<T = unknown> {
    private concurrency;
    private queue;
    private running;
    constructor(concurrency?: number);
    add<R>(operation: () => Promise<R>): Promise<R>;
    private processQueue;
    get pending(): number;
    get active(): number;
    get size(): number;
    clear(): void;
}
/**
 * Generic circuit breaker pattern
 */
declare class CircuitBreaker {
    private config;
    private state;
    private failures;
    private lastFailureTime;
    private successes;
    constructor(config: {
        failureThreshold: number;
        recoveryTimeout: number;
        halfOpenMaxAttempts?: number;
    });
    execute<TResult>(operation: () => Promise<TResult>): Promise<TResult>;
    private onSuccess;
    private onFailure;
    getState(): string;
    getFailures(): number;
    reset(): void;
}

/**
 * Payload structure for relayer requests.
 * Contains the EIP-712 typed data, signature, and optional expected user address for security verification.
 *
 * @category Server
 */
interface RelayerRequestPayload {
    /** EIP-712 typed data containing the transaction details */
    typedData: GenericTypedData;
    /** User's signature of the typed data */
    signature: Hash;
    /** Optional expected user address for security verification */
    expectedUserAddress?: Address;
}
/**
 * Unified server-side handler for processing relayed transactions.
 *
 * This function encapsulates the complete relayer workflow:
 * 1. Verifies the signature against the typed data
 * 2. Optionally checks the signer matches the expected user address
 * 3. Routes to the appropriate SDK method based on primaryType
 * 4. Returns the resulting transaction hash
 *
 * Supported transaction types:
 * - Permission: Permission grants
 * - PermissionRevoke: Permission revocations
 * - TrustServer: Trust server operations
 * - UntrustServer: Untrust server operations
 *
 * @param sdk - Initialized Vana SDK instance
 * @param payload - Request payload containing typed data, signature, and optional security check
 * @returns Promise resolving to the transaction hash
 * @throws {SignatureError} When signature verification fails or signer mismatch occurs
 * @throws {Error} When primaryType is unsupported or SDK operations fail
 * @category Server
 * @example
 * ```typescript
 * import { handleRelayerRequest } from 'vana-sdk';
 *
 * // In your relayer API endpoint:
 * export async function POST(request: NextRequest) {
 *   try {
 *     const body = await request.json();
 *     const vana = await createRelayerVana();
 *
 *     const txHash = await handleRelayerRequest(vana, {
 *       typedData: body.typedData,
 *       signature: body.signature,
 *       expectedUserAddress: body.expectedUserAddress
 *     });
 *
 *     return NextResponse.json({
 *       success: true,
 *       transactionHash: txHash
 *     });
 *   } catch (error) {
 *     return NextResponse.json({
 *       success: false,
 *       error: error.message
 *     }, { status: 500 });
 *   }
 * }
 * ```
 */
declare function handleRelayerRequest(sdk: VanaNode, payload: RelayerRequestPayload): Promise<Hash>;

/**
 * Node.js implementation of the Vana Platform Adapter
 *
 * This implementation uses Node.js-specific libraries and configurations
 * to provide crypto, PGP, and HTTP functionality.
 */

/**
 * Complete Node.js platform adapter implementation
 */
declare class NodePlatformAdapter implements VanaPlatformAdapter {
    crypto: VanaCryptoAdapter;
    pgp: VanaPGPAdapter;
    http: VanaHttpAdapter;
    platform: "node";
    constructor();
}

/**
 * Browser implementation of the Vana Platform Adapter
 *
 * This implementation uses browser-compatible libraries and configurations
 * to provide crypto, PGP, and HTTP functionality without Node.js dependencies.
 */

/**
 * Complete browser platform adapter implementation
 */
declare class BrowserPlatformAdapter implements VanaPlatformAdapter {
    crypto: VanaCryptoAdapter;
    pgp: VanaPGPAdapter;
    http: VanaHttpAdapter;
    platform: "browser";
    constructor();
}

/**
 * Configuration for the generic API client
 */
interface ApiClientConfig {
    /** Base URL for all requests */
    baseUrl?: string;
    /** Default headers */
    headers?: Record<string, string>;
    /** Request timeout in milliseconds */
    timeout?: number;
    /** Retry configuration */
    retry?: RetryConfig;
    /** Rate limiting configuration */
    rateLimit?: RateLimiterConfig;
    /** Circuit breaker configuration */
    circuitBreaker?: {
        failureThreshold: number;
        recoveryTimeout: number;
        halfOpenMaxAttempts?: number;
    };
}
/**
 * HTTP method types
 */
type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
/**
 * Request options for API calls
 */
interface RequestOptions {
    /** HTTP method */
    method?: HttpMethod;
    /** Request headers */
    headers?: Record<string, string>;
    /** Query parameters */
    params?: Record<string, unknown>;
    /** Request timeout */
    timeout?: number;
    /** Skip retry for this request */
    skipRetry?: boolean;
    /** Skip rate limiting for this request */
    skipRateLimit?: boolean;
}
/**
 * Generic API client with middleware, retry, rate limiting, and circuit breaker support
 */
declare class ApiClient {
    private readonly config;
    private readonly middleware;
    private readonly rateLimiter?;
    private readonly circuitBreaker?;
    constructor(config?: ApiClientConfig);
    /**
     * Add middleware to the request pipeline
     *
     * @param middleware - The middleware function to add to the pipeline
     */
    use(middleware: Middleware): void;
    /**
     * Make a generic HTTP request
     *
     * @param url - The URL to make the request to
     * @param options - Request options including method, headers, body, etc.
     * @returns Promise resolving to the response data
     */
    request<TData = unknown>(url: string, options?: RequestOptions): Promise<GenericResponse<TData>>;
    /**
     * Make a GET request
     *
     * @param url - The URL to make the GET request to
     * @param options - Request options (excluding method)
     * @returns Promise resolving to the response data
     */
    get<TData = unknown>(url: string, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
    /**
     * Make a POST request
     *
     * @param url - The URL to make the POST request to
     * @param data - The data to send in the request body
     * @param options - Request options (excluding method)
     * @returns Promise resolving to the response data
     */
    post<TData = unknown>(url: string, data?: unknown, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
    /**
     * Make a PUT request
     *
     * @param url - The URL to make the PUT request to
     * @param data - The data to send in the request body
     * @param options - Request options (excluding method)
     * @returns Promise resolving to the response data
     */
    put<TData = unknown>(url: string, data?: unknown, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
    /**
     * Make a DELETE request
     *
     * @param url - The URL to make the DELETE request to
     * @param options - Request options (excluding method)
     * @returns Promise resolving to the response data
     */
    delete<TData = unknown>(url: string, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
    /**
     * Make a PATCH request
     *
     * @param url - The URL to make the PATCH request to
     * @param data - The data to send in the request body
     * @param options - Request options (excluding method)
     * @returns Promise resolving to the response data
     */
    patch<TData = unknown>(url: string, data?: unknown, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
    /**
     * Execute the actual HTTP request with middleware and retry
     *
     * @param request - The generic request object containing URL and options
     * @returns Promise resolving to the generic response with data
     */
    private executeRequest;
    /**
     * Make the actual HTTP request using fetch API
     *
     * @param url - The URL to make the request to
     * @param options - The request options including method, headers, body, etc.
     * @returns Promise resolving to the generic response with data
     */
    private makeHttpRequest;
    /**
     * Build the full URL
     *
     * @param url - The URL or path to build the full URL from
     * @returns The complete URL string
     */
    private buildUrl;
    /**
     * Build request options with defaults
     *
     * @param options - The request options to merge with defaults
     * @returns The merged request options with defaults applied
     */
    private buildRequestOptions;
    /**
     * Get client statistics
     *
     * @returns Object containing client statistics and performance metrics
     */
    getStats(): {
        rateLimiter: {
            remaining: number;
            resetTime: number;
        } | null;
        circuitBreaker: {
            state: string;
            failures: number;
        } | null;
        middleware: {
            count: number;
        };
    };
    /**
     * Reset client state
     */
    reset(): void;
}

/**
 * The Vana SDK class pre-configured for Node.js environments.
 * Automatically uses the Node.js platform adapter for crypto operations and file systems.
 *
 * @example
 * ```typescript
 * const vana = new Vana({ walletClient });
 *
 * // Upload and encrypt user data
 * const file = await vana.data.uploadAndStoreFile(dataBlob, schema);
 *
 * // Grant permissions to DLPs
 * await vana.permissions.grantPermission({
 *   account: dlpAddress,
 *   fileId: file.id,
 *   permissions: ['read']
 * });
 * ```
 */
declare class VanaNode extends VanaCore {
    /**
     * Creates a Vana SDK instance configured for Node.js environments.
     *
     * @param config - SDK configuration object (wallet client or chain config)
     * @example
     * ```typescript
     * // With wallet client
     * const vana = new Vana({ walletClient });
     *
     * // With chain configuration
     * const vana = new Vana({ chainId: 14800, account });
     * ```
     */
    constructor(config: VanaConfig);
}

export { type APIResponse, type AddRefinerParams, type AddRefinerResult, type AddSchemaParams, type AddSchemaResult, type AllKeys, ApiClient, type ApiClientConfig, type ApiResponse, AsyncQueue, type AsyncResult, type Awaited, type BaseConfig, BaseController, type BatchServerInfoResult, type BatchUploadParams, type BatchUploadResult, type BlockRange, BlockchainError, type Brand, BrowserPlatformAdapter, type Cache, type CacheConfig, type ChainConfig, type CheckPermissionParams, CircuitBreaker, type ConditionalOptional, type ConfigValidationOptions, type ConfigValidationResult, type ContractAddresses, type ContractCall, type ContractDeployment, ContractFactory, type ContractInfo, type ContractMethodParams, type ContractMethodReturnType, ContractNotFoundError, type Controller, type ControllerContext$1 as ControllerContext, DEFAULT_ENCRYPTION_SEED, DEFAULT_IPFS_GATEWAY, DataController, type DataSchema, type DeepPartial, type DeepReadonly, type DeleteFileParams, type DeleteFileResult, type DownloadFileParams, type DownloadFileResult, type EncryptionInfo, EventEmitter, type EventFilter, type EventLog, type Factory, type FileAccessPermissions, type FileMetadata, type FileSharingConfig, type GasEstimate, type GenericRequest, type GenericResponse, type GenericTypedData, type GetFileParams, type GetUserFilesParams, type GetUserTrustedServersParams, type GetUserTrustedServersResult, GoogleDriveStorage, GrantExpiredError, type GrantFile, type GrantPermissionParams, GrantSchemaError, GrantValidationError, type GrantValidationOptions, type GrantValidationResult, type GrantedPermission, GranteeMismatchError, type HttpMethod, IPFS_GATEWAYS, type IdentityServerOutput, type IdentityServerResponse, type InitPersonalServerParams, InvalidConfigurationError, IpfsStorage, type MaybeArray, type MaybePromise, MemoryCache, type Middleware, MiddlewarePipeline, NetworkError, type NetworkInfo, NodePlatformAdapter, type Nominal, type NonNullable, NonceError, type Observable, type Observer, type OmitByType, OperationNotAllowedError, type OptionalKeys, type PaginatedTrustedServers, type PaginationParams, type PaginationResult, type PartialExcept, type PermissionAnalytics, type PermissionCheckResult, PermissionError, type PermissionEvent, type PermissionGrantDomain, type PermissionGrantMessage, type PermissionGrantTypedData, type PermissionInfo, type PermissionInputMessage, type PermissionOperation, type PermissionQueryResult, type PermissionStatus, PermissionsController, type PersonalServerResponse as PersonalServerAPIResponse, PersonalServerError, type PersonalServerOutput, type PersonalServerResponse$1 as PersonalServerResponse, type PickByType, type PinataListResponse, type PinataPin, PinataStorage, type PinataUploadResponse, type Plugin, type PostRequestParams, type PromiseResult, ProtocolController, type QueryPermissionsParams, type RateLimitInfo, RateLimiter, type RateLimiterConfig, type Refiner, type RelayerCallbacks, type RelayerConfig, RelayerError, type RelayerErrorResponse, type RelayerMetrics, type RelayerQueueInfo, type RelayerRequestOptions, type RelayerRequestPayload, type RelayerStatus, type RelayerStorageResponse, type RelayerStoreParams, type RelayerSubmitParams, type RelayerTransactionResponse, type RelayerTransactionStatus, type RelayerWebhookConfig, type RelayerWebhookPayload, type ReplicateAPIResponse, type ReplicatePredictionResponse, type ReplicateStatus, type Repository, type RequestOptions, type RequireKeys, type RequiredExcept, type RetryConfig, RetryUtility, type RevokePermissionInput, type RevokePermissionParams, type RuntimeConfig, type Schema, SchemaValidationError, SchemaValidator, SerializationError, type Server, ServerController, ServerProxyStorage, type ServerTrustStatus, ServerUrlMismatchError, type Service, SignatureError, type SimplifiedPermissionMessage, type StateMachine, type StatusInfo, type StorageConfig, StorageError, type StorageFile, type StorageListOptions, StorageManager, type StorageProvider, type StorageProviderConfig, type StorageUploadResult, type TimeRange, type TransactionOptions, type TransactionReceipt, type Transformer, type TrustServerInput, type TrustServerParams, type TrustServerTypedData, type TrustedServer, type TrustedServerInfo, type TrustedServerQueryMode, type TrustedServerQueryOptions, type UntrustServerInput, type UntrustServerParams, type UntrustServerTypedData, type UpdateSchemaIdParams, type UpdateSchemaIdResult, type UploadEncryptedFileResult, type UploadFileParams, type UploadFileResult, type UploadProgress, type UserFile, UserRejectedRequestError, type ValidationResult, type Validator, VanaNode as Vana, type VanaChain, type VanaChainConfig, type VanaChainId, type VanaConfig, type VanaContract, type VanaContract as VanaContractAbi, type VanaContractInstance, type VanaContractName, VanaCore, VanaError, VanaNode, type WalletConfig, __contractCache, chains, checkGrantAccess, clearContractCache, convertIpfsUrl, convertIpfsUrlWithFallbacks, createAndStoreGrant, createGrantFile, createValidatedGrant, decryptUserData, decryptWithPrivateKey, decryptWithWalletPrivateKey, VanaNode as default, encryptFileKey, encryptUserData, encryptWithWalletPublicKey, extractIpfsHash, fetchAndValidateSchema, fetchWithFallbacks, formatEth, formatNumber, formatToken, generateEncryptionKey, generateEncryptionKeyPair, generatePGPKeyPair, getAbi, getAllChains, getChainConfig, getContractAddress, getContractController, getContractInfo, getEncryptionParameters, getGatewayUrls, getGrantFileHash, getGrantTimeRemaining, handleRelayerRequest, isAPIResponse, isChainConfig, isGrantExpired, isIdentityServerOutput, isIpfsUrl, isPersonalServerOutput, isReplicateAPIResponse, isVanaChain, isVanaChainId, isWalletConfig, moksha, mokshaTestnet, parseReplicateOutput, retrieveAndValidateGrant, retrieveGrantFile, safeParseJSON, schemaValidator, shortenAddress, storeGrantFile, summarizeGrant, validateDataAgainstSchema, validateDataSchema, validateGrant, validateGrantExpiry, validateGrantFile, validateGranteeAccess, validateOperationAccess, vanaMainnet };