@vaultum/sdk 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,2203 @@
+import { Address, Hex, TypedDataDefinition } from 'viem';
+
+interface RetryConfig {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+}
+interface RequestContext {
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    body?: unknown;
+}
+interface ResponseContext {
+    status: number;
+    headers: Headers;
+    data: unknown;
+}
+type RequestInterceptor = (ctx: RequestContext) => RequestContext | Promise<RequestContext>;
+type ResponseInterceptor = (ctx: ResponseContext) => ResponseContext | Promise<ResponseContext>;
+interface VaultumConfig {
+    baseURL: string;
+    apiKey?: string;
+    bearer?: string;
+    chain?: string;
+    timeout?: number;
+    retry?: RetryConfig | boolean;
+    onRequest?: RequestInterceptor;
+    onResponse?: ResponseInterceptor;
+}
+interface ApiUser {
+    id: number;
+    email?: string | null;
+    name?: string | null;
+    is_admin?: boolean;
+}
+interface AuthTokenResponse<TUser = ApiUser> {
+    user: TUser;
+    token: string;
+    type: string;
+    abilities?: string[];
+    requires_wallet?: boolean;
+}
+interface AuthMeResponse<TUser = ApiUser> {
+    user: TUser;
+}
+interface LogoutResponse {
+    message: string;
+}
+interface WalletChallengeResponse {
+    message: string;
+    expiresAt: string;
+}
+interface UserWalletInfo {
+    address: Address;
+    chainId: number;
+    type: string;
+}
+interface WalletsResponse {
+    wallets: UserWalletInfo[];
+}
+interface PackedUserOperation {
+    sender: Address;
+    nonce: bigint;
+    initCode: Hex;
+    callData: Hex;
+    accountGasLimits: Hex;
+    preVerificationGas: bigint;
+    gasFees: Hex;
+    paymasterAndData: Hex;
+    signature: Hex;
+}
+interface UserOperation {
+    sender: Address;
+    nonce: Hex;
+    initCode: Hex;
+    callData: Hex;
+    callGasLimit: Hex;
+    verificationGasLimit: Hex;
+    preVerificationGas: Hex;
+    maxFeePerGas: Hex;
+    maxPriorityFeePerGas: Hex;
+    paymasterAndData: Hex;
+    signature: Hex;
+}
+interface UserOpGasLimits {
+    verificationGasLimit: bigint;
+    callGasLimit: bigint;
+    preVerificationGas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+}
+interface OperationResult {
+    id: string;
+    state: 'queued' | 'sent' | 'retrying' | 'success' | 'failed';
+    txHash?: Hex;
+    userOpHash?: Hex;
+    error?: string;
+}
+interface UserOpSimulationResponse {
+    ok: boolean;
+    result: Record<string, unknown>;
+    fallback?: string;
+}
+interface WaitOptions {
+    timeout?: number;
+    interval?: number;
+    signal?: AbortSignal;
+    onProgress?: (result: OperationResult) => void;
+}
+interface AccountCreateResult {
+    chain: string;
+    factory: Address;
+    address: Address;
+    config: {
+        owners: Address[];
+        threshold: number;
+        securityCouncil: Address;
+        salt: Hex;
+    };
+    userOp: Record<string, unknown>;
+}
+interface AccountVerifyResult {
+    address: Address;
+    exists: boolean;
+    owners: Address[];
+    threshold: number | null;
+    balance: string;
+    chain: string;
+    isSmartAccount: boolean;
+}
+interface VaultState {
+    address: Address;
+    chain: string;
+    owners: Address[];
+    threshold: number | null;
+    balanceWei: string;
+}
+interface FeatureInfo {
+    implementation: Address;
+    enabled: boolean;
+    mandatory: boolean;
+    reserved: string;
+}
+interface SessionKeyInfo {
+    wallet: Address;
+    sessionKey: Address;
+    chain: string;
+    manager: Address;
+    status: SessionKeyStatus | null;
+    info: {
+        expiry: string;
+        nonce: string;
+        maxValuePerCall: string;
+    } | null;
+    roles: Hex[];
+    tokenLimits: TokenLimitStatus[];
+}
+interface SessionKeyList {
+    wallet: Address;
+    chain: string;
+    manager: Address;
+    sessionKeys: Address[];
+}
+interface SessionKeyStatus {
+    active: boolean;
+    startTime: number;
+    expiry: number;
+    lastResetTime: number;
+    nonce: number;
+    maxValuePerCall: string;
+    paused: boolean;
+}
+interface TokenLimitStatus {
+    token: Address;
+    limit: string;
+    spent: string;
+    remaining: string;
+}
+interface SpendingLimitStatus {
+    wallet: Address;
+    chain: string;
+    manager: Address;
+    activeNativeLimits: Array<{
+        window: number;
+        amount: string;
+        available: string;
+        utilizationBps: string;
+    }>;
+}
+interface AllowlistStatus {
+    wallet: Address;
+    chain: string;
+    allowlistEnabled: boolean;
+    addressRoot: Hex | null;
+    selectorRoot: Hex | null;
+    manager: Address;
+}
+interface GuardianConfig {
+    wallet: Address;
+    chain: string;
+    guardians: Address[];
+    threshold: number | null;
+    timelock: number | null;
+    guardianSetHash: Hex | null;
+    manager: Address;
+}
+interface RecoveryProposal {
+    proposalId: Hex;
+    proposedOwner: Address;
+    executeAfter: number;
+    approvalCount: number;
+    executed: boolean;
+    active: boolean;
+}
+interface RecoveryStatus {
+    wallet: Address;
+    chain: string;
+    recoveryActive: boolean;
+    proposal: RecoveryProposal | null;
+    manager: Address;
+}
+interface AggregatedRecoveryStatus {
+    status: 'pending' | 'ready';
+    chain: string;
+    chainId: number;
+    wallet: Address;
+    proposedOwner: Address;
+    proposalId: Hex | null;
+    executeAfter: number | null;
+    guardianSetHash: Hex;
+    threshold: number;
+    validUntil: number;
+    collected: number;
+    guardians: Address[];
+}
+interface AggregatedRecoveryInitiateResponse {
+    status: 'initiated' | 'needs_onchain_initiation';
+    chain: string;
+    chainId: number;
+    wallet: Address;
+    proposedOwner: Address;
+    manager: Address;
+    proposalId: Hex | null;
+    executeAfter: number | null;
+    threshold: number;
+    timelock: number;
+    guardianSetHash: Hex;
+    guardianCount: number;
+    validUntil: number;
+    digest?: Hex;
+    initiateCalldata: Hex;
+}
+interface AggregatedRecoveryPrepareExecutionResponse {
+    wallet: Address;
+    proposedOwner: Address;
+    chain: string;
+    chainId: number;
+    proposalId: Hex;
+    executeAfter: number;
+    validUntil: number;
+    threshold: number;
+    signatures: Hex[];
+    ecdsaModule: Address;
+    userOp: Record<string, unknown>;
+    calldata?: Hex;
+}
+interface Proposal {
+    id: string;
+    wallet: Address;
+    chainId: number;
+    status: 'pending' | 'ready' | 'submitted' | 'cancelled' | 'failed';
+    threshold: number;
+    owners: Address[];
+    userOpHash: Hex;
+    calls: ProposalCall[];
+    executeAfter: string | null;
+    executeBefore: string | null;
+    createdAt: string;
+}
+interface ProposalsPage extends CursorPage {
+    proposals: Proposal[];
+}
+interface ProposalCall {
+    to: Address;
+    value?: string;
+    data: Hex;
+}
+interface ProposalSignature {
+    signer: Address;
+    signature: Hex;
+    createdAt: string;
+}
+interface ProposalDigest {
+    proposalId: string;
+    chainId: number;
+    wallet: Address;
+    userOpHash: Hex;
+    ethSignedMessageHash: Hex;
+}
+interface FinalizedProposal {
+    proposalId: string;
+    wallet: Address;
+    chainId: number;
+    userOpHash: Hex;
+    signature: Hex;
+    userOp: Record<string, unknown>;
+}
+interface SettlementTokens {
+    tokens: Array<{
+        symbol: string;
+        address: Address;
+        decimals: number;
+    }>;
+}
+interface SettlementQuote {
+    token: string;
+    tokenAmount: string;
+    gasCostWei: string;
+    exchangeRate: string;
+    validUntil: number;
+}
+type SwapRouteStepType = 'swap' | 'bridge';
+interface SwapRouteStep {
+    type: SwapRouteStepType;
+    protocol: string;
+    chainId: number;
+}
+interface SwapRoute {
+    routeId: string;
+    fromAmount: string;
+    toAmount: string;
+    toAmountMin: string;
+    gasEstimate?: string | null;
+    approvalRequired: boolean;
+    approvalSpender?: Address | null;
+    steps: SwapRouteStep[];
+}
+interface SwapQuotePayload {
+    quoteId: string;
+    expiresAt: string;
+    routes: SwapRoute[];
+}
+interface SwapQuoteResponse {
+    wallet: Address;
+    fromChain: string;
+    toChain: string;
+    quote: SwapQuotePayload;
+}
+interface SwapBuildMeta {
+    fromChainId: number;
+    toChainId: number;
+    fromToken: Address;
+    toToken: Address;
+    fromAmount: string;
+    toAmountMin: string;
+    steps: string[];
+}
+interface SwapBuildResponse {
+    userOp: Record<string, unknown>;
+    quoteId: string;
+    routeId: string;
+    routeHash: Hex;
+    meta: SwapBuildMeta;
+}
+interface CrossChainConfig {
+    wallet: Address;
+    chain: string;
+    registry: Address;
+    registered: boolean;
+    bridgePaused: boolean;
+    governanceDomainSeparator: Hex;
+    config: {
+        owners: Address[];
+        threshold: string;
+        securityCouncil: Address;
+        nonce: string;
+        lastUpdateTime: string;
+        active: boolean;
+    } | null;
+}
+interface CrossChainPendingProposal {
+    proposalId: Hex;
+    newOwners: Address[];
+    newThreshold: string;
+    executionTime: string;
+}
+interface RoleInfo {
+    wallet: Address;
+    roleId: Hex;
+    chain: string;
+    name: string;
+    targetBitmap: string;
+    selectorBitmap: string;
+    maxValue: string;
+}
+interface RoleBudget {
+    wallet: Address;
+    roleId: Hex;
+    chain: string;
+    budget: string;
+    spent: string;
+    remaining: string;
+}
+interface CursorPage {
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface AddressBookEntry {
+    id: number;
+    address: Address;
+    chainId: number;
+    label: string;
+    tags: string[];
+    notes: string | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+}
+interface AddressBookPage extends CursorPage {
+    entries: AddressBookEntry[];
+}
+type AutomationType = 'recurring_payment' | 'stop_loss' | 'dca' | 'rebalance';
+type AutomationStatus = 'active' | 'paused' | 'completed' | 'failed';
+interface Automation {
+    id: string;
+    wallet: Address;
+    type: AutomationType;
+    status: AutomationStatus;
+    sessionKey: Address | null;
+    config: Record<string, unknown>;
+    executionCount: number;
+    failureCount: number;
+    lastExecutedAt: string | null;
+    nextExecutionAt: string | null;
+    lastTxHash: Hex | null;
+    lastError: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+type AutomationExecutionStatus = 'pending' | 'success' | 'failed';
+interface AutomationExecution {
+    id: string;
+    status: AutomationExecutionStatus;
+    txHash: Hex | null;
+    error: string | null;
+    gasUsed: string | null;
+    createdAt: string;
+}
+interface AutomationResponse {
+    automation: Automation;
+}
+interface TriggerAutomationResponse extends AutomationResponse {
+    message: string;
+}
+interface AutomationPage extends CursorPage {
+    automations: Automation[];
+}
+interface AutomationDetails {
+    automation: Automation;
+    executions: AutomationExecution[];
+}
+interface UserOpResponse {
+    userOp: Record<string, unknown>;
+}
+interface EnabledFeature {
+    featureId: Hex;
+    name: string;
+    implementation: Address;
+    enabled: boolean;
+}
+interface FeatureConfig {
+    featureId: Hex;
+    implementation: Address;
+    enabled: boolean;
+    mandatory: boolean;
+    reserved: string;
+}
+interface SessionKeyCount {
+    wallet: Address;
+    chain: string;
+    count: number;
+}
+interface SessionKeyPolicySigner {
+    wallet: Address;
+    chain: string;
+    policySigner: Address;
+}
+interface SessionKeyRoles {
+    wallet: Address;
+    sessionKey: Address;
+    chain: string;
+    roles: Hex[];
+}
+interface SessionKeyTokenLimit {
+    wallet: Address;
+    sessionKey: Address;
+    token: Address;
+    chain: string;
+    limit: string;
+    spent: string;
+    remaining: string;
+}
+interface SpendingLimitSummary {
+    window: number;
+    limit: string;
+    spent: string;
+    remaining: string;
+    windowStart: number;
+    windowEnd: number;
+}
+interface SpendingLimitPreview {
+    wallet: Address;
+    chain: string;
+    nativeLimits: SpendingLimitSummary[];
+    tokenLimits: Array<{
+        token: Address;
+        limits: SpendingLimitSummary[];
+    }>;
+}
+interface SpendingLimitBucket {
+    wallet: Address;
+    chain: string;
+    windowStart: number;
+    native: string;
+    tokens: Record<Address, string>;
+}
+interface NativeLimitConfig {
+    wallet: Address;
+    chain: string;
+    window: number;
+    limit: string;
+    enabled: boolean;
+}
+interface NativeLimitStatus {
+    wallet: Address;
+    chain: string;
+    window: number;
+    limit: string;
+    spent: string;
+    remaining: string;
+    windowStart: number;
+    windowEnd: number;
+}
+interface TokenLimitConfig {
+    wallet: Address;
+    token: Address;
+    chain: string;
+    window: number;
+    limit: string;
+    enabled: boolean;
+}
+interface TokenLimitFullStatus {
+    wallet: Address;
+    token: Address;
+    chain: string;
+    window: number;
+    limit: string;
+    spent: string;
+    remaining: string;
+    windowStart: number;
+    windowEnd: number;
+}
+interface AllowlistRoots {
+    wallet: Address;
+    chain: string;
+    addressRoot: Hex;
+    selectorRoot: Hex;
+}
+interface ActorPermissions {
+    wallet: Address;
+    actor: Address;
+    chain: string;
+    permissions: Hex;
+}
+interface TokenMaxTransfer {
+    wallet: Address;
+    token: Address;
+    chain: string;
+    maxTransfer: string;
+}
+interface RecoveryGuardians {
+    wallet: Address;
+    chain: string;
+    guardians: Address[];
+    threshold: number;
+    guardianSetHash: Hex;
+}
+interface RecoveryProposalInfo {
+    wallet: Address;
+    chain: string;
+    hasProposal: boolean;
+    proposal: RecoveryProposal | null;
+}
+interface RecoveryProposalState {
+    wallet: Address;
+    chain: string;
+    state: 'none' | 'pending' | 'ready' | 'executed';
+}
+interface GuardianApproval {
+    wallet: Address;
+    guardian: Address;
+    chain: string;
+    approved: boolean;
+}
+interface IsGuardian {
+    wallet: Address;
+    guardian: Address;
+    chain: string;
+    isGuardian: boolean;
+}
+interface RecoveryStatusHint {
+    wallet: Address;
+    chain: string;
+    note: string;
+}
+type OnChainRecoveryStatus = RecoveryStatusHint;
+interface RolesInfo {
+    wallet: Address;
+    chain: string;
+    roles: RoleInfo[];
+}
+interface AccountRoles {
+    wallet: Address;
+    account: Address;
+    chain: string;
+    roles: Hex[];
+}
+interface ArmedStatus {
+    wallet: Address;
+    chain: string;
+    armed: boolean;
+}
+interface TargetIndex {
+    wallet: Address;
+    target: Address;
+    chain: string;
+    index: number;
+}
+interface SelectorIndex {
+    wallet: Address;
+    selector: Hex;
+    chain: string;
+    index: number;
+}
+interface HasRole {
+    wallet: Address;
+    account: Address;
+    roleId: Hex;
+    chain: string;
+    hasRole: boolean;
+}
+interface CrossChainReceiverState {
+    wallet: Address;
+    chain: string;
+    stateFresh: boolean;
+    lastSyncTime: number;
+}
+interface CrossChainSkipProposal {
+    wallet: Address;
+    chain: string;
+    skipProposal: boolean;
+}
+interface CrossChainGasLimit {
+    chainId: number;
+    gasLimit: string;
+}
+interface RegistryFeatures {
+    chain: string;
+    registry: Address;
+    featureIds: Hex[];
+    count: number;
+}
+interface RegistryVersion {
+    chain: string;
+    registry: Address;
+    version: string;
+}
+interface FeatureInternal {
+    chain: string;
+    registry: Address;
+    featureId: Hex;
+    internal: boolean;
+}
+interface ValidatorSelectorPermitted {
+    chain: string;
+    registry: Address;
+    validatorId: Hex;
+    selector: Hex;
+    permitted: boolean;
+}
+interface GloballyPaused {
+    wallet: Address;
+    chain: string;
+    registry: Address;
+    globallyPaused: boolean;
+}
+interface CanaryOptIn {
+    wallet: Address;
+    chain: string;
+    registry: Address;
+    canaryOptIn: boolean;
+}
+interface RegistryCapabilitySnapshot {
+    wallet: Address;
+    chain: string;
+    registry: Address;
+    capability_snapshot: Hex;
+}
+interface RegistryMandatoryInitData {
+    wallet: Address;
+    chain: string;
+    registry: Address;
+    feature_id: Hex;
+    init_data: Hex;
+}
+interface RegistryCoreModuleId {
+    chain: string;
+    registry: Address;
+    key: Hex;
+    module_id: Hex;
+}
+interface RegistrySlotAccess {
+    chain: string;
+    registry: Address;
+    feature_id: Hex;
+    slot: Hex;
+    allowed: boolean;
+}
+interface RegistrySupportsMigration {
+    chain: string;
+    registry: Address;
+    feature_id: Hex;
+    supports_migration: boolean;
+}
+interface RegistryIsFeatureImplementation {
+    chain: string;
+    registry: Address;
+    implementation: Address;
+    is_feature_implementation: boolean;
+}
+interface RegistryFeatureImplementation {
+    chain: string;
+    registry: Address;
+    feature_id: Hex;
+    implementation: Address;
+}
+interface RegistryFeatureImplementationForWallet {
+    wallet: Address;
+    chain: string;
+    registry: Address;
+    feature_id: Hex;
+    implementation: Address;
+}
+interface RegistryIsMandatoryFeature {
+    chain: string;
+    registry: Address;
+    feature_id: Hex;
+    mandatory: boolean;
+}
+interface RegistryEcdsaModule {
+    chain: string;
+    registry: Address;
+    ecdsa_module: Address;
+}
+interface RegistrySessionKeyManager {
+    chain: string;
+    registry: Address;
+    session_key_manager: Address;
+}
+interface RegistrySpendingLimitManager {
+    chain: string;
+    registry: Address;
+    spending_limit_manager: Address;
+}
+interface RegistryPermissionsManager {
+    chain: string;
+    registry: Address;
+    permissions_manager: Address;
+}
+interface UserOpTemplate {
+    chainId: number;
+    sender: Address;
+    nonce: string;
+    initCode: Hex;
+    callData: Hex;
+    accountGasLimits: Hex;
+    preVerificationGas: string;
+    gasFees: Hex;
+    paymasterAndData: Hex;
+}
+interface EIP712Template {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: Address;
+    };
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    primaryType: string;
+}
+interface TimestampValidation {
+    valid: boolean;
+    validAfter: number;
+    validUntil: number;
+    serverTime: number;
+}
+interface RelayEstimate {
+    gasLimit: string;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    estimatedCost: string;
+}
+interface RelayPreview {
+    chain: string;
+    chainId: number;
+    sender: Address;
+    sessionKey: Address | null;
+    approvalWitnessRequired: boolean;
+    approvalCallCount: number;
+    policySigner: Address | null;
+    policySignerConfigured: boolean;
+    policySignerError: string | null;
+    rejected: boolean;
+    reason?: string;
+}
+interface HealthStatus {
+    status: string;
+    timestamp: string;
+}
+type OperationState = 'queued' | 'sent' | 'success' | 'failed' | 'retrying';
+interface AccountOperation {
+    id: string;
+    state: OperationState;
+    chain: string;
+    txHash: Hex | null;
+    sender: Address | null;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AccountOperations extends CursorPage {
+    operations: AccountOperation[];
+    account: Address;
+    total: number;
+}
+interface AddressCapabilities {
+    chains: number[];
+    contracts: string[];
+}
+
+declare const API: {
+    readonly op: {
+        readonly submit: "/api/op/submit";
+        readonly simulate: "/api/op/simulate";
+        readonly capabilities: "/api/op/capabilities";
+        readonly status: (id: string) => string;
+        readonly wait: (id: string) => string;
+    };
+    readonly auth: {
+        readonly register: "/api/auth/register";
+        readonly login: "/api/auth/login";
+        readonly walletChallenge: "/api/auth/wallet/challenge";
+        readonly walletVerify: "/api/auth/wallet/verify";
+        readonly walletRegisterChallenge: "/api/auth/wallet/register/challenge";
+        readonly walletRegisterVerify: "/api/auth/wallet/register/verify";
+        readonly logout: "/api/auth/logout";
+        readonly logoutAll: "/api/auth/logout-all";
+        readonly me: "/api/auth/me";
+        readonly walletLinkChallenge: "/api/auth/wallet/link/challenge";
+        readonly walletLinkVerify: "/api/auth/wallet/link/verify";
+        readonly wallets: "/api/auth/wallets";
+    };
+    readonly accounts: {
+        readonly create: "/api/accounts";
+        readonly verify: "/api/accounts/verify";
+        readonly operations: "/api/accounts/operations";
+    };
+    readonly vault: {
+        readonly state: (wallet: Address) => string;
+        readonly features: (wallet: Address) => string;
+        readonly feature: (wallet: Address, featureId: string) => string;
+        readonly opNonce: (wallet: Address) => string;
+        readonly securityCouncil: (wallet: Address) => string;
+        readonly fallbackSigner: (wallet: Address) => string;
+        readonly paused: (wallet: Address) => string;
+        readonly l2Receiver: (wallet: Address) => string;
+        readonly tryExecute: "/api/vault/try-execute";
+        readonly pause: "/api/vault/pause";
+        readonly unpause: "/api/vault/unpause";
+        readonly setSecurityCouncil: "/api/vault/security-council";
+        readonly setFallbackSigner: "/api/vault/fallback-signer";
+        readonly overrideGlobalPause: "/api/vault/override-global-pause";
+    };
+    readonly sessionKey: {
+        readonly grant: "/api/sessionkey/grant";
+        readonly revoke: "/api/sessionkey/revoke";
+        readonly revokeAll: "/api/sessionkey/revoke-all";
+        readonly tokenLimits: "/api/sessionkey/token-limits";
+        readonly maxValuePerCall: "/api/sessionkey/max-value-per-call";
+        readonly sync: "/api/sessionkey/sync";
+        readonly list: (wallet: Address) => string;
+        readonly info: (wallet: Address, key: Address) => string;
+        readonly count: (wallet: Address) => string;
+        readonly policySigner: (wallet: Address) => string;
+        readonly roles: (wallet: Address, key: Address) => string;
+        readonly tokenLimit: (wallet: Address, key: Address, token: Address) => string;
+    };
+    readonly feature: {
+        readonly enable: "/api/feature/enable";
+        readonly disable: "/api/feature/disable";
+        readonly reset: "/api/feature/reset";
+        readonly spendingLimits: (wallet: Address) => string;
+        readonly allowlist: (wallet: Address) => string;
+        readonly guardians: (wallet: Address) => string;
+        readonly recovery: (wallet: Address) => string;
+        readonly roles: (wallet: Address) => string;
+        readonly accountRoles: (wallet: Address, account: Address) => string;
+    };
+    readonly spendingLimit: {
+        readonly enable: "/api/spending-limit/enable";
+        readonly disable: "/api/spending-limit/disable";
+        readonly update: "/api/spending-limit/update";
+        readonly enableToken: "/api/spending-limit/token/enable";
+        readonly disableToken: "/api/spending-limit/token/disable";
+        readonly updateToken: "/api/spending-limit/token/update";
+        readonly setSpendValidator: "/api/spending-limit/validator/set";
+        readonly status: (wallet: Address) => string;
+        readonly nativeSummaries: (wallet: Address) => string;
+        readonly tokenSummaries: (wallet: Address, token: Address) => string;
+        readonly preview: (wallet: Address) => string;
+        readonly bucket: (wallet: Address, windowStart: number) => string;
+        readonly nativeLimit: (wallet: Address, window: number) => string;
+        readonly nativeStatus: (wallet: Address, window: number) => string;
+        readonly tokenLimit: (wallet: Address, token: Address, window: number) => string;
+        readonly tokenStatus: (wallet: Address, token: Address, window: number) => string;
+    };
+    readonly allowlist: {
+        readonly enable: "/api/allowlist/enable";
+        readonly disable: "/api/allowlist/disable";
+        readonly contractOnly: "/api/allowlist/contract-only";
+        readonly roots: "/api/allowlist/roots";
+        readonly sync: "/api/allowlist/sync";
+        readonly transferLimit: "/api/allowlist/transfer-limit";
+        readonly actorPermissions: "/api/allowlist/actor/permissions";
+        readonly getRoots: (wallet: Address) => string;
+        readonly getActorPermissions: (wallet: Address, actor: Address) => string;
+        readonly tokenMaxTransfer: (wallet: Address, token: Address) => string;
+    };
+    readonly guardians: {
+        readonly configure: "/api/guardians/configure";
+    };
+    readonly recovery: {
+        readonly initiate: "/api/recovery/initiate";
+        readonly support: "/api/recovery/support";
+        readonly execute: "/api/recovery/execute";
+        readonly cancel: "/api/recovery/cancel";
+        readonly status: (wallet: Address) => string;
+        readonly guardians: (wallet: Address) => string;
+        readonly proposal: (wallet: Address) => string;
+        readonly proposalState: (wallet: Address) => string;
+        readonly guardianApproved: (wallet: Address, guardian: Address) => string;
+        readonly isGuardian: (wallet: Address, guardian: Address) => string;
+    };
+    readonly recoveryAggregated: {
+        readonly initiate: "/api/recovery/aggregated/initiate";
+        readonly signature: "/api/recovery/aggregated/signature";
+        readonly status: (wallet: Address, proposedOwner: Address) => string;
+        readonly prepare: "/api/recovery/aggregated/prepare";
+    };
+    readonly roles: {
+        readonly create: "/api/roles/create";
+        readonly createBatch: "/api/roles/create-batch";
+        readonly grant: "/api/roles/grant";
+        readonly revoke: "/api/roles/revoke";
+        readonly grantBatch: "/api/roles/grant-batch";
+        readonly revokeBatch: "/api/roles/revoke-batch";
+        readonly update: "/api/roles/update";
+        readonly grantMulti: "/api/roles/grant-multi";
+        readonly arm: "/api/roles/arm";
+        readonly armed: (wallet: Address) => string;
+        readonly targetIndex: (wallet: Address, target: Address) => string;
+        readonly selectorIndex: (wallet: Address, selector: string) => string;
+        readonly hasRole: (wallet: Address, account: Address, roleId: string) => string;
+        readonly budget: (wallet: Address, roleId: string) => string;
+        readonly setBudget: (wallet: Address, roleId: string) => string;
+        readonly show: (wallet: Address, roleId: string) => string;
+    };
+    readonly proposals: {
+        readonly list: "/api/proposals";
+        readonly due: "/api/proposals/due";
+        readonly create: "/api/proposals";
+        readonly show: (id: string) => string;
+        readonly digest: (id: string) => string;
+        readonly sign: (id: string) => string;
+        readonly finalize: (id: string) => string;
+        readonly cancel: (id: string) => string;
+    };
+    readonly crosschain: {
+        readonly config: (wallet: Address) => string;
+        readonly pendingProposals: (wallet: Address) => string;
+        readonly receiverStateFresh: (wallet: Address) => string;
+        readonly receiverSkipProposal: (wallet: Address) => string;
+        readonly gasLimit: (chainId: number) => string;
+        readonly proposeOwnerUpdate: "/api/crosschain/propose-owner-update";
+        readonly executeOwnerUpdate: "/api/crosschain/execute-owner-update";
+        readonly resync: "/api/crosschain/resync";
+    };
+    readonly settlement: {
+        readonly tokens: "/api/settlement/tokens";
+        readonly quote: "/api/settlement/quote";
+        readonly prepare: "/api/settlement/prepare";
+    };
+    readonly swap: {
+        readonly quote: "/api/swap/quote";
+        readonly build: "/api/swap/build";
+    };
+    readonly addressBook: {
+        readonly list: "/api/address-book";
+        readonly create: "/api/address-book";
+        readonly update: (id: number) => string;
+        readonly delete: (id: number) => string;
+    };
+    readonly automations: {
+        readonly list: "/api/automations";
+        readonly create: "/api/automations";
+        readonly show: (id: string) => string;
+        readonly update: (id: string) => string;
+        readonly delete: (id: string) => string;
+        readonly pause: (id: string) => string;
+        readonly resume: (id: string) => string;
+        readonly trigger: (id: string) => string;
+    };
+    readonly addresses: {
+        readonly capabilities: "/api/addresses/capabilities";
+        readonly all: (chainId: number) => string;
+        readonly get: (chainId: number, name: string) => string;
+    };
+    readonly signature: {
+        readonly timing: "/api/signature/timing";
+        readonly userOpTemplate: "/api/signature/userop-template";
+        readonly eip712Template: "/api/signature/eip712-template";
+        readonly validateTimestamp: "/api/signature/validate-timestamp";
+    };
+    readonly registry: {
+        readonly features: "/api/registry/features";
+        readonly version: "/api/registry/version";
+        readonly isInternal: (featureId: string) => string;
+        readonly canValidatorHandleSelector: (validatorId: string, selector: string) => string;
+        readonly coreModuleId: (key: string) => string;
+        readonly slotAccess: (featureId: string, slot: string) => string;
+        readonly supportsMigration: (featureId: string) => string;
+        readonly isFeatureImplementation: (impl: Address) => string;
+        readonly featureImplementation: (featureId: string) => string;
+        readonly featureImplementationForWallet: (wallet: Address, featureId: string) => string;
+        readonly isMandatoryFeature: (featureId: string) => string;
+        readonly ecdsaModule: "/api/registry/ecdsa-module";
+        readonly sessionKeyManager: "/api/registry/session-key-manager";
+        readonly spendingLimitManager: "/api/registry/spending-limit-manager";
+        readonly permissionsManager: "/api/registry/permissions-manager";
+        readonly globallyPaused: (wallet: Address) => string;
+        readonly canaryOptIn: (wallet: Address) => string;
+        readonly capabilitySnapshot: (wallet: Address) => string;
+        readonly mandatoryInitData: (wallet: Address, featureId: string) => string;
+        readonly setCanaryOptIn: "/api/registry/canary/opt-in";
+        readonly setMandatoryInitData: "/api/registry/mandatory-init-data";
+        readonly updateCapabilitySnapshot: "/api/registry/capability-snapshot";
+    };
+    readonly paymaster: {
+        readonly banStatus: (account: Address) => string;
+        readonly refundCredit: (wallet: Address, token: Address) => string;
+        readonly claimRefundCredit: "/api/paymaster/refund-credit/claim";
+    };
+    readonly config: {
+        readonly gasLimits: "/api/config/gas-limits";
+    };
+    readonly relay: {
+        readonly estimate: "/api/relay/estimate";
+        readonly preview: "/api/relay/preview";
+    };
+    readonly health: "/api/health";
+};
+interface QuoteResponseRaw {
+    gasLimits: {
+        verificationGasLimit: string;
+        callGasLimit: string;
+        preVerificationGas: string;
+        maxFeePerGas: string;
+        maxPriorityFeePerGas: string;
+    };
+    paymasterAndData: string;
+    sponsored: boolean;
+}
+interface QuoteResponse {
+    gasLimits: {
+        verificationGasLimit: bigint;
+        callGasLimit: bigint;
+        preVerificationGas: bigint;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+    };
+    paymasterAndData: string;
+    sponsored: boolean;
+}
+interface BanStatus {
+    account: string;
+    chain: string;
+    banned: boolean;
+}
+interface RefundCredit {
+    wallet: string;
+    token: string;
+    chain: string;
+    paymaster: string;
+    refund_credit: string;
+}
+interface Capabilities {
+    sponsored: boolean;
+    chainId: number;
+    entryPoint: string;
+}
+interface TimingConfig {
+    maxAge: number;
+    gracePeriod: number;
+    minValidAfter: number;
+}
+declare function parseQuoteResponse(raw: QuoteResponseRaw): QuoteResponse;
+
+type SDKErrorCode = 'INVALID_USEROP' | 'BUNDLER_ERROR' | 'RATE_LIMITED' | 'TIMEOUT' | 'UNAUTHORIZED' | 'NOT_FOUND' | 'FORBIDDEN' | 'INVALID_CONFIG' | 'VALIDATION_ERROR';
+declare class VaultumError extends Error {
+    code?: SDKErrorCode | undefined;
+    status?: number | undefined;
+    details?: unknown | undefined;
+    retryable: boolean;
+    constructor(message: string, code?: SDKErrorCode | undefined, status?: number | undefined, details?: unknown | undefined, retryable?: boolean);
+}
+declare class VaultumClient {
+    private baseURL;
+    private headers;
+    private timeout;
+    private chain?;
+    private retry;
+    private onRequest?;
+    private onResponse?;
+    constructor(config: VaultumConfig);
+    setBearer(token: string | null | undefined): void;
+    setApiKey(key: string | null | undefined): void;
+    setDefaultChain(chain: string | null | undefined): void;
+    request<T = unknown>(method: string, path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+        timestamp?: number;
+        headers?: Record<string, string>;
+        signal?: AbortSignal;
+        retry?: boolean;
+    }): Promise<T>;
+    submit(userOp: UserOperation | PackedUserOperation, options?: {
+        chain?: string;
+        idempotencyKey?: string;
+        timestamp?: number;
+        signal?: AbortSignal;
+    }): Promise<OperationResult>;
+    simulate(userOp: UserOperation | PackedUserOperation, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpSimulationResponse>;
+    authRegister(params: {
+        name: string;
+        email: string;
+        password: string;
+        signal?: AbortSignal;
+    }): Promise<AuthTokenResponse>;
+    authLogin(params: {
+        email: string;
+        password: string;
+        signal?: AbortSignal;
+    }): Promise<AuthTokenResponse>;
+    authMe(signal?: AbortSignal): Promise<AuthMeResponse>;
+    authLogout(signal?: AbortSignal): Promise<LogoutResponse>;
+    authLogoutAll(signal?: AbortSignal): Promise<LogoutResponse>;
+    walletChallenge(params: {
+        chain: string;
+        address: Address;
+        signal?: AbortSignal;
+    }): Promise<WalletChallengeResponse>;
+    walletVerify(params: {
+        chain: string;
+        address: Address;
+        signature: Hex;
+        signal?: AbortSignal;
+    }): Promise<AuthTokenResponse>;
+    walletRegisterChallenge(params: {
+        chain: string;
+        address: Address;
+        signal?: AbortSignal;
+    }): Promise<WalletChallengeResponse>;
+    walletRegisterVerify(params: {
+        chain: string;
+        address: Address;
+        signature: Hex;
+        name: string;
+        email: string;
+        signal?: AbortSignal;
+    }): Promise<AuthTokenResponse>;
+    walletLinkChallenge(params: {
+        chain: string;
+        address: Address;
+        signal?: AbortSignal;
+    }): Promise<WalletChallengeResponse>;
+    walletLinkVerify(params: {
+        chain: string;
+        address: Address;
+        signature: Hex;
+        signal?: AbortSignal;
+    }): Promise<WalletsResponse>;
+    wallets(signal?: AbortSignal): Promise<WalletsResponse>;
+    getOperation(id: string, signal?: AbortSignal): Promise<OperationResult>;
+    waitForOperation(id: string, options?: WaitOptions): Promise<OperationResult>;
+    getCapabilities(signal?: AbortSignal): Promise<Capabilities>;
+    createAccount(options: {
+        sessionKeyAddress: Address;
+        chain?: string;
+        salt?: Hex;
+        owners?: Address[];
+        threshold?: number;
+        securityCouncil?: Address;
+        modules?: Address[];
+        featureInits?: Array<{
+            featureId: Hex;
+            initData?: Hex;
+        }>;
+        signal?: AbortSignal;
+    }): Promise<AccountCreateResult>;
+    verifyAccount(address: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<AccountVerifyResult>;
+    getVaultState(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<VaultState>;
+    getNonce(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    getBanStatus(account: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<BanStatus>;
+    getRefundCredit(wallet: Address, token: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RefundCredit>;
+    buildClaimRefundCredit(params: {
+        wallet: Address;
+        token: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    getSessionKeyInfo(wallet: Address, key: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SessionKeyInfo>;
+    getSpendingLimitStatus(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SpendingLimitStatus>;
+    getAllowlistStatus(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<AllowlistStatus>;
+    getGuardians(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<GuardianConfig>;
+    getRecoveryStatus(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RecoveryStatus>;
+    getRecoveryStatusHint(account: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<OnChainRecoveryStatus>;
+    initiateAggregatedRecovery(params: {
+        wallet: Address;
+        proposedOwner: Address;
+        chain: string;
+        validUntil?: number;
+        signal?: AbortSignal;
+    }): Promise<AggregatedRecoveryInitiateResponse>;
+    submitRecoverySignature(params: {
+        wallet: Address;
+        proposedOwner: Address;
+        guardian: Address;
+        signature: Hex;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        status: string;
+        collected: number;
+        threshold: number;
+    }>;
+    getAggregatedRecoveryStatus(wallet: Address, proposedOwner: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<AggregatedRecoveryStatus>;
+    prepareAggregatedRecovery(params: {
+        wallet: Address;
+        proposedOwner: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<AggregatedRecoveryPrepareExecutionResponse>;
+    getProposals(options?: {
+        wallet?: Address;
+        status?: string;
+        limit?: number;
+        cursor?: string;
+        signal?: AbortSignal;
+    }): Promise<ProposalsPage>;
+    getDueProposals(options?: {
+        limit?: number;
+        cursor?: string;
+        signal?: AbortSignal;
+    }): Promise<ProposalsPage>;
+    createProposal(params: {
+        wallet: Address;
+        chain: string;
+        calls: ProposalCall[];
+        executeAfter?: string;
+        executeBefore?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        proposal: Proposal;
+        userOpHash: Hex;
+        moduleId: Hex;
+        threshold: number;
+        owners: Address[];
+    }>;
+    getProposal(id: string, signal?: AbortSignal): Promise<{
+        proposal: Proposal;
+        signatures: ProposalSignature[];
+    }>;
+    getProposalDigest(id: string, signal?: AbortSignal): Promise<ProposalDigest>;
+    signProposal(params: {
+        id: string;
+        signer: Address;
+        signature: Hex;
+        signal?: AbortSignal;
+    }): Promise<{
+        proposalId: string;
+        status: string;
+        collected: number;
+        threshold: number;
+    }>;
+    finalizeProposal(id: string, signal?: AbortSignal): Promise<FinalizedProposal>;
+    cancelProposal(id: string, signal?: AbortSignal): Promise<{
+        cancelled: boolean;
+    }>;
+    getSettlementTokens(options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SettlementTokens>;
+    getSettlementQuote(params: {
+        chain: string;
+        sender: Address;
+        token: 'USDC' | 'USDT';
+        maxGasCost: string;
+        maxFeePerGas: string;
+        signal?: AbortSignal;
+    }): Promise<SettlementQuote>;
+    prepareSettlement(params: {
+        chain: string;
+        token: 'USDC' | 'USDT';
+        userOp: UserOperation | PackedUserOperation | Record<string, unknown>;
+        idempotencyKey?: string;
+        timestamp?: number;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    swapQuote(params: {
+        wallet: Address;
+        fromChain: string;
+        toChain: string;
+        fromToken: Address;
+        toToken: Address;
+        amount: string;
+        slippageBps: number;
+        deadlineSeconds: number;
+        allowBridges?: string[];
+        allowDexes?: string[];
+        signal?: AbortSignal;
+    }): Promise<SwapQuoteResponse>;
+    swapBuild(params: {
+        wallet: Address;
+        fromChain: string;
+        toChain: string;
+        quoteId: string;
+        routeId: string;
+        slippageBps: number;
+        signal?: AbortSignal;
+    }): Promise<SwapBuildResponse>;
+    getCrossChainConfig(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<CrossChainConfig>;
+    getCrossChainPendingProposals(wallet: Address, options?: {
+        chain?: string;
+        lookbackBlocks?: number;
+        max?: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        pendingProposals: CrossChainPendingProposal[];
+    }>;
+    buildSessionKeyGrant(params: {
+        wallet: Address;
+        sessionKey: Address;
+        chain: string;
+        expiry: number;
+        startTime?: number;
+        targets?: Address[];
+        selectors?: Hex[];
+        roles?: Hex[];
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSessionKeyRevoke(params: {
+        wallet: Address;
+        sessionKey: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildEnableFeature(params: {
+        wallet: Address;
+        featureId: Hex;
+        chain: string;
+        initData?: Hex;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildDisableFeature(params: {
+        wallet: Address;
+        featureId: Hex;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildResetFeatureInitialization(params: {
+        wallet: Address;
+        featureId: Hex;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildTryExecute(params: {
+        wallet: Address;
+        chain: string;
+        calls: Array<{
+            to: Address;
+            value?: number;
+            data: Hex;
+        }>;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildConfigureGuardians(params: {
+        wallet: Address;
+        chain: string;
+        guardians: Address[];
+        threshold: number;
+        timelock: number;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    getAddressBook(options?: {
+        chain?: string;
+        limit?: number;
+        cursor?: string;
+        signal?: AbortSignal;
+    }): Promise<AddressBookPage>;
+    createAddressBookEntry(params: {
+        chain: string;
+        label: string;
+        address: Address;
+        tags?: string[];
+        notes?: string;
+        signal?: AbortSignal;
+    }): Promise<AddressBookEntry>;
+    updateAddressBookEntry(id: number, params: {
+        label?: string;
+        tags?: string[];
+        notes?: string | null;
+        signal?: AbortSignal;
+    }): Promise<AddressBookEntry>;
+    deleteAddressBookEntry(id: number, signal?: AbortSignal): Promise<void>;
+    getAutomations(params: {
+        wallet: Address;
+        limit?: number;
+        cursor?: string;
+        signal?: AbortSignal;
+    }): Promise<AutomationPage>;
+    createAutomation(params: {
+        wallet: Address;
+        type: Automation['type'];
+        config: Record<string, unknown>;
+        sessionKey?: Address;
+        signal?: AbortSignal;
+    }): Promise<Automation>;
+    getAutomation(id: string, signal?: AbortSignal): Promise<AutomationDetails>;
+    pauseAutomation(id: string, signal?: AbortSignal): Promise<Automation>;
+    resumeAutomation(id: string, signal?: AbortSignal): Promise<Automation>;
+    deleteAutomation(id: string, signal?: AbortSignal): Promise<void>;
+    getContractAddresses(chainId: number, signal?: AbortSignal): Promise<Record<string, Address>>;
+    getContractAddress(chainId: number, name: string, signal?: AbortSignal): Promise<{
+        address: Address;
+        chain_id: number;
+        contract_name: string;
+    }>;
+    getTimingConfig(signal?: AbortSignal): Promise<TimingConfig>;
+    getGasLimits(signal?: AbortSignal): Promise<Record<string, unknown>>;
+    getAccountOperations(options: {
+        account: Address;
+        chain?: string;
+        state?: string;
+        limit?: number;
+        cursor?: string;
+        signal?: AbortSignal;
+    }): Promise<AccountOperations>;
+    getEnabledFeatures(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        features: EnabledFeature[];
+    }>;
+    getFeatureConfig(wallet: Address, featureId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<FeatureConfig>;
+    getSecurityCouncil(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        wallet: Address;
+        chain: string;
+        securityCouncil: Address;
+    }>;
+    getFallbackSigner(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        wallet: Address;
+        chain: string;
+        fallbackSigner: Address;
+    }>;
+    isPaused(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        wallet: Address;
+        chain: string;
+        paused: boolean;
+    }>;
+    getL2Receiver(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        wallet: Address;
+        chain: string;
+        receiver: Address;
+    }>;
+    buildPauseCore(params: {
+        wallet: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildUnpauseCore(params: {
+        wallet: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetSecurityCouncil(params: {
+        wallet: Address;
+        chain: string;
+        securityCouncil: Address;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetFallbackSigner(params: {
+        wallet: Address;
+        chain: string;
+        fallbackSigner: Address;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildOverrideGlobalPause(params: {
+        wallet: Address;
+        chain: string;
+        override: boolean;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    getSessionKeyCount(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SessionKeyCount>;
+    getSessionKeyPolicySigner(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SessionKeyPolicySigner>;
+    getSessionKeyRoles(wallet: Address, sessionKey: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SessionKeyRoles>;
+    getSessionKeyTokenLimit(wallet: Address, sessionKey: Address, token: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SessionKeyTokenLimit>;
+    buildRevokeAllSessionKeys(params: {
+        wallet: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetSessionKeyTokenLimits(params: {
+        wallet: Address;
+        sessionKey: Address;
+        chain: string;
+        limits: Array<{
+            token: Address;
+            limit: string;
+        }>;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetMaxValuePerCall(params: {
+        wallet: Address;
+        sessionKey: Address;
+        chain: string;
+        maxValue: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSyncSessionKey(params: {
+        wallet: Address;
+        sessionKey: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    getFeatureSessionKeys(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SessionKeyList>;
+    getFeatureSpendingLimits(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SpendingLimitStatus>;
+    getFeatureRoles(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RolesInfo>;
+    getAccountRoles(wallet: Address, account: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<AccountRoles>;
+    getNativeSpendingSummaries(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        wallet: Address;
+        chain: string;
+        summaries: SpendingLimitSummary[];
+    }>;
+    getTokenSpendingSummaries(wallet: Address, token: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        wallet: Address;
+        token: Address;
+        chain: string;
+        summaries: SpendingLimitSummary[];
+    }>;
+    getSpendingPreview(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SpendingLimitPreview>;
+    getSpendingBucket(wallet: Address, windowStart: number, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SpendingLimitBucket>;
+    getNativeLimit(wallet: Address, window: number, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<NativeLimitConfig>;
+    getNativeLimitStatus(wallet: Address, window: number, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<NativeLimitStatus>;
+    getTokenLimit(wallet: Address, token: Address, window: number, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<TokenLimitConfig>;
+    getTokenLimitStatus(wallet: Address, token: Address, window: number, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<TokenLimitFullStatus>;
+    buildEnableSpendingLimit(params: {
+        wallet: Address;
+        chain: string;
+        window: number;
+        limit: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildDisableSpendingLimit(params: {
+        wallet: Address;
+        chain: string;
+        window: number;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildUpdateSpendingLimit(params: {
+        wallet: Address;
+        chain: string;
+        window: number;
+        limit: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildEnableTokenSpendingLimit(params: {
+        wallet: Address;
+        chain: string;
+        token: Address;
+        window: number;
+        limit: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildDisableTokenSpendingLimit(params: {
+        wallet: Address;
+        chain: string;
+        token: Address;
+        window: number;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildUpdateTokenSpendingLimit(params: {
+        wallet: Address;
+        chain: string;
+        token: Address;
+        window: number;
+        limit: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetSpendValidator(params: {
+        wallet: Address;
+        chain: string;
+        target: Address;
+        selector: Hex;
+        module: Address;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    getAllowlistRoots(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<AllowlistRoots>;
+    getActorPermissions(wallet: Address, actor: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<ActorPermissions>;
+    getTokenMaxTransfer(wallet: Address, token: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<TokenMaxTransfer>;
+    buildEnableAllowlist(params: {
+        wallet: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildDisableAllowlist(params: {
+        wallet: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildEnableContractOnly(params: {
+        wallet: Address;
+        chain: string;
+        enabled: boolean;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetAllowlistRoots(params: {
+        wallet: Address;
+        chain: string;
+        addressRoot: Hex;
+        selectorRoot: Hex;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSyncAllowlist(params: {
+        wallet: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetMaxTransferAmount(params: {
+        wallet: Address;
+        chain: string;
+        token: Address;
+        maxAmount: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetActorPermissions(params: {
+        wallet: Address;
+        chain: string;
+        actor: Address;
+        permissions: Hex;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    getRecoveryGuardians(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RecoveryGuardians>;
+    getRecoveryProposal(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RecoveryProposalInfo>;
+    getRecoveryProposalState(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RecoveryProposalState>;
+    hasGuardianApproved(wallet: Address, guardian: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<GuardianApproval>;
+    isGuardian(wallet: Address, guardian: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<IsGuardian>;
+    buildInitiateRecovery(params: {
+        wallet: Address;
+        chain: string;
+        proposedOwner: Address;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSupportRecovery(params: {
+        wallet: Address;
+        chain: string;
+        guardian: Address;
+        signature: Hex;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildExecuteRecovery(params: {
+        wallet: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildCancelRecovery(params: {
+        wallet: Address;
+        chain: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    getArmedStatus(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<ArmedStatus>;
+    getTargetIndex(wallet: Address, target: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<TargetIndex>;
+    getSelectorIndex(wallet: Address, selector: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<SelectorIndex>;
+    hasRole(wallet: Address, account: Address, roleId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<HasRole>;
+    getRoleBudget(wallet: Address, roleId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RoleBudget>;
+    getRole(wallet: Address, roleId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RoleInfo>;
+    buildCreateRole(params: {
+        wallet: Address;
+        chain: string;
+        roleId: Hex;
+        name: string;
+        targetBitmap: string;
+        selectorBitmap: string;
+        maxValue?: number;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildCreateRolesBatch(params: {
+        wallet: Address;
+        chain: string;
+        roles: Array<{
+            roleId: Hex;
+            name: string;
+            targetBitmap: string;
+            selectorBitmap: string;
+            maxValue?: string | number;
+        }>;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildGrantRole(params: {
+        wallet: Address;
+        chain: string;
+        account: Address;
+        roleId: Hex;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildRevokeRole(params: {
+        wallet: Address;
+        chain: string;
+        account: Address;
+        roleId: Hex;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildGrantRolesBatch(params: {
+        wallet: Address;
+        chain: string;
+        grants: Array<{
+            account: Address;
+            roleId: Hex;
+        }>;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildRevokeRolesBatch(params: {
+        wallet: Address;
+        chain: string;
+        revokes: Array<{
+            account: Address;
+            roleId: Hex;
+        }>;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildUpdateRole(params: {
+        wallet: Address;
+        chain: string;
+        roleId: Hex;
+        name: string;
+        targetBitmap: string;
+        selectorBitmap: string;
+        maxValue: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetRoleBitmap(params: {
+        wallet: Address;
+        chain: string;
+        roleId: Hex;
+        targetBitmap: string;
+        selectorBitmap: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildGrantRolesMultiAccount(params: {
+        wallet: Address;
+        chain: string;
+        accounts: Address[];
+        roleIds: Hex[];
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildArmRoles(params: {
+        wallet: Address;
+        chain: string;
+        armed: boolean;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetRoleBudget(params: {
+        wallet: Address;
+        chain: string;
+        roleId: Hex;
+        budget: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    getCrossChainReceiverState(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<CrossChainReceiverState>;
+    getCrossChainSkipProposal(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<CrossChainSkipProposal>;
+    getCrossChainGasLimit(chainId: number, signal?: AbortSignal): Promise<CrossChainGasLimit>;
+    buildProposeOwnerUpdate(params: {
+        wallet: Address;
+        chain: string;
+        newOwners: Address[];
+        newThreshold: number;
+        targetChains: number[];
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildExecuteOwnerUpdate(params: {
+        wallet: Address;
+        chain: string;
+        proposalId: Hex;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildResyncL2(params: {
+        wallet: Address;
+        chain: string;
+        targetChain: number;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    updateAutomation(id: string, params: {
+        sessionKey?: Address | null;
+        config?: Record<string, unknown>;
+        signal?: AbortSignal;
+    }): Promise<Automation>;
+    triggerAutomation(id: string, signal?: AbortSignal): Promise<TriggerAutomationResponse>;
+    getAddressCapabilities(signal?: AbortSignal): Promise<AddressCapabilities>;
+    getUserOpTemplate(options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<UserOpTemplate>;
+    getEIP712Template(options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<EIP712Template>;
+    validateTimestamp(params: {
+        validAfter: number;
+        validUntil: number;
+        signal?: AbortSignal;
+    }): Promise<TimestampValidation>;
+    getRegistryFeatures(options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryFeatures>;
+    getRegistryVersion(options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryVersion>;
+    isFeatureInternal(featureId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<FeatureInternal>;
+    canValidatorHandleSelector(validatorId: Hex, selector: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<ValidatorSelectorPermitted>;
+    getRegistryCoreModuleId(key: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryCoreModuleId>;
+    canAccessRegistrySlot(featureId: Hex, slot: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistrySlotAccess>;
+    registrySupportsMigration(featureId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistrySupportsMigration>;
+    isRegistryFeatureImplementation(impl: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryIsFeatureImplementation>;
+    getRegistryFeatureImplementation(featureId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryFeatureImplementation>;
+    getRegistryFeatureImplementationForWallet(wallet: Address, featureId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryFeatureImplementationForWallet>;
+    isRegistryMandatoryFeature(featureId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryIsMandatoryFeature>;
+    getRegistryEcdsaModule(options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryEcdsaModule>;
+    getRegistrySessionKeyManager(options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistrySessionKeyManager>;
+    getRegistrySpendingLimitManager(options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistrySpendingLimitManager>;
+    getRegistryPermissionsManager(options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryPermissionsManager>;
+    getRegistryCapabilitySnapshot(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryCapabilitySnapshot>;
+    getRegistryMandatoryInitData(wallet: Address, featureId: Hex, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<RegistryMandatoryInitData>;
+    buildSetRegistryCanaryOptIn(params: {
+        wallet: Address;
+        chain: string;
+        optIn: boolean;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildSetRegistryMandatoryInitData(params: {
+        wallet: Address;
+        chain: string;
+        featureId: Hex;
+        initData: Hex;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    buildUpdateRegistryCapabilitySnapshot(params: {
+        wallet: Address;
+        chain: string;
+        snapshot: Hex;
+        signal?: AbortSignal;
+    }): Promise<UserOpResponse>;
+    isGloballyPaused(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<GloballyPaused>;
+    isCanaryOptIn(wallet: Address, options?: {
+        chain?: string;
+        signal?: AbortSignal;
+    }): Promise<CanaryOptIn>;
+    estimateRelay(params: {
+        chain: string;
+        userOp: Record<string, unknown>;
+        signal?: AbortSignal;
+    }): Promise<RelayEstimate>;
+    previewRelay(params: {
+        chain: string;
+        userOp: Record<string, unknown>;
+        signal?: AbortSignal;
+    }): Promise<RelayPreview>;
+    getHealth(signal?: AbortSignal): Promise<HealthStatus>;
+}
+
+interface UserOpBuilderConfig {
+    account: Address;
+    chainId: number;
+    entryPoint?: Address;
+}
+interface ExecuteCall {
+    target: Address;
+    value: bigint;
+    data: Hex;
+}
+declare function packGasLimits(verificationGasLimit: bigint, callGasLimit: bigint): Hex;
+declare function unpackGasLimits(packed: Hex): {
+    verificationGasLimit: bigint;
+    callGasLimit: bigint;
+};
+declare function packGasFees(maxPriorityFeePerGas: bigint, maxFeePerGas: bigint): Hex;
+declare function unpackGasFees(packed: Hex): {
+    maxPriorityFeePerGas: bigint;
+    maxFeePerGas: bigint;
+};
+declare function getUserOpHash(userOp: PackedUserOperation, entryPoint: Address, chainId: number): Hex;
+declare class UserOpBuilder {
+    private account;
+    private chainId;
+    private entryPoint;
+    constructor(config: UserOpBuilderConfig);
+    create(callData: Hex, nonce: bigint): PackedUserOperation;
+    encodeExecute(call: ExecuteCall): Hex;
+    encodeExecuteBatch(calls: ExecuteCall[]): Hex;
+    encodeEnableFeature(featureId: Hex, initData: Hex): Hex;
+    encodeDisableFeature(featureId: Hex): Hex;
+    buildExecute(call: ExecuteCall, nonce: bigint): PackedUserOperation;
+    buildExecuteBatch(calls: ExecuteCall[], nonce: bigint): PackedUserOperation;
+    buildEnableFeature(featureId: Hex, initData: Hex, nonce: bigint): PackedUserOperation;
+    buildDisableFeature(featureId: Hex, nonce: bigint): PackedUserOperation;
+    withGas(userOp: PackedUserOperation, gas: Partial<UserOpGasLimits>): PackedUserOperation;
+    withPaymaster(userOp: PackedUserOperation, paymasterAndData: Hex): PackedUserOperation;
+    withSignature(userOp: PackedUserOperation, signature: Hex): PackedUserOperation;
+    getHash(userOp: PackedUserOperation): Hex;
+}
+declare function createUserOpBuilder(config: UserOpBuilderConfig): UserOpBuilder;
+
+declare const ENTRYPOINT_V07: "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+declare const FEATURE_ID_STRINGS: {
+    readonly MODULE_ECDSA_VALIDATION: "module.validation.ecdsa";
+    readonly MODULE_SESSION_KEY_VALIDATION: "module.validation.session_key";
+    readonly FEATURE_SESSION_KEYS: "feature.session_keys";
+    readonly FEATURE_SPENDING_LIMIT: "feature.spending_limit";
+    readonly FEATURE_APPROVAL_LIMIT: "feature.approval_limit";
+    readonly FEATURE_PERMISSIONS: "feature.permissions";
+    readonly FEATURE_SOCIAL_RECOVERY: "feature.social_recovery";
+    readonly FEATURE_PAYMASTER_GUARD: "feature.paymaster_guard";
+};
+declare const FEATURE_IDS: Record<keyof typeof FEATURE_ID_STRINGS, Hex>;
+declare const CONTRACTS: {
+    readonly VAULTUM_CORE: "VaultumCore";
+    readonly VAULTUM_FACTORY: "VaultumAccountFactory";
+    readonly FEATURE_REGISTRY: "FeatureRegistry";
+    readonly IMPLEMENTATION_REGISTRY: "ImplementationRegistry";
+    readonly SESSION_KEY_MANAGER: "SessionKeyManager";
+    readonly SPENDING_LIMIT_MANAGER: "SpendingLimitManager";
+    readonly PERMISSIONS_MANAGER: "PermissionsManager";
+    readonly SOCIAL_RECOVERY_MANAGER: "SocialRecoveryManager";
+    readonly PAYMASTER_GUARD: "PaymasterGuard";
+    readonly ECDSA_VALIDATION_MODULE: "ECDSAValidationModuleSingleton";
+    readonly SESSION_KEY_VALIDATION_MODULE: "SessionKeyValidationModuleSingleton";
+    readonly VAULTUM_SETTLEMENT_PAYMASTER: "VaultumSettlementPaymaster";
+};
+type ContractName = (typeof CONTRACTS)[keyof typeof CONTRACTS];
+
+declare const GOVERNANCE_DOMAIN_NAME = "VaultumGovernance";
+declare const GOVERNANCE_DOMAIN_VERSION = "1";
+type CrossChainRootTypedMessage = {
+    merkleRoot: Hex;
+    nonce: bigint;
+    validUntil: bigint;
+};
+interface CrossChainRootTypedDataParams {
+    merkleRoot: Hex;
+    nonce: bigint;
+    validUntil: bigint;
+    registry: Address;
+    chainId: number;
+}
+declare function buildCrossChainRootTypedData(params: CrossChainRootTypedDataParams): TypedDataDefinition;
+declare function hashCrossChainRootTypedData(params: CrossChainRootTypedDataParams): Hex;
+
+declare const VERSION: string;
+
+export { API, type AccountCreateResult, type AccountOperation, type AccountOperations, type AccountRoles, type AccountVerifyResult, type ActorPermissions, type AddressBookEntry, type AddressBookPage, type AddressCapabilities, type AggregatedRecoveryInitiateResponse, type AggregatedRecoveryPrepareExecutionResponse, type AggregatedRecoveryStatus, type AllowlistRoots, type AllowlistStatus, type ApiUser, type ArmedStatus, type AuthMeResponse, type AuthTokenResponse, type Automation, type AutomationDetails, type AutomationExecution, type AutomationExecutionStatus, type AutomationPage, type AutomationResponse, type AutomationStatus, type AutomationType, type BanStatus, CONTRACTS, type CanaryOptIn, type Capabilities, type ContractName, type CrossChainConfig, type CrossChainGasLimit, type CrossChainPendingProposal, type CrossChainReceiverState, type CrossChainRootTypedDataParams, type CrossChainRootTypedMessage, type CrossChainSkipProposal, type CursorPage, type EIP712Template, ENTRYPOINT_V07, type EnabledFeature, type ExecuteCall, FEATURE_IDS, FEATURE_ID_STRINGS, type FeatureConfig, type FeatureInfo, type FeatureInternal, type FinalizedProposal, GOVERNANCE_DOMAIN_NAME, GOVERNANCE_DOMAIN_VERSION, type GloballyPaused, type GuardianApproval, type GuardianConfig, type HasRole, type HealthStatus, type IsGuardian, type LogoutResponse, type NativeLimitConfig, type NativeLimitStatus, type OnChainRecoveryStatus, type OperationResult, type OperationState, type PackedUserOperation, type Proposal, type ProposalCall, type ProposalDigest, type ProposalSignature, type ProposalsPage, type QuoteResponse, type QuoteResponseRaw, type RecoveryGuardians, type RecoveryProposal, type RecoveryProposalInfo, type RecoveryProposalState, type RecoveryStatus, type RegistryFeatures, type RegistryVersion, type RelayEstimate, type RequestContext, type RequestInterceptor, type ResponseContext, type ResponseInterceptor, type RetryConfig, type RoleBudget, type RoleInfo, type RolesInfo, type SDKErrorCode, type SelectorIndex, type SessionKeyCount, type SessionKeyInfo, type SessionKeyList, type SessionKeyPolicySigner, type SessionKeyRoles, type SessionKeyStatus, type SessionKeyTokenLimit, type SettlementQuote, type SettlementTokens, type SpendingLimitBucket, type SpendingLimitPreview, type SpendingLimitStatus, type SpendingLimitSummary, type TargetIndex, type TimestampValidation, type TimingConfig, type TokenLimitConfig, type TokenLimitFullStatus, type TokenLimitStatus, type TokenMaxTransfer, type TriggerAutomationResponse, UserOpBuilder, type UserOpBuilderConfig, type UserOpGasLimits, type UserOpResponse, type UserOpSimulationResponse, type UserOpTemplate, type UserOperation, type UserWalletInfo, VERSION, type ValidatorSelectorPermitted, type VaultState, VaultumClient, type VaultumConfig, VaultumError, type WaitOptions, type WalletChallengeResponse, type WalletsResponse, buildCrossChainRootTypedData, createUserOpBuilder, getUserOpHash, hashCrossChainRootTypedData, packGasFees, packGasLimits, parseQuoteResponse, unpackGasFees, unpackGasLimits };