@gitmyabi/safe 1.0.146 → 1.0.147

package/contracts/Safe_json.d.ts

@@ -0,0 +1,1617 @@
+import type { Address, PublicClient, WalletClient } from 'viem';
+/**
+ * Safe_json ABI
+ *
+ * This ABI is typed using viem's type system for full type safety.
+ */
+export declare const Safe_jsonAbi: readonly [{
+    readonly inputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "AddedOwner";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "approvedHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "ApproveHash";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "handler";
+        readonly type: "address";
+    }];
+    readonly name: "ChangedFallbackHandler";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "guard";
+        readonly type: "address";
+    }];
+    readonly name: "ChangedGuard";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "moduleGuard";
+        readonly type: "address";
+    }];
+    readonly name: "ChangedModuleGuard";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "threshold";
+        readonly type: "uint256";
+    }];
+    readonly name: "ChangedThreshold";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "module";
+        readonly type: "address";
+    }];
+    readonly name: "DisabledModule";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "module";
+        readonly type: "address";
+    }];
+    readonly name: "EnabledModule";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "txHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "payment";
+        readonly type: "uint256";
+    }];
+    readonly name: "ExecutionFailure";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "module";
+        readonly type: "address";
+    }];
+    readonly name: "ExecutionFromModuleFailure";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "module";
+        readonly type: "address";
+    }];
+    readonly name: "ExecutionFromModuleSuccess";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "txHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "payment";
+        readonly type: "uint256";
+    }];
+    readonly name: "ExecutionSuccess";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "RemovedOwner";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "SafeReceived";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "initiator";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address[]";
+        readonly name: "owners";
+        readonly type: "address[]";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "threshold";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "initializer";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "fallbackHandler";
+        readonly type: "address";
+    }];
+    readonly name: "SafeSetup";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "msgHash";
+        readonly type: "bytes32";
+    }];
+    readonly name: "SignMsg";
+    readonly type: "event";
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "fallback";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "VERSION";
+    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 internalType: "uint256";
+        readonly name: "_threshold";
+        readonly type: "uint256";
+    }];
+    readonly name: "addOwnerWithThreshold";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "hashToApprove";
+        readonly type: "bytes32";
+    }];
+    readonly name: "approveHash";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly name: "approvedHashes";
+    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: "_threshold";
+        readonly type: "uint256";
+    }];
+    readonly name: "changeThreshold";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "signatures";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "requiredSignatures";
+        readonly type: "uint256";
+    }];
+    readonly name: "checkNSignatures";
+    readonly outputs: readonly [];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "executor";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "signatures";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "requiredSignatures";
+        readonly type: "uint256";
+    }];
+    readonly name: "checkNSignatures";
+    readonly outputs: readonly [];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "signatures";
+        readonly type: "bytes";
+    }];
+    readonly name: "checkSignatures";
+    readonly outputs: readonly [];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "executor";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "signatures";
+        readonly type: "bytes";
+    }];
+    readonly name: "checkSignatures";
+    readonly outputs: readonly [];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "prevModule";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "module";
+        readonly type: "address";
+    }];
+    readonly name: "disableModule";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "domainSeparator";
+    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: "module";
+        readonly type: "address";
+    }];
+    readonly name: "enableModule";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    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 internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "enum Enum.Operation";
+        readonly name: "operation";
+        readonly type: "uint8";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "safeTxGas";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "baseGas";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "gasPrice";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "gasToken";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address payable";
+        readonly name: "refundReceiver";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "signatures";
+        readonly type: "bytes";
+    }];
+    readonly name: "execTransaction";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "success";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "payable";
+    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 internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "enum Enum.Operation";
+        readonly name: "operation";
+        readonly type: "uint8";
+    }];
+    readonly name: "execTransactionFromModule";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "success";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    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 internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "enum Enum.Operation";
+        readonly name: "operation";
+        readonly type: "uint8";
+    }];
+    readonly name: "execTransactionFromModuleReturnData";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "success";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "returnData";
+        readonly type: "bytes";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "start";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "pageSize";
+        readonly type: "uint256";
+    }];
+    readonly name: "getModulesPaginated";
+    readonly outputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "array";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "address";
+        readonly name: "next";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getOwners";
+    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: "offset";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "length";
+        readonly type: "uint256";
+    }];
+    readonly name: "getStorageAt";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getThreshold";
+    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 internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "enum Enum.Operation";
+        readonly name: "operation";
+        readonly type: "uint8";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "safeTxGas";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "baseGas";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "gasPrice";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "gasToken";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "refundReceiver";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_nonce";
+        readonly type: "uint256";
+    }];
+    readonly name: "getTransactionHash";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "txHash";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "module";
+        readonly type: "address";
+    }];
+    readonly name: "isModuleEnabled";
+    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 name: "isOwner";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "nonce";
+    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: "prevOwner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_threshold";
+        readonly type: "uint256";
+    }];
+    readonly name: "removeOwner";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "handler";
+        readonly type: "address";
+    }];
+    readonly name: "setFallbackHandler";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "guard";
+        readonly type: "address";
+    }];
+    readonly name: "setGuard";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "moduleGuard";
+        readonly type: "address";
+    }];
+    readonly name: "setModuleGuard";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "_owners";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_threshold";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "address";
+        readonly name: "fallbackHandler";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "paymentToken";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "payment";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address payable";
+        readonly name: "paymentReceiver";
+        readonly type: "address";
+    }];
+    readonly name: "setup";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly name: "signedMessages";
+    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: "targetContract";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "calldataPayload";
+        readonly type: "bytes";
+    }];
+    readonly name: "simulateAndRevert";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "prevOwner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "oldOwner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "swapOwner";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly stateMutability: "payable";
+    readonly type: "receive";
+}];
+/**
+ * Type-safe ABI for Safe_json
+ */
+export type Safe_jsonAbi = typeof Safe_jsonAbi;
+/**
+ * Contract instance type for Safe_json
+ */
+export type Safe_jsonContract = any;
+/**
+ * Safe_json Contract Class
+ *
+ * Provides a class-based API similar to TypeChain for interacting with the contract.
+ *
+ * @example
+ * ```typescript
+ * import { createPublicClient, createWalletClient, http } from 'viem';
+ * import { mainnet } from 'viem/chains';
+ * import { Safe_json } from 'Safe_json';
+ *
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ *
+ * const contract = new Safe_json('0x...', { publicClient, walletClient });
+ *
+ * // Read functions
+ * const result = await contract.balanceOf('0x...');
+ *
+ * // Write functions
+ * const hash = await contract.transfer('0x...', 1000n);
+ *
+ * // Simulate transactions (dry-run)
+ * const simulation = await contract.simulate.transfer('0x...', 1000n);
+ * console.log('Gas estimate:', simulation.request.gas);
+ *
+ * // Watch events
+ * const unwatch = contract.watch.Transfer((event) => {
+ *   console.log('Transfer event:', event);
+ * });
+ * ```
+ */
+export declare class Safe_json {
+    private contract;
+    private contractAddress;
+    private publicClient;
+    constructor(address: Address, clients: {
+        publicClient: PublicClient;
+        walletClient?: WalletClient;
+    });
+    /**
+     * Get the contract address
+     */
+    get address(): Address;
+    /**
+     * Get the underlying viem contract instance
+     */
+    getContract(): Safe_jsonContract;
+    /**
+     * VERSION
+     * view
+     */
+    VERSION(): Promise<string>;
+    /**
+     * approvedHashes
+     * view
+     */
+    approvedHashes(arg0: `0x${string}`, arg1: `0x${string}`): Promise<bigint>;
+    checkNSignatures(dataHash: `0x${string}`, data: `0x${string}`, signatures: `0x${string}`, requiredSignatures: bigint): Promise<void>;
+    checkNSignatures(executor: `0x${string}`, dataHash: `0x${string}`, signatures: `0x${string}`, requiredSignatures: bigint): Promise<void>;
+    checkSignatures(dataHash: `0x${string}`, data: `0x${string}`, signatures: `0x${string}`): Promise<void>;
+    checkSignatures(executor: `0x${string}`, dataHash: `0x${string}`, signatures: `0x${string}`): Promise<void>;
+    /**
+     * domainSeparator
+     * view
+     */
+    domainSeparator(): Promise<`0x${string}`>;
+    /**
+     * getModulesPaginated
+     * view
+     */
+    getModulesPaginated(start: `0x${string}`, pageSize: bigint): Promise<[`0x${string}`[], `0x${string}`]>;
+    /**
+     * getOwners
+     * view
+     */
+    getOwners(): Promise<`0x${string}`[]>;
+    /**
+     * getStorageAt
+     * view
+     */
+    getStorageAt(offset: bigint, length: bigint): Promise<`0x${string}`>;
+    /**
+     * getThreshold
+     * view
+     */
+    getThreshold(): Promise<bigint>;
+    /**
+     * getTransactionHash
+     * view
+     */
+    getTransactionHash(to: `0x${string}`, value: bigint, data: `0x${string}`, operation: bigint, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: `0x${string}`, refundReceiver: `0x${string}`, _nonce: bigint): Promise<`0x${string}`>;
+    /**
+     * isModuleEnabled
+     * view
+     */
+    isModuleEnabled(module: `0x${string}`): Promise<boolean>;
+    /**
+     * isOwner
+     * view
+     */
+    isOwner(owner: `0x${string}`): Promise<boolean>;
+    /**
+     * nonce
+     * view
+     */
+    nonce(): Promise<bigint>;
+    /**
+     * signedMessages
+     * view
+     */
+    signedMessages(arg0: `0x${string}`): Promise<bigint>;
+    /**
+     * addOwnerWithThreshold
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addOwnerWithThreshold(owner: `0x${string}`, _threshold: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * approveHash
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    approveHash(hashToApprove: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * changeThreshold
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    changeThreshold(_threshold: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * disableModule
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    disableModule(prevModule: `0x${string}`, module: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * enableModule
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    enableModule(module: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * execTransaction
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    execTransaction(to: `0x${string}`, value: bigint, data: `0x${string}`, operation: bigint, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: `0x${string}`, refundReceiver: `0x${string}`, signatures: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * execTransactionFromModule
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    execTransactionFromModule(to: `0x${string}`, value: bigint, data: `0x${string}`, operation: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * execTransactionFromModuleReturnData
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    execTransactionFromModuleReturnData(to: `0x${string}`, value: bigint, data: `0x${string}`, operation: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * removeOwner
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeOwner(prevOwner: `0x${string}`, owner: `0x${string}`, _threshold: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * setFallbackHandler
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setFallbackHandler(handler: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * setGuard
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setGuard(guard: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * setModuleGuard
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setModuleGuard(moduleGuard: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * setup
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setup(_owners: `0x${string}`[], _threshold: bigint, to: `0x${string}`, data: `0x${string}`, fallbackHandler: `0x${string}`, paymentToken: `0x${string}`, payment: bigint, paymentReceiver: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * simulateAndRevert
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    simulateAndRevert(targetContract: `0x${string}`, calldataPayload: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * swapOwner
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    swapOwner(prevOwner: `0x${string}`, oldOwner: `0x${string}`, newOwner: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * Simulate contract write operations (dry-run without sending transaction)
+     *
+     * @example
+     * const result = await contract.simulate.transfer('0x...', 1000n);
+     * console.log('Gas estimate:', result.request.gas);
+     * console.log('Would succeed:', result.result);
+     */
+    get simulate(): {
+        /**
+         * Simulate addOwnerWithThreshold
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addOwnerWithThreshold(owner: `0x${string}`, _threshold: bigint, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate approveHash
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        approveHash(hashToApprove: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate changeThreshold
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        changeThreshold(_threshold: bigint, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate disableModule
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        disableModule(prevModule: `0x${string}`, module: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate enableModule
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        enableModule(module: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate execTransaction
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        execTransaction(to: `0x${string}`, value: bigint, data: `0x${string}`, operation: bigint, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: `0x${string}`, refundReceiver: `0x${string}`, signatures: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<boolean>;
+        /**
+         * Simulate execTransactionFromModule
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        execTransactionFromModule(to: `0x${string}`, value: bigint, data: `0x${string}`, operation: bigint, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<boolean>;
+        /**
+         * Simulate execTransactionFromModuleReturnData
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        execTransactionFromModuleReturnData(to: `0x${string}`, value: bigint, data: `0x${string}`, operation: bigint, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<[boolean, `0x${string}`]>;
+        /**
+         * Simulate removeOwner
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeOwner(prevOwner: `0x${string}`, owner: `0x${string}`, _threshold: bigint, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate setFallbackHandler
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setFallbackHandler(handler: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate setGuard
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setGuard(guard: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate setModuleGuard
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setModuleGuard(moduleGuard: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate setup
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setup(_owners: `0x${string}`[], _threshold: bigint, to: `0x${string}`, data: `0x${string}`, fallbackHandler: `0x${string}`, paymentToken: `0x${string}`, payment: bigint, paymentReceiver: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate simulateAndRevert
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        simulateAndRevert(targetContract: `0x${string}`, calldataPayload: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate swapOwner
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        swapOwner(prevOwner: `0x${string}`, oldOwner: `0x${string}`, newOwner: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+    };
+    /**
+     * Watch contract events
+     *
+     * @example
+     * // Watch all Transfer events
+     * const unwatch = contract.watch.Transfer((event) => {
+     *   console.log('Transfer:', event);
+     * });
+     *
+     * // Stop watching
+     * unwatch();
+     */
+    get watch(): {
+        /**
+         * Watch AddedOwner events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        AddedOwner: (callback: (event: {
+            owner: `0x${string}`;
+        }) => void, filter?: {
+            owner: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch ApproveHash events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ApproveHash: (callback: (event: {
+            approvedHash: `0x${string}`;
+            owner: `0x${string}`;
+        }) => void, filter?: {
+            approvedHash: `0x${string}`;
+            owner: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch ChangedFallbackHandler events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ChangedFallbackHandler: (callback: (event: {
+            handler: `0x${string}`;
+        }) => void, filter?: {
+            handler: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch ChangedGuard events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ChangedGuard: (callback: (event: {
+            guard: `0x${string}`;
+        }) => void, filter?: {
+            guard: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch ChangedModuleGuard events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ChangedModuleGuard: (callback: (event: {
+            moduleGuard: `0x${string}`;
+        }) => void, filter?: {
+            moduleGuard: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch ChangedThreshold events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ChangedThreshold: (callback: (event: {
+            threshold: bigint;
+        }) => void) => () => void;
+        /**
+         * Watch DisabledModule events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        DisabledModule: (callback: (event: {
+            module: `0x${string}`;
+        }) => void, filter?: {
+            module: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch EnabledModule events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        EnabledModule: (callback: (event: {
+            module: `0x${string}`;
+        }) => void, filter?: {
+            module: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch ExecutionFailure events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ExecutionFailure: (callback: (event: {
+            txHash: `0x${string}`;
+            payment: bigint;
+        }) => void, filter?: {
+            txHash: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch ExecutionFromModuleFailure events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ExecutionFromModuleFailure: (callback: (event: {
+            module: `0x${string}`;
+        }) => void, filter?: {
+            module: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch ExecutionFromModuleSuccess events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ExecutionFromModuleSuccess: (callback: (event: {
+            module: `0x${string}`;
+        }) => void, filter?: {
+            module: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch ExecutionSuccess events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ExecutionSuccess: (callback: (event: {
+            txHash: `0x${string}`;
+            payment: bigint;
+        }) => void, filter?: {
+            txHash: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch RemovedOwner events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        RemovedOwner: (callback: (event: {
+            owner: `0x${string}`;
+        }) => void, filter?: {
+            owner: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch SafeReceived events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        SafeReceived: (callback: (event: {
+            sender: `0x${string}`;
+            value: bigint;
+        }) => void, filter?: {
+            sender: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch SafeSetup events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        SafeSetup: (callback: (event: {
+            initiator: `0x${string}`;
+            owners: `0x${string}`[];
+            threshold: bigint;
+            initializer: `0x${string}`;
+            fallbackHandler: `0x${string}`;
+        }) => void, filter?: {
+            initiator: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch SignMsg events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        SignMsg: (callback: (event: {
+            msgHash: `0x${string}`;
+        }) => void, filter?: {
+            msgHash: `0x${string}`;
+        }) => () => void;
+    };
+}