polkamarkets-js 3.1.11 → 3.2.0

package/lib/openzeppelin-contracts-upgradeable/contracts/mocks/WithInit.sol

@@ -9,523 +9,541 @@ contract AccessControlUpgradeableWithInit is AccessControlUpgradeable {
         __AccessControl_init();
     }
 }
-import "../utils/ContextUpgradeable.sol";
+import "../access/extensions/AccessControlDefaultAdminRulesUpgradeable.sol";
 
-contract ContextUpgradeableWithInit is ContextUpgradeable {
+contract AccessControlDefaultAdminRulesUpgradeableWithInit is AccessControlDefaultAdminRulesUpgradeable {
+    constructor(uint48 initialDelay, address initialDefaultAdmin) payable initializer {
+        __AccessControlDefaultAdminRules_init(initialDelay, initialDefaultAdmin);
+    }
+}
+import "../access/extensions/AccessControlEnumerableUpgradeable.sol";
+
+contract AccessControlEnumerableUpgradeableWithInit is AccessControlEnumerableUpgradeable {
     constructor() payable initializer {
-        __Context_init();
+        __AccessControlEnumerable_init();
     }
 }
-import "../utils/introspection/ERC165Upgradeable.sol";
+import "../access/manager/AccessManagedUpgradeable.sol";
 
-contract ERC165UpgradeableWithInit is ERC165Upgradeable {
+contract AccessManagedUpgradeableWithInit is AccessManagedUpgradeable {
+    constructor(address initialAuthority) payable initializer {
+        __AccessManaged_init(initialAuthority);
+    }
+}
+import "../access/manager/AccessManagerUpgradeable.sol";
+
+contract AccessManagerUpgradeableWithInit is AccessManagerUpgradeable {
+    constructor(address initialAdmin) payable initializer {
+        __AccessManager_init(initialAdmin);
+    }
+}
+import "../access/OwnableUpgradeable.sol";
+
+contract OwnableUpgradeableWithInit is OwnableUpgradeable {
+    constructor(address initialOwner) payable initializer {
+        __Ownable_init(initialOwner);
+    }
+}
+import "../access/Ownable2StepUpgradeable.sol";
+
+contract Ownable2StepUpgradeableWithInit is Ownable2StepUpgradeable {
     constructor() payable initializer {
-        __ERC165_init();
+        __Ownable2Step_init();
+    }
+}
+import "../account/extensions/draft-AccountERC7579Upgradeable.sol";
+
+contract AccountERC7579UpgradeableWithInit is AccountERC7579Upgradeable {
+    constructor() payable initializer {
+        __AccountERC7579_init();
     }
 }
-import "./AccessControlMockUpgradeable.sol";
+import "../account/extensions/draft-AccountERC7579HookedUpgradeable.sol";
 
-contract AccessControlMockUpgradeableWithInit is AccessControlMockUpgradeable {
+contract AccountERC7579HookedUpgradeableWithInit is AccountERC7579HookedUpgradeable {
     constructor() payable initializer {
-        __AccessControlMock_init();
+        __AccountERC7579Hooked_init();
+    }
+}
+import "../finance/VestingWalletUpgradeable.sol";
+
+contract VestingWalletUpgradeableWithInit is VestingWalletUpgradeable {
+    constructor(address beneficiary, uint64 startTimestamp, uint64 durationSeconds) payable initializer {
+        __VestingWallet_init(beneficiary, startTimestamp, durationSeconds);
+    }
+}
+import "../finance/VestingWalletCliffUpgradeable.sol";
+
+contract VestingWalletCliffUpgradeableWithInit is VestingWalletCliffUpgradeable {
+    constructor(uint64 cliffSeconds) payable initializer {
+        __VestingWalletCliff_init(cliffSeconds);
     }
 }
 import "../governance/TimelockControllerUpgradeable.sol";
 
 contract TimelockControllerUpgradeableWithInit is TimelockControllerUpgradeable {
-    constructor(
-        uint256 minDelay,
-        address[] memory proposers,
-        address[] memory executors,
-        address admin
-    ) payable initializer {
+    constructor(uint256 minDelay, address[] memory proposers, address[] memory executors, address admin) payable initializer {
         __TimelockController_init(minDelay, proposers, executors, admin);
     }
 }
-import "../utils/cryptography/EIP712Upgradeable.sol";
+import "../metatx/ERC2771ContextUpgradeable.sol";
+
+contract ERC2771ContextUpgradeableWithInit is ERC2771ContextUpgradeable {
+    constructor(address trustedForwarder_) ERC2771ContextUpgradeable(trustedForwarder_) payable initializer {
 
-contract EIP712UpgradeableWithInit is EIP712Upgradeable {
-    constructor(string memory name, string memory version) payable initializer {
-        __EIP712_init(name, version);
     }
 }
-import "./wizard/MyGovernor3Upgradeable.sol";
+import "../metatx/ERC2771ForwarderUpgradeable.sol";
 
-contract MyGovernorUpgradeableWithInit is MyGovernorUpgradeable {
-    constructor(IVotesUpgradeable _token, TimelockControllerUpgradeable _timelock) payable initializer {
-        __MyGovernor_init(_token, _timelock);
+contract ERC2771ForwarderUpgradeableWithInit is ERC2771ForwarderUpgradeable {
+    constructor(string memory name) payable initializer {
+        __ERC2771Forwarder_init(name);
     }
 }
-import "./wizard/MyGovernor2Upgradeable.sol";
+import "./AccessManagedTargetUpgradeable.sol";
 
-contract MyGovernor2UpgradeableWithInit is MyGovernor2Upgradeable {
-    constructor(IVotesUpgradeable _token, TimelockControllerUpgradeable _timelock) payable initializer {
-        __MyGovernor2_init(_token, _timelock);
+contract AccessManagedTargetUpgradeableWithInit is AccessManagedTargetUpgradeable {
+    constructor() payable initializer {
+        __AccessManagedTarget_init();
     }
 }
-import "./wizard/MyGovernor1Upgradeable.sol";
+import "./AccessManagerMockUpgradeable.sol";
 
-contract MyGovernor1UpgradeableWithInit is MyGovernor1Upgradeable {
-    constructor(IVotesUpgradeable _token, TimelockControllerUpgradeable _timelock) payable initializer {
-        __MyGovernor1_init(_token, _timelock);
+contract AccessManagerMockUpgradeableWithInit is AccessManagerMockUpgradeable {
+    constructor(address initialAdmin) payable initializer {
+        __AccessManagerMock_init(initialAdmin);
     }
 }
-import "./GovernorWithParamsMockUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract GovernorWithParamsMockUpgradeableWithInit is GovernorWithParamsMockUpgradeable {
-    constructor(string memory name_, IVotesUpgradeable token_) payable initializer {
-        __GovernorWithParamsMock_init(name_, token_);
+contract AccountMockUpgradeableWithInit is AccountMockUpgradeable {
+    constructor() payable initializer {
+        __AccountMock_init();
     }
 }
-import "./GovernorVoteMockUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract GovernorVoteMocksUpgradeableWithInit is GovernorVoteMocksUpgradeable {
-    constructor(string memory name_, IVotesUpgradeable token_) payable initializer {
-        __GovernorVoteMocks_init(name_, token_);
+contract AccountECDSAMockUpgradeableWithInit is AccountECDSAMockUpgradeable {
+    constructor() payable initializer {
+        __AccountECDSAMock_init();
     }
 }
-import "./GovernorTimelockControlMockUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract GovernorTimelockControlMockUpgradeableWithInit is GovernorTimelockControlMockUpgradeable {
-    constructor(
-        string memory name_,
-        IVotesUpgradeable token_,
-        uint256 votingDelay_,
-        uint256 votingPeriod_,
-        TimelockControllerUpgradeable timelock_,
-        uint256 quorumNumerator_
-    ) payable initializer {
-        __GovernorTimelockControlMock_init(name_, token_, votingDelay_, votingPeriod_, timelock_, quorumNumerator_);
+contract AccountP256MockUpgradeableWithInit is AccountP256MockUpgradeable {
+    constructor() payable initializer {
+        __AccountP256Mock_init();
     }
 }
-import "./GovernorTimelockCompoundMockUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract GovernorTimelockCompoundMockUpgradeableWithInit is GovernorTimelockCompoundMockUpgradeable {
-    constructor(
-        string memory name_,
-        IVotesUpgradeable token_,
-        uint256 votingDelay_,
-        uint256 votingPeriod_,
-        ICompoundTimelockUpgradeable timelock_,
-        uint256 quorumNumerator_
-    ) payable initializer {
-        __GovernorTimelockCompoundMock_init(name_, token_, votingDelay_, votingPeriod_, timelock_, quorumNumerator_);
+contract AccountRSAMockUpgradeableWithInit is AccountRSAMockUpgradeable {
+    constructor() payable initializer {
+        __AccountRSAMock_init();
     }
 }
-import "./GovernorCompatibilityBravoMockUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract GovernorCompatibilityBravoMockUpgradeableWithInit is GovernorCompatibilityBravoMockUpgradeable {
-    constructor(
-        string memory name_,
-        ERC20VotesCompUpgradeable token_,
-        uint256 votingDelay_,
-        uint256 votingPeriod_,
-        uint256 proposalThreshold_,
-        ICompoundTimelockUpgradeable timelock_
-    ) payable initializer {
-        __GovernorCompatibilityBravoMock_init(name_, token_, votingDelay_, votingPeriod_, proposalThreshold_, timelock_);
+contract AccountERC7702MockUpgradeableWithInit is AccountERC7702MockUpgradeable {
+    constructor() payable initializer {
+        __AccountERC7702Mock_init();
     }
 }
-import "../token/ERC20/ERC20Upgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract ERC20UpgradeableWithInit is ERC20Upgradeable {
-    constructor(string memory name_, string memory symbol_) payable initializer {
-        __ERC20_init(name_, symbol_);
+contract AccountERC7702WithModulesMockUpgradeableWithInit is AccountERC7702WithModulesMockUpgradeable {
+    constructor() payable initializer {
+        __AccountERC7702WithModulesMock_init();
     }
 }
-import "./GovernorCompMockUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract GovernorCompMockUpgradeableWithInit is GovernorCompMockUpgradeable {
-    constructor(string memory name_, ERC20VotesCompUpgradeable token_) payable initializer {
-        __GovernorCompMock_init(name_, token_);
+contract AccountERC7579MockUpgradeableWithInit is AccountERC7579MockUpgradeable {
+    constructor(address validator, bytes memory initData) payable initializer {
+        __AccountERC7579Mock_init(validator, initData);
     }
 }
-import "./ERC1271WalletMockUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract ERC1271WalletMockUpgradeableWithInit is ERC1271WalletMockUpgradeable {
-    constructor(address originalOwner) payable initializer {
-        __ERC1271WalletMock_init(originalOwner);
+contract AccountERC7579HookedMockUpgradeableWithInit is AccountERC7579HookedMockUpgradeable {
+    constructor(address validator, bytes memory initData) payable initializer {
+        __AccountERC7579HookedMock_init(validator, initData);
     }
 }
-import "./ERC1271WalletMockUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract ERC1271MaliciousMockUpgradeableWithInit is ERC1271MaliciousMockUpgradeable {
+contract AccountERC7913MockUpgradeableWithInit is AccountERC7913MockUpgradeable {
     constructor() payable initializer {
-        __ERC1271MaliciousMock_init();
+        __AccountERC7913Mock_init();
     }
 }
-import "../access/OwnableUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract OwnableUpgradeableWithInit is OwnableUpgradeable {
+contract AccountMultiSignerMockUpgradeableWithInit is AccountMultiSignerMockUpgradeable {
     constructor() payable initializer {
-        __Ownable_init();
+        __AccountMultiSignerMock_init();
     }
 }
-import "../utils/escrow/EscrowUpgradeable.sol";
+import "./account/AccountMockUpgradeable.sol";
 
-contract EscrowUpgradeableWithInit is EscrowUpgradeable {
+contract AccountMultiSignerWeightedMockUpgradeableWithInit is AccountMultiSignerWeightedMockUpgradeable {
     constructor() payable initializer {
-        __Escrow_init();
+        __AccountMultiSignerWeightedMock_init();
     }
 }
-import "../utils/MulticallUpgradeable.sol";
+import "./account/modules/ERC7579MockUpgradeable.sol";
 
-contract MulticallUpgradeableWithInit is MulticallUpgradeable {
-    constructor() payable initializer {
-        __Multicall_init();
+contract ERC7579ModuleMockUpgradeableWithInit is ERC7579ModuleMockUpgradeable {
+    constructor(uint256 moduleTypeId) payable initializer {
+        __ERC7579ModuleMock_init(moduleTypeId);
     }
 }
-import "./MulticallTokenMockUpgradeable.sol";
+import "./account/modules/ERC7579MockUpgradeable.sol";
 
-contract MulticallTokenMockUpgradeableWithInit is MulticallTokenMockUpgradeable {
-    constructor(uint256 initialBalance) payable initializer {
-        __MulticallTokenMock_init(initialBalance);
+contract ERC7579HookMockUpgradeableWithInit is ERC7579HookMockUpgradeable {
+    constructor() payable initializer {
+        __ERC7579HookMock_init();
     }
 }
-import "./ERC20MockUpgradeable.sol";
+import "./account/modules/ERC7579MockUpgradeable.sol";
 
-contract ERC20MockUpgradeableWithInit is ERC20MockUpgradeable {
-    constructor(
-        string memory name,
-        string memory symbol,
-        address initialAccount,
-        uint256 initialBalance
-    ) payable initializer {
-        __ERC20Mock_init(name, symbol, initialAccount, initialBalance);
+contract ERC7579FallbackHandlerMockUpgradeableWithInit is ERC7579FallbackHandlerMockUpgradeable {
+    constructor() payable initializer {
+        __ERC7579FallbackHandlerMock_init();
     }
 }
-import "../token/ERC20/presets/ERC20PresetMinterPauserUpgradeable.sol";
+import "./account/modules/ERC7579MockUpgradeable.sol";
 
-contract ERC20PresetMinterPauserUpgradeableWithInit is ERC20PresetMinterPauserUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC20PresetMinterPauser_init(name, symbol);
+contract ERC7579ValidatorMockUpgradeableWithInit is ERC7579ValidatorMockUpgradeable {
+    constructor() payable initializer {
+        __ERC7579ValidatorMock_init();
     }
 }
-import "../access/AccessControlEnumerableUpgradeable.sol";
+import "./account/utils/ERC7579UtilsMockUpgradeable.sol";
 
-contract AccessControlEnumerableUpgradeableWithInit is AccessControlEnumerableUpgradeable {
+contract ERC7579UtilsGlobalMockUpgradeableWithInit is ERC7579UtilsGlobalMockUpgradeable {
     constructor() payable initializer {
-        __AccessControlEnumerable_init();
+        __ERC7579UtilsGlobalMock_init();
     }
 }
-import "../security/PausableUpgradeable.sol";
+import "./ArraysMockUpgradeable.sol";
 
-contract PausableUpgradeableWithInit is PausableUpgradeable {
-    constructor() payable initializer {
-        __Pausable_init();
+contract Uint256ArraysMockUpgradeableWithInit is Uint256ArraysMockUpgradeable {
+    constructor(uint256[] memory array) payable initializer {
+        __Uint256ArraysMock_init(array);
     }
 }
-import "../token/ERC777/ERC777Upgradeable.sol";
+import "./ArraysMockUpgradeable.sol";
 
-contract ERC777UpgradeableWithInit is ERC777Upgradeable {
-    constructor(
-        string memory name_,
-        string memory symbol_,
-        address[] memory defaultOperators_
-    ) payable initializer {
-        __ERC777_init(name_, symbol_, defaultOperators_);
+contract AddressArraysMockUpgradeableWithInit is AddressArraysMockUpgradeable {
+    constructor(address[] memory array) payable initializer {
+        __AddressArraysMock_init(array);
     }
 }
-import "../token/ERC777/presets/ERC777PresetFixedSupplyUpgradeable.sol";
+import "./ArraysMockUpgradeable.sol";
 
-contract ERC777PresetFixedSupplyUpgradeableWithInit is ERC777PresetFixedSupplyUpgradeable {
-    constructor(
-        string memory name,
-        string memory symbol,
-        address[] memory defaultOperators,
-        uint256 initialSupply,
-        address owner
-    ) payable initializer {
-        __ERC777PresetFixedSupply_init(name, symbol, defaultOperators, initialSupply, owner);
+contract Bytes32ArraysMockUpgradeableWithInit is Bytes32ArraysMockUpgradeable {
+    constructor(bytes32[] memory array) payable initializer {
+        __Bytes32ArraysMock_init(array);
+    }
+}
+import "./ArraysMockUpgradeable.sol";
+
+contract BytesArraysMockUpgradeableWithInit is BytesArraysMockUpgradeable {
+    constructor(bytes[] memory array) payable initializer {
+        __BytesArraysMock_init(array);
     }
 }
-import "./ERC777SenderRecipientMockUpgradeable.sol";
+import "./ArraysMockUpgradeable.sol";
 
-contract ERC777SenderRecipientMockUpgradeableWithInit is ERC777SenderRecipientMockUpgradeable {
+contract StringArraysMockUpgradeableWithInit is StringArraysMockUpgradeable {
+    constructor(string[] memory array) payable initializer {
+        __StringArraysMock_init(array);
+    }
+}
+import "./AuthorityMockUpgradeable.sol";
+
+contract NotAuthorityMockUpgradeableWithInit is NotAuthorityMockUpgradeable {
     constructor() payable initializer {
-        __ERC777SenderRecipientMock_init();
+        __NotAuthorityMock_init();
     }
 }
-import "../utils/introspection/ERC1820ImplementerUpgradeable.sol";
+import "./AuthorityMockUpgradeable.sol";
 
-contract ERC1820ImplementerUpgradeableWithInit is ERC1820ImplementerUpgradeable {
+contract AuthorityNoDelayMockUpgradeableWithInit is AuthorityNoDelayMockUpgradeable {
     constructor() payable initializer {
-        __ERC1820Implementer_init();
+        __AuthorityNoDelayMock_init();
     }
 }
-import "./ERC1820ImplementerMockUpgradeable.sol";
+import "./AuthorityMockUpgradeable.sol";
 
-contract ERC1820ImplementerMockUpgradeableWithInit is ERC1820ImplementerMockUpgradeable {
+contract AuthorityDelayMockUpgradeableWithInit is AuthorityDelayMockUpgradeable {
     constructor() payable initializer {
-        __ERC1820ImplementerMock_init();
+        __AuthorityDelayMock_init();
     }
 }
-import "./Create2ImplUpgradeable.sol";
+import "./AuthorityMockUpgradeable.sol";
 
-contract Create2ImplUpgradeableWithInit is Create2ImplUpgradeable {
+contract AuthorityNoResponseUpgradeableWithInit is AuthorityNoResponseUpgradeable {
     constructor() payable initializer {
-        __Create2Impl_init();
+        __AuthorityNoResponse_init();
     }
 }
-import "../token/ERC20/utils/TokenTimelockUpgradeable.sol";
+import "./AuthorityMockUpgradeable.sol";
 
-contract TokenTimelockUpgradeableWithInit is TokenTimelockUpgradeable {
-    constructor(
-        IERC20Upgradeable token_,
-        address beneficiary_,
-        uint256 releaseTime_
-    ) payable initializer {
-        __TokenTimelock_init(token_, beneficiary_, releaseTime_);
+contract AuthorityObserveIsConsumingUpgradeableWithInit is AuthorityObserveIsConsumingUpgradeable {
+    constructor() payable initializer {
+        __AuthorityObserveIsConsuming_init();
     }
 }
-import "../token/ERC721/presets/ERC721PresetMinterPauserAutoIdUpgradeable.sol";
+import "./Base64DirtyUpgradeable.sol";
 
-contract ERC721PresetMinterPauserAutoIdUpgradeableWithInit is ERC721PresetMinterPauserAutoIdUpgradeable {
-    constructor(
-        string memory name,
-        string memory symbol,
-        string memory baseTokenURI
-    ) payable initializer {
-        __ERC721PresetMinterPauserAutoId_init(name, symbol, baseTokenURI);
+contract Base64DirtyUpgradeableWithInit is Base64DirtyUpgradeable {
+    constructor() payable initializer {
+        __Base64Dirty_init();
     }
 }
-import "../token/ERC721/ERC721Upgradeable.sol";
+import "./BatchCallerUpgradeable.sol";
 
-contract ERC721UpgradeableWithInit is ERC721Upgradeable {
-    constructor(string memory name_, string memory symbol_) payable initializer {
-        __ERC721_init(name_, symbol_);
+contract BatchCallerUpgradeableWithInit is BatchCallerUpgradeable {
+    constructor() payable initializer {
+        __BatchCaller_init();
     }
 }
-import "../token/ERC1155/presets/ERC1155PresetMinterPauserUpgradeable.sol";
+import "./CallReceiverMockUpgradeable.sol";
 
-contract ERC1155PresetMinterPauserUpgradeableWithInit is ERC1155PresetMinterPauserUpgradeable {
-    constructor(string memory uri) payable initializer {
-        __ERC1155PresetMinterPauser_init(uri);
+contract CallReceiverMockUpgradeableWithInit is CallReceiverMockUpgradeable {
+    constructor() payable initializer {
+        __CallReceiverMock_init();
     }
 }
-import "../token/ERC1155/ERC1155Upgradeable.sol";
+import "./CallReceiverMockUpgradeable.sol";
 
-contract ERC1155UpgradeableWithInit is ERC1155Upgradeable {
-    constructor(string memory uri_) payable initializer {
-        __ERC1155_init(uri_);
+contract CallReceiverMockTrustingForwarderUpgradeableWithInit is CallReceiverMockTrustingForwarderUpgradeable {
+    constructor(address trustedForwarder_) payable initializer {
+        __CallReceiverMockTrustingForwarder_init(trustedForwarder_);
     }
 }
-import "./VotesMockUpgradeable.sol";
+import "./compound/CompTimelockUpgradeable.sol";
 
-contract VotesMockUpgradeableWithInit is VotesMockUpgradeable {
-    constructor(string memory name) payable initializer {
-        __VotesMock_init(name);
+contract CompTimelockUpgradeableWithInit is CompTimelockUpgradeable {
+    constructor(address admin_, uint256 delay_) payable initializer {
+        __CompTimelock_init(admin_, delay_);
     }
 }
-import "./EIP712ExternalUpgradeable.sol";
+import "./ConstructorMockUpgradeable.sol";
 
-contract EIP712ExternalUpgradeableWithInit is EIP712ExternalUpgradeable {
-    constructor(string memory name, string memory version) payable initializer {
-        __EIP712External_init(name, version);
+contract ConstructorMockUpgradeableWithInit is ConstructorMockUpgradeable {
+    constructor(RevertType error) payable initializer {
+        __ConstructorMock_init(error);
     }
 }
-import "../metatx/MinimalForwarderUpgradeable.sol";
+import "./ContextMockUpgradeable.sol";
 
-contract MinimalForwarderUpgradeableWithInit is MinimalForwarderUpgradeable {
+contract ContextMockUpgradeableWithInit is ContextMockUpgradeable {
     constructor() payable initializer {
-        __MinimalForwarder_init();
+        __ContextMock_init();
     }
 }
-import "./GovernorMockUpgradeable.sol";
+import "./ContextMockUpgradeable.sol";
 
-contract GovernorMockUpgradeableWithInit is GovernorMockUpgradeable {
-    constructor(
-        string memory name_,
-        IVotesUpgradeable token_,
-        uint256 votingDelay_,
-        uint256 votingPeriod_,
-        uint256 quorumNumerator_
-    ) payable initializer {
-        __GovernorMock_init(name_, token_, votingDelay_, votingPeriod_, quorumNumerator_);
+contract ContextMockCallerUpgradeableWithInit is ContextMockCallerUpgradeable {
+    constructor() payable initializer {
+        __ContextMockCaller_init();
     }
 }
-import "./GovernorPreventLateQuorumMockUpgradeable.sol";
+import "./docs/access-control/AccessControlERC20MintBaseUpgradeable.sol";
 
-contract GovernorPreventLateQuorumMockUpgradeableWithInit is GovernorPreventLateQuorumMockUpgradeable {
-    constructor(
-        string memory name_,
-        IVotesUpgradeable token_,
-        uint256 votingDelay_,
-        uint256 votingPeriod_,
-        uint256 quorum_,
-        uint64 voteExtension_
-    ) payable initializer {
-        __GovernorPreventLateQuorumMock_init(name_, token_, votingDelay_, votingPeriod_, quorum_, voteExtension_);
+contract AccessControlERC20MintBaseUpgradeableWithInit is AccessControlERC20MintBaseUpgradeable {
+    constructor(address minter) payable initializer {
+        __AccessControlERC20MintBase_init(minter);
     }
 }
-import "./ERC1155SupplyMockUpgradeable.sol";
+import "./docs/access-control/AccessControlERC20MintMissingUpgradeable.sol";
 
-contract ERC1155SupplyMockUpgradeableWithInit is ERC1155SupplyMockUpgradeable {
-    constructor(string memory uri) payable initializer {
-        __ERC1155SupplyMock_init(uri);
+contract AccessControlERC20MintMissingUpgradeableWithInit is AccessControlERC20MintMissingUpgradeable {
+    constructor() payable initializer {
+        __AccessControlERC20MintMissing_init();
     }
 }
-import "./ERC1155MockUpgradeable.sol";
+import "./docs/access-control/AccessControlERC20MintOnlyRoleUpgradeable.sol";
 
-contract ERC1155MockUpgradeableWithInit is ERC1155MockUpgradeable {
-    constructor(string memory uri) payable initializer {
-        __ERC1155Mock_init(uri);
+contract AccessControlERC20MintUpgradeableWithInit is AccessControlERC20MintUpgradeable {
+    constructor(address minter, address burner) payable initializer {
+        __AccessControlERC20Mint_init(minter, burner);
     }
 }
-import "./ERC1155URIStorageMockUpgradeable.sol";
+import "./docs/access-control/AccessControlModifiedUpgradeable.sol";
 
-contract ERC1155URIStorageMockUpgradeableWithInit is ERC1155URIStorageMockUpgradeable {
-    constructor(string memory _uri) payable initializer {
-        __ERC1155URIStorageMock_init(_uri);
+contract AccessControlModifiedUpgradeableWithInit is AccessControlModifiedUpgradeable {
+    constructor() payable initializer {
+        __AccessControlModified_init();
     }
 }
-import "./ERC1155PausableMockUpgradeable.sol";
+import "./docs/access-control/AccessManagedERC20MintBaseUpgradeable.sol";
 
-contract ERC1155PausableMockUpgradeableWithInit is ERC1155PausableMockUpgradeable {
-    constructor(string memory uri) payable initializer {
-        __ERC1155PausableMock_init(uri);
+contract AccessManagedERC20MintUpgradeableWithInit is AccessManagedERC20MintUpgradeable {
+    constructor(address manager) payable initializer {
+        __AccessManagedERC20Mint_init(manager);
     }
 }
-import "./ERC1155BurnableMockUpgradeable.sol";
+import "./docs/access-control/MyContractOwnableUpgradeable.sol";
 
-contract ERC1155BurnableMockUpgradeableWithInit is ERC1155BurnableMockUpgradeable {
-    constructor(string memory uri) payable initializer {
-        __ERC1155BurnableMock_init(uri);
+contract MyContractUpgradeableWithInit is MyContractUpgradeable {
+    constructor(address initialOwner) payable initializer {
+        __MyContract_init(initialOwner);
     }
 }
-import "../utils/introspection/ERC165StorageUpgradeable.sol";
+import "./docs/account/MyAccountERC7702Upgradeable.sol";
 
-contract ERC165StorageUpgradeableWithInit is ERC165StorageUpgradeable {
+contract MyAccountERC7702UpgradeableWithInit is MyAccountERC7702Upgradeable {
     constructor() payable initializer {
-        __ERC165Storage_init();
+        __MyAccountERC7702_init();
+    }
+}
+import "./docs/account/MyFactoryAccountUpgradeable.sol";
+
+contract MyFactoryAccountUpgradeableWithInit is MyFactoryAccountUpgradeable {
+    constructor(address impl_) payable initializer {
+        __MyFactoryAccount_init(impl_);
     }
 }
-import "./ERC165StorageMockUpgradeable.sol";
+import "./docs/ERC20WithAutoMinerRewardUpgradeable.sol";
 
-contract ERC165StorageMockUpgradeableWithInit is ERC165StorageMockUpgradeable {
+contract ERC20WithAutoMinerRewardUpgradeableWithInit is ERC20WithAutoMinerRewardUpgradeable {
     constructor() payable initializer {
-        __ERC165StorageMock_init();
+        __ERC20WithAutoMinerReward_init();
     }
 }
-import "./ERC165CheckerMockUpgradeable.sol";
+import "./docs/ERC4626FeesUpgradeable.sol";
 
-contract ERC165CheckerMockUpgradeableWithInit is ERC165CheckerMockUpgradeable {
+contract ERC4626FeesUpgradeableWithInit is ERC4626FeesUpgradeable {
     constructor() payable initializer {
-        __ERC165CheckerMock_init();
+        __ERC4626Fees_init();
     }
 }
-import "./ERC721EnumerableMockUpgradeable.sol";
+import "./docs/governance/MyGovernorUpgradeable.sol";
 
-contract ERC721EnumerableMockUpgradeableWithInit is ERC721EnumerableMockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC721EnumerableMock_init(name, symbol);
+contract MyGovernorUpgradeableWithInit is MyGovernorUpgradeable {
+    constructor(
+        IVotes _token,
+        TimelockControllerUpgradeable _timelock
+    ) payable initializer {
+        __MyGovernor_init(_token, _timelock);
     }
 }
-import "./ERC721ConsecutiveMockUpgradeable.sol";
+import "./docs/governance/MyTokenUpgradeable.sol";
 
-contract ERC721ConsecutiveMockUpgradeableWithInit is ERC721ConsecutiveMockUpgradeable {
+contract MyTokenUpgradeableWithInit is MyTokenUpgradeable {
+    constructor() payable initializer {
+        __MyToken_init();
+    }
+}
+import "./docs/governance/MyTokenTimestampBasedUpgradeable.sol";
+
+contract MyTokenTimestampBasedUpgradeableWithInit is MyTokenTimestampBasedUpgradeable {
+    constructor() payable initializer {
+        __MyTokenTimestampBased_init();
+    }
+}
+import "./docs/governance/MyTokenWrappedUpgradeable.sol";
+
+contract MyTokenWrappedUpgradeableWithInit is MyTokenWrappedUpgradeable {
     constructor(
-        string memory name,
-        string memory symbol,
-        address[] memory delegates,
-        address[] memory receivers,
-        uint96[] memory amounts
+        IERC20 wrappedToken
     ) payable initializer {
-        __ERC721ConsecutiveMock_init(name, symbol, delegates, receivers, amounts);
+        __MyTokenWrapped_init(wrappedToken);
     }
 }
-import "./ERC721ConsecutiveMockUpgradeable.sol";
+import "./docs/MyNFTUpgradeable.sol";
 
-contract ERC721ConsecutiveNoConstructorMintMockUpgradeableWithInit is ERC721ConsecutiveNoConstructorMintMockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC721ConsecutiveNoConstructorMintMock_init(name, symbol);
+contract MyNFTUpgradeableWithInit is MyNFTUpgradeable {
+    constructor() payable initializer {
+        __MyNFT_init();
     }
 }
-import "./BitmapMockUpgradeable.sol";
+import "./docs/token/ERC1155/GameItemsUpgradeable.sol";
 
-contract BitMapMockUpgradeableWithInit is BitMapMockUpgradeable {
+contract GameItemsUpgradeableWithInit is GameItemsUpgradeable {
     constructor() payable initializer {
-        __BitMapMock_init();
+        __GameItems_init();
     }
 }
-import "./DoubleEndedQueueMockUpgradeable.sol";
+import "./docs/token/ERC1155/MyERC115HolderContractUpgradeable.sol";
 
-contract Bytes32DequeMockUpgradeableWithInit is Bytes32DequeMockUpgradeable {
+contract MyERC115HolderContractUpgradeableWithInit is MyERC115HolderContractUpgradeable {
     constructor() payable initializer {
-        __Bytes32DequeMock_init();
+        __MyERC115HolderContract_init();
+    }
+}
+import "./docs/token/ERC20/GLDTokenUpgradeable.sol";
+
+contract GLDTokenUpgradeableWithInit is GLDTokenUpgradeable {
+    constructor(uint256 initialSupply) payable initializer {
+        __GLDToken_init(initialSupply);
     }
 }
-import "./SafeCastMockUpgradeable.sol";
+import "./docs/token/ERC6909/ERC6909GameItemsUpgradeable.sol";
 
-contract SafeCastMockUpgradeableWithInit is SafeCastMockUpgradeable {
+contract ERC6909GameItemsUpgradeableWithInit is ERC6909GameItemsUpgradeable {
     constructor() payable initializer {
-        __SafeCastMock_init();
+        __ERC6909GameItems_init();
     }
 }
-import "./CheckpointsMockUpgradeable.sol";
+import "./docs/token/ERC721/GameItemUpgradeable.sol";
 
-contract CheckpointsMockUpgradeableWithInit is CheckpointsMockUpgradeable {
+contract GameItemUpgradeableWithInit is GameItemUpgradeable {
     constructor() payable initializer {
-        __CheckpointsMock_init();
+        __GameItem_init();
     }
 }
-import "./CheckpointsMockUpgradeable.sol";
+import "./docs/utilities/Base64NFTUpgradeable.sol";
 
-contract Checkpoints224MockUpgradeableWithInit is Checkpoints224MockUpgradeable {
+contract Base64NFTUpgradeableWithInit is Base64NFTUpgradeable {
     constructor() payable initializer {
-        __Checkpoints224Mock_init();
+        __Base64NFT_init();
     }
 }
-import "./CheckpointsMockUpgradeable.sol";
+import "./docs/utilities/MulticallUpgradeable.sol";
 
-contract Checkpoints160MockUpgradeableWithInit is Checkpoints160MockUpgradeable {
+contract BoxUpgradeableWithInit is BoxUpgradeable {
     constructor() payable initializer {
-        __Checkpoints160Mock_init();
+        __Box_init();
     }
 }
-import "./ERC721ConsecutiveEnumerableMockUpgradeable.sol";
+import "./DummyImplementationUpgradeable.sol";
 
-contract ERC721ConsecutiveEnumerableMockUpgradeableWithInit is ERC721ConsecutiveEnumerableMockUpgradeable {
-    constructor(
-        string memory name,
-        string memory symbol,
-        address[] memory receivers,
-        uint96[] memory amounts
-    ) payable initializer {
-        __ERC721ConsecutiveEnumerableMock_init(name, symbol, receivers, amounts);
+contract DummyImplementationUpgradeableWithInit is DummyImplementationUpgradeable {
+    constructor() payable initializer {
+        __DummyImplementation_init();
     }
 }
-import "./ERC721BurnableMockUpgradeable.sol";
+import "./DummyImplementationUpgradeable.sol";
 
-contract ERC721BurnableMockUpgradeableWithInit is ERC721BurnableMockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC721BurnableMock_init(name, symbol);
+contract DummyImplementationV2UpgradeableWithInit is DummyImplementationV2Upgradeable {
+    constructor() payable initializer {
+        __DummyImplementationV2_init();
     }
 }
-import "../token/ERC1155/utils/ERC1155HolderUpgradeable.sol";
+import "./EIP712VerifierUpgradeable.sol";
 
-contract ERC1155HolderUpgradeableWithInit is ERC1155HolderUpgradeable {
+contract EIP712VerifierUpgradeableWithInit is EIP712VerifierUpgradeable {
     constructor() payable initializer {
-        __ERC1155Holder_init();
+        __EIP712Verifier_init();
     }
 }
-import "./ERC1155ReceiverMockUpgradeable.sol";
+import "./ERC1271WalletMockUpgradeable.sol";
 
-contract ERC1155ReceiverMockUpgradeableWithInit is ERC1155ReceiverMockUpgradeable {
-    constructor(
-        bytes4 recRetval,
-        bool recReverts,
-        bytes4 batRetval,
-        bool batReverts
-    ) payable initializer {
-        __ERC1155ReceiverMock_init(recRetval, recReverts, batRetval, batReverts);
+contract ERC1271WalletMockUpgradeableWithInit is ERC1271WalletMockUpgradeable {
+    constructor(address originalOwner) payable initializer {
+        __ERC1271WalletMock_init(originalOwner);
     }
 }
-import "./ERC165/ERC165ReturnBombUpgradeable.sol";
+import "./ERC1271WalletMockUpgradeable.sol";
 
-contract ERC165ReturnBombMockUpgradeableWithInit is ERC165ReturnBombMockUpgradeable {
+contract ERC1271MaliciousMockUpgradeableWithInit is ERC1271MaliciousMockUpgradeable {
     constructor() payable initializer {
-        __ERC165ReturnBombMock_init();
+        __ERC1271MaliciousMock_init();
     }
 }
 import "./ERC165/ERC165InterfacesSupportedUpgradeable.sol";
@@ -542,832 +560,923 @@ contract ERC165InterfacesSupportedUpgradeableWithInit is ERC165InterfacesSupport
         __ERC165InterfacesSupported_init(interfaceIds);
     }
 }
-import "../token/common/ERC2981Upgradeable.sol";
+import "./ERC165/ERC165MaliciousDataUpgradeable.sol";
 
-contract ERC2981UpgradeableWithInit is ERC2981Upgradeable {
+contract ERC165MaliciousDataUpgradeableWithInit is ERC165MaliciousDataUpgradeable {
     constructor() payable initializer {
-        __ERC2981_init();
+        __ERC165MaliciousData_init();
     }
 }
-import "./ERC721RoyaltyMockUpgradeable.sol";
+import "./ERC165/ERC165MissingDataUpgradeable.sol";
 
-contract ERC721RoyaltyMockUpgradeableWithInit is ERC721RoyaltyMockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC721RoyaltyMock_init(name, symbol);
+contract ERC165MissingDataUpgradeableWithInit is ERC165MissingDataUpgradeable {
+    constructor() payable initializer {
+        __ERC165MissingData_init();
     }
 }
-import "./ERC165MockUpgradeable.sol";
+import "./ERC165/ERC165NotSupportedUpgradeable.sol";
 
-contract ERC165MockUpgradeableWithInit is ERC165MockUpgradeable {
+contract ERC165NotSupportedUpgradeableWithInit is ERC165NotSupportedUpgradeable {
     constructor() payable initializer {
-        __ERC165Mock_init();
+        __ERC165NotSupported_init();
     }
 }
-import "./StringsMockUpgradeable.sol";
+import "./ERC165/ERC165ReturnBombUpgradeable.sol";
 
-contract StringsMockUpgradeableWithInit is StringsMockUpgradeable {
+contract ERC165ReturnBombMockUpgradeableWithInit is ERC165ReturnBombMockUpgradeable {
     constructor() payable initializer {
-        __StringsMock_init();
+        __ERC165ReturnBombMock_init();
     }
 }
-import "../proxy/ERC1967/ERC1967UpgradeUpgradeable.sol";
+import "./ERC2771ContextMockUpgradeable.sol";
 
-contract ERC1967UpgradeUpgradeableWithInit is ERC1967UpgradeUpgradeable {
+contract ERC2771ContextMockUpgradeableWithInit is ERC2771ContextMockUpgradeable {
+    constructor(address trustedForwarder) ERC2771ContextMockUpgradeable(trustedForwarder) payable initializer {
+
+    }
+}
+import "./ERC3156FlashBorrowerMockUpgradeable.sol";
+
+contract ERC3156FlashBorrowerMockUpgradeableWithInit is ERC3156FlashBorrowerMockUpgradeable {
+    constructor(bool enableReturn, bool enableApprove) payable initializer {
+        __ERC3156FlashBorrowerMock_init(enableReturn, enableApprove);
+    }
+}
+import "./EtherReceiverMockUpgradeable.sol";
+
+contract EtherReceiverMockUpgradeableWithInit is EtherReceiverMockUpgradeable {
     constructor() payable initializer {
-        __ERC1967Upgrade_init();
+        __EtherReceiverMock_init();
     }
 }
-import "./UUPS/UUPSUpgradeableMockUpgradeable.sol";
+import "./governance/GovernorCountingOverridableMockUpgradeable.sol";
 
-contract UUPSUpgradeableMockUpgradeableWithInit is UUPSUpgradeableMockUpgradeable {
+contract GovernorCountingOverridableMockUpgradeableWithInit is GovernorCountingOverridableMockUpgradeable {
     constructor() payable initializer {
-        __UUPSUpgradeableMock_init();
+        __GovernorCountingOverridableMock_init();
     }
 }
-import "./UUPS/UUPSUpgradeableMockUpgradeable.sol";
+import "./governance/GovernorFractionalMockUpgradeable.sol";
 
-contract UUPSUpgradeableUnsafeMockUpgradeableWithInit is UUPSUpgradeableUnsafeMockUpgradeable {
+contract GovernorFractionalMockUpgradeableWithInit is GovernorFractionalMockUpgradeable {
     constructor() payable initializer {
-        __UUPSUpgradeableUnsafeMock_init();
+        __GovernorFractionalMock_init();
     }
 }
-import "./CountersImplUpgradeable.sol";
+import "./governance/GovernorMockUpgradeable.sol";
 
-contract CountersImplUpgradeableWithInit is CountersImplUpgradeable {
+contract GovernorMockUpgradeableWithInit is GovernorMockUpgradeable {
     constructor() payable initializer {
-        __CountersImpl_init();
+        __GovernorMock_init();
     }
 }
-import "./UUPS/UUPSLegacyUpgradeable.sol";
+import "./governance/GovernorNoncesKeyedMockUpgradeable.sol";
 
-contract UUPSUpgradeableLegacyMockUpgradeableWithInit is UUPSUpgradeableLegacyMockUpgradeable {
+contract GovernorNoncesKeyedMockUpgradeableWithInit is GovernorNoncesKeyedMockUpgradeable {
     constructor() payable initializer {
-        __UUPSUpgradeableLegacyMock_init();
+        __GovernorNoncesKeyedMock_init();
     }
 }
-import "./StorageSlotMockUpgradeable.sol";
+import "./governance/GovernorPreventLateQuorumMockUpgradeable.sol";
 
-contract StorageSlotMockUpgradeableWithInit is StorageSlotMockUpgradeable {
+contract GovernorPreventLateQuorumMockUpgradeableWithInit is GovernorPreventLateQuorumMockUpgradeable {
+    constructor(uint256 quorum_) payable initializer {
+        __GovernorPreventLateQuorumMock_init(quorum_);
+    }
+}
+import "./governance/GovernorProposalGuardianMockUpgradeable.sol";
+
+contract GovernorProposalGuardianMockUpgradeableWithInit is GovernorProposalGuardianMockUpgradeable {
     constructor() payable initializer {
-        __StorageSlotMock_init();
+        __GovernorProposalGuardianMock_init();
     }
 }
-import "./ERC20SnapshotMockUpgradeable.sol";
+import "./governance/GovernorSequentialProposalIdMockUpgradeable.sol";
 
-contract ERC20SnapshotMockUpgradeableWithInit is ERC20SnapshotMockUpgradeable {
-    constructor(
-        string memory name,
-        string memory symbol,
-        address initialAccount,
-        uint256 initialBalance
-    ) payable initializer {
-        __ERC20SnapshotMock_init(name, symbol, initialAccount, initialBalance);
+contract GovernorSequentialProposalIdMockUpgradeableWithInit is GovernorSequentialProposalIdMockUpgradeable {
+    constructor() payable initializer {
+        __GovernorSequentialProposalIdMock_init();
     }
 }
-import "./ArraysMockUpgradeable.sol";
+import "./governance/GovernorStorageMockUpgradeable.sol";
 
-contract Uint256ArraysMockUpgradeableWithInit is Uint256ArraysMockUpgradeable {
-    constructor(uint256[] memory array) payable initializer {
-        __Uint256ArraysMock_init(array);
+contract GovernorStorageMockUpgradeableWithInit is GovernorStorageMockUpgradeable {
+    constructor() payable initializer {
+        __GovernorStorageMock_init();
+    }
+}
+import "./governance/GovernorSuperQuorumMockUpgradeable.sol";
+
+contract GovernorSuperQuorumMockUpgradeableWithInit is GovernorSuperQuorumMockUpgradeable {
+    constructor(uint256 quorum_, uint256 superQuorum_) payable initializer {
+        __GovernorSuperQuorumMock_init(quorum_, superQuorum_);
+    }
+}
+import "./governance/GovernorTimelockAccessMockUpgradeable.sol";
+
+contract GovernorTimelockAccessMockUpgradeableWithInit is GovernorTimelockAccessMockUpgradeable {
+    constructor() payable initializer {
+        __GovernorTimelockAccessMock_init();
+    }
+}
+import "./governance/GovernorTimelockCompoundMockUpgradeable.sol";
+
+contract GovernorTimelockCompoundMockUpgradeableWithInit is GovernorTimelockCompoundMockUpgradeable {
+    constructor() payable initializer {
+        __GovernorTimelockCompoundMock_init();
+    }
+}
+import "./governance/GovernorTimelockControlMockUpgradeable.sol";
+
+contract GovernorTimelockControlMockUpgradeableWithInit is GovernorTimelockControlMockUpgradeable {
+    constructor() payable initializer {
+        __GovernorTimelockControlMock_init();
+    }
+}
+import "./governance/GovernorVoteMockUpgradeable.sol";
+
+contract GovernorVoteMocksUpgradeableWithInit is GovernorVoteMocksUpgradeable {
+    constructor() payable initializer {
+        __GovernorVoteMocks_init();
+    }
+}
+import "./governance/GovernorVotesSuperQuorumFractionMockUpgradeable.sol";
+
+contract GovernorVotesSuperQuorumFractionMockUpgradeableWithInit is GovernorVotesSuperQuorumFractionMockUpgradeable {
+    constructor() payable initializer {
+        __GovernorVotesSuperQuorumFractionMock_init();
+    }
+}
+import "./governance/GovernorWithParamsMockUpgradeable.sol";
+
+contract GovernorWithParamsMockUpgradeableWithInit is GovernorWithParamsMockUpgradeable {
+    constructor() payable initializer {
+        __GovernorWithParamsMock_init();
+    }
+}
+import "./MerkleProofCustomHashMockUpgradeable.sol";
+
+contract MerkleProofCustomHashMockUpgradeableWithInit is MerkleProofCustomHashMockUpgradeable {
+    constructor() payable initializer {
+        __MerkleProofCustomHashMock_init();
+    }
+}
+import "./MerkleTreeMockUpgradeable.sol";
+
+contract MerkleTreeMockUpgradeableWithInit is MerkleTreeMockUpgradeable {
+    constructor() payable initializer {
+        __MerkleTreeMock_init();
+    }
+}
+import "./MulticallHelperUpgradeable.sol";
+
+contract MulticallHelperUpgradeableWithInit is MulticallHelperUpgradeable {
+    constructor() payable initializer {
+        __MulticallHelper_init();
+    }
+}
+import "./PausableMockUpgradeable.sol";
+
+contract PausableMockUpgradeableWithInit is PausableMockUpgradeable {
+    constructor() payable initializer {
+        __PausableMock_init();
+    }
+}
+import "./proxy/BadBeaconUpgradeable.sol";
+
+contract BadBeaconNoImplUpgradeableWithInit is BadBeaconNoImplUpgradeable {
+    constructor() payable initializer {
+        __BadBeaconNoImpl_init();
+    }
+}
+import "./proxy/BadBeaconUpgradeable.sol";
+
+contract BadBeaconNotContractUpgradeableWithInit is BadBeaconNotContractUpgradeable {
+    constructor() payable initializer {
+        __BadBeaconNotContract_init();
+    }
+}
+import "./proxy/ClashingImplementationUpgradeable.sol";
+
+contract ClashingImplementationUpgradeableWithInit is ClashingImplementationUpgradeable {
+    constructor() payable initializer {
+        __ClashingImplementation_init();
+    }
+}
+import "./proxy/UUPSUpgradeableMockUpgradeable.sol";
+
+contract NonUpgradeableMockUpgradeableWithInit is NonUpgradeableMockUpgradeable {
+    constructor() payable initializer {
+        __NonUpgradeableMock_init();
+    }
+}
+import "./proxy/UUPSUpgradeableMockUpgradeable.sol";
+
+contract UUPSUpgradeableMockUpgradeableWithInit is UUPSUpgradeableMockUpgradeable {
+    constructor() payable initializer {
+        __UUPSUpgradeableMock_init();
     }
 }
-import "./ArraysMockUpgradeable.sol";
+import "./proxy/UUPSUpgradeableMockUpgradeable.sol";
 
-contract AddressArraysMockUpgradeableWithInit is AddressArraysMockUpgradeable {
-    constructor(address[] memory array) payable initializer {
-        __AddressArraysMock_init(array);
+contract UUPSUpgradeableUnsafeMockUpgradeableWithInit is UUPSUpgradeableUnsafeMockUpgradeable {
+    constructor() payable initializer {
+        __UUPSUpgradeableUnsafeMock_init();
     }
 }
-import "./ArraysMockUpgradeable.sol";
+import "./proxy/UUPSUpgradeableMockUpgradeable.sol";
 
-contract Bytes32ArraysMockUpgradeableWithInit is Bytes32ArraysMockUpgradeable {
-    constructor(bytes32[] memory array) payable initializer {
-        __Bytes32ArraysMock_init(array);
+contract UUPSUnsupportedProxiableUUIDUpgradeableWithInit is UUPSUnsupportedProxiableUUIDUpgradeable {
+    constructor() payable initializer {
+        __UUPSUnsupportedProxiableUUID_init();
     }
 }
-import "./ERC4626MockUpgradeable.sol";
+import "./ReentrancyAttackUpgradeable.sol";
 
-contract ERC4626MockUpgradeableWithInit is ERC4626MockUpgradeable {
-    constructor(
-        IERC20MetadataUpgradeable asset,
-        string memory name,
-        string memory symbol
-    ) payable initializer {
-        __ERC4626Mock_init(asset, name, symbol);
+contract ReentrancyAttackUpgradeableWithInit is ReentrancyAttackUpgradeable {
+    constructor() payable initializer {
+        __ReentrancyAttack_init();
     }
 }
-import "./ERC4626MockUpgradeable.sol";
+import "./ReentrancyMockUpgradeable.sol";
 
-contract ERC4626DecimalMockUpgradeableWithInit is ERC4626DecimalMockUpgradeable {
-    constructor(
-        IERC20MetadataUpgradeable asset,
-        string memory name,
-        string memory symbol,
-        uint8 decimalsOverride
-    ) payable initializer {
-        __ERC4626DecimalMock_init(asset, name, symbol, decimalsOverride);
+contract ReentrancyMockUpgradeableWithInit is ReentrancyMockUpgradeable {
+    constructor() payable initializer {
+        __ReentrancyMock_init();
     }
 }
-import "./MathMockUpgradeable.sol";
+import "./ReentrancyTransientMockUpgradeable.sol";
 
-contract MathMockUpgradeableWithInit is MathMockUpgradeable {
+contract ReentrancyTransientMockUpgradeableWithInit is ReentrancyTransientMockUpgradeable {
     constructor() payable initializer {
-        __MathMock_init();
+        __ReentrancyTransientMock_init();
     }
 }
-import "./TimersTimestampImplUpgradeable.sol";
+import "./StatelessUpgradeable.sol";
 
-contract TimersTimestampImplUpgradeableWithInit is TimersTimestampImplUpgradeable {
+contract Dummy1234UpgradeableWithInit is Dummy1234Upgradeable {
     constructor() payable initializer {
-        __TimersTimestampImpl_init();
+        __Dummy1234_init();
     }
 }
-import "./TimersBlockNumberImplUpgradeable.sol";
+import "./StorageSlotMockUpgradeable.sol";
 
-contract TimersBlockNumberImplUpgradeableWithInit is TimersBlockNumberImplUpgradeable {
+contract StorageSlotMockUpgradeableWithInit is StorageSlotMockUpgradeable {
     constructor() payable initializer {
-        __TimersBlockNumberImpl_init();
+        __StorageSlotMock_init();
     }
 }
-import "../token/ERC721/utils/ERC721HolderUpgradeable.sol";
+import "./TimelockReentrantUpgradeable.sol";
 
-contract ERC721HolderUpgradeableWithInit is ERC721HolderUpgradeable {
+contract TimelockReentrantUpgradeableWithInit is TimelockReentrantUpgradeable {
     constructor() payable initializer {
-        __ERC721Holder_init();
+        __TimelockReentrant_init();
     }
 }
-import "./ERC721ReceiverMockUpgradeable.sol";
+import "./token/ERC1155ReceiverMockUpgradeable.sol";
 
-contract ERC721ReceiverMockUpgradeableWithInit is ERC721ReceiverMockUpgradeable {
-    constructor(bytes4 retval, Error error) payable initializer {
-        __ERC721ReceiverMock_init(retval, error);
+contract ERC1155ReceiverMockUpgradeableWithInit is ERC1155ReceiverMockUpgradeable {
+    constructor(bytes4 recRetval, bytes4 batRetval, RevertType error) payable initializer {
+        __ERC1155ReceiverMock_init(recRetval, batRetval, error);
     }
 }
-import "./ERC721VotesMockUpgradeable.sol";
+import "./token/ERC1363ForceApproveMockUpgradeable.sol";
 
-contract ERC721VotesMockUpgradeableWithInit is ERC721VotesMockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC721VotesMock_init(name, symbol);
+contract ERC1363ForceApproveMockUpgradeableWithInit is ERC1363ForceApproveMockUpgradeable {
+    constructor() payable initializer {
+        __ERC1363ForceApproveMock_init();
     }
 }
-import "./ERC721URIStorageMockUpgradeable.sol";
+import "./token/ERC1363NoReturnMockUpgradeable.sol";
 
-contract ERC721URIStorageMockUpgradeableWithInit is ERC721URIStorageMockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC721URIStorageMock_init(name, symbol);
+contract ERC1363NoReturnMockUpgradeableWithInit is ERC1363NoReturnMockUpgradeable {
+    constructor() payable initializer {
+        __ERC1363NoReturnMock_init();
     }
 }
-import "./ERC721MockUpgradeable.sol";
+import "./token/ERC1363ReceiverMockUpgradeable.sol";
 
-contract ERC721MockUpgradeableWithInit is ERC721MockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC721Mock_init(name, symbol);
+contract ERC1363ReceiverMockUpgradeableWithInit is ERC1363ReceiverMockUpgradeable {
+    constructor() payable initializer {
+        __ERC1363ReceiverMock_init();
     }
 }
-import "./ERC721PausableMockUpgradeable.sol";
+import "./token/ERC1363ReturnFalseMockUpgradeable.sol";
 
-contract ERC721PausableMockUpgradeableWithInit is ERC721PausableMockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC721PausableMock_init(name, symbol);
+contract ERC1363ReturnFalseOnERC20MockUpgradeableWithInit is ERC1363ReturnFalseOnERC20MockUpgradeable {
+    constructor() payable initializer {
+        __ERC1363ReturnFalseOnERC20Mock_init();
     }
 }
-import "./ERC20PausableMockUpgradeable.sol";
+import "./token/ERC1363ReturnFalseMockUpgradeable.sol";
 
-contract ERC20PausableMockUpgradeableWithInit is ERC20PausableMockUpgradeable {
-    constructor(
-        string memory name,
-        string memory symbol,
-        address initialAccount,
-        uint256 initialBalance
-    ) payable initializer {
-        __ERC20PausableMock_init(name, symbol, initialAccount, initialBalance);
+contract ERC1363ReturnFalseMockUpgradeableWithInit is ERC1363ReturnFalseMockUpgradeable {
+    constructor() payable initializer {
+        __ERC1363ReturnFalseMock_init();
     }
 }
-import "./PausableMockUpgradeable.sol";
+import "./token/ERC1363SpenderMockUpgradeable.sol";
 
-contract PausableMockUpgradeableWithInit is PausableMockUpgradeable {
+contract ERC1363SpenderMockUpgradeableWithInit is ERC1363SpenderMockUpgradeable {
     constructor() payable initializer {
-        __PausableMock_init();
+        __ERC1363SpenderMock_init();
     }
 }
-import "./AccessControlEnumerableMockUpgradeable.sol";
+import "./token/ERC20ApprovalMockUpgradeable.sol";
 
-contract AccessControlEnumerableMockUpgradeableWithInit is AccessControlEnumerableMockUpgradeable {
+contract ERC20ApprovalMockUpgradeableWithInit is ERC20ApprovalMockUpgradeable {
     constructor() payable initializer {
-        __AccessControlEnumerableMock_init();
+        __ERC20ApprovalMock_init();
     }
 }
-import "./EnumerableMapMockUpgradeable.sol";
+import "./token/ERC20BridgeableMockUpgradeable.sol";
 
-contract UintToAddressMapMockUpgradeableWithInit is UintToAddressMapMockUpgradeable {
-    constructor() payable initializer {
-        __UintToAddressMapMock_init();
+contract ERC20BridgeableMockUpgradeableWithInit is ERC20BridgeableMockUpgradeable {
+    constructor(address bridge) payable initializer {
+        __ERC20BridgeableMock_init(bridge);
     }
 }
-import "./EnumerableMapMockUpgradeable.sol";
+import "./token/ERC20DecimalsMockUpgradeable.sol";
 
-contract AddressToUintMapMockUpgradeableWithInit is AddressToUintMapMockUpgradeable {
-    constructor() payable initializer {
-        __AddressToUintMapMock_init();
+contract ERC20DecimalsMockUpgradeableWithInit is ERC20DecimalsMockUpgradeable {
+    constructor(uint8 decimals_) payable initializer {
+        __ERC20DecimalsMock_init(decimals_);
     }
 }
-import "./EnumerableMapMockUpgradeable.sol";
+import "./token/ERC20ExcessDecimalsMockUpgradeable.sol";
 
-contract Bytes32ToBytes32MapMockUpgradeableWithInit is Bytes32ToBytes32MapMockUpgradeable {
+contract ERC20ExcessDecimalsMockUpgradeableWithInit is ERC20ExcessDecimalsMockUpgradeable {
     constructor() payable initializer {
-        __Bytes32ToBytes32MapMock_init();
+        __ERC20ExcessDecimalsMock_init();
     }
 }
-import "./EnumerableMapMockUpgradeable.sol";
+import "./token/ERC20FlashMintMockUpgradeable.sol";
 
-contract UintToUintMapMockUpgradeableWithInit is UintToUintMapMockUpgradeable {
+contract ERC20FlashMintMockUpgradeableWithInit is ERC20FlashMintMockUpgradeable {
     constructor() payable initializer {
-        __UintToUintMapMock_init();
+        __ERC20FlashMintMock_init();
     }
 }
-import "./EnumerableMapMockUpgradeable.sol";
+import "./token/ERC20ForceApproveMockUpgradeable.sol";
 
-contract Bytes32ToUintMapMockUpgradeableWithInit is Bytes32ToUintMapMockUpgradeable {
+contract ERC20ForceApproveMockUpgradeableWithInit is ERC20ForceApproveMockUpgradeable {
     constructor() payable initializer {
-        __Bytes32ToUintMapMock_init();
+        __ERC20ForceApproveMock_init();
     }
 }
-import "./EnumerableSetMockUpgradeable.sol";
+import "./token/ERC20GetterHelperUpgradeable.sol";
 
-contract EnumerableBytes32SetMockUpgradeableWithInit is EnumerableBytes32SetMockUpgradeable {
+contract ERC20GetterHelperUpgradeableWithInit is ERC20GetterHelperUpgradeable {
     constructor() payable initializer {
-        __EnumerableBytes32SetMock_init();
+        __ERC20GetterHelper_init();
     }
 }
-import "./EnumerableSetMockUpgradeable.sol";
+import "./token/ERC20MockUpgradeable.sol";
 
-contract EnumerableAddressSetMockUpgradeableWithInit is EnumerableAddressSetMockUpgradeable {
+contract ERC20MockUpgradeableWithInit is ERC20MockUpgradeable {
     constructor() payable initializer {
-        __EnumerableAddressSetMock_init();
+        __ERC20Mock_init();
     }
 }
-import "./EnumerableSetMockUpgradeable.sol";
+import "./token/ERC20MulticallMockUpgradeable.sol";
 
-contract EnumerableUintSetMockUpgradeableWithInit is EnumerableUintSetMockUpgradeable {
+contract ERC20MulticallMockUpgradeableWithInit is ERC20MulticallMockUpgradeable {
     constructor() payable initializer {
-        __EnumerableUintSetMock_init();
+        __ERC20MulticallMock_init();
     }
 }
-import "./SafeERC20HelperUpgradeable.sol";
+import "./token/ERC20NoReturnMockUpgradeable.sol";
 
-contract ERC20ReturnFalseMockUpgradeableWithInit is ERC20ReturnFalseMockUpgradeable {
+contract ERC20NoReturnMockUpgradeableWithInit is ERC20NoReturnMockUpgradeable {
     constructor() payable initializer {
-        __ERC20ReturnFalseMock_init();
+        __ERC20NoReturnMock_init();
     }
 }
-import "./SafeERC20HelperUpgradeable.sol";
+import "./token/ERC20ReentrantUpgradeable.sol";
 
-contract ERC20ReturnTrueMockUpgradeableWithInit is ERC20ReturnTrueMockUpgradeable {
+contract ERC20ReentrantUpgradeableWithInit is ERC20ReentrantUpgradeable {
     constructor() payable initializer {
-        __ERC20ReturnTrueMock_init();
+        __ERC20Reentrant_init();
     }
 }
-import "./SafeERC20HelperUpgradeable.sol";
+import "./token/ERC20ReturnFalseMockUpgradeable.sol";
 
-contract ERC20NoReturnMockUpgradeableWithInit is ERC20NoReturnMockUpgradeable {
+contract ERC20ReturnFalseMockUpgradeableWithInit is ERC20ReturnFalseMockUpgradeable {
     constructor() payable initializer {
-        __ERC20NoReturnMock_init();
+        __ERC20ReturnFalseMock_init();
     }
 }
-import "./SafeERC20HelperUpgradeable.sol";
+import "./token/ERC20VotesAdditionalCheckpointsMockUpgradeable.sol";
 
-contract ERC20PermitNoRevertMockUpgradeableWithInit is ERC20PermitNoRevertMockUpgradeable {
+contract ERC20VotesExtendedMockUpgradeableWithInit is ERC20VotesExtendedMockUpgradeable {
     constructor() payable initializer {
-        __ERC20PermitNoRevertMock_init();
+        __ERC20VotesExtendedMock_init();
     }
 }
-import "./SafeERC20HelperUpgradeable.sol";
+import "./token/ERC20VotesAdditionalCheckpointsMockUpgradeable.sol";
 
-contract SafeERC20WrapperUpgradeableWithInit is SafeERC20WrapperUpgradeable {
-    constructor(IERC20Upgradeable token) payable initializer {
-        __SafeERC20Wrapper_init(token);
+contract ERC20VotesExtendedTimestampMockUpgradeableWithInit is ERC20VotesExtendedTimestampMockUpgradeable {
+    constructor() payable initializer {
+        __ERC20VotesExtendedTimestampMock_init();
     }
 }
-import "./ERC20PermitMockUpgradeable.sol";
+import "./token/ERC20VotesLegacyMockUpgradeable.sol";
 
-contract ERC20PermitMockUpgradeableWithInit is ERC20PermitMockUpgradeable {
-    constructor(
-        string memory name,
-        string memory symbol,
-        address initialAccount,
-        uint256 initialBalance
-    ) payable initializer {
-        __ERC20PermitMock_init(name, symbol, initialAccount, initialBalance);
+contract ERC20VotesLegacyMockUpgradeableWithInit is ERC20VotesLegacyMockUpgradeable {
+    constructor() payable initializer {
+        __ERC20VotesLegacyMock_init();
     }
 }
-import "./ERC20WrapperMockUpgradeable.sol";
+import "./token/ERC20VotesTimestampMockUpgradeable.sol";
 
-contract ERC20WrapperMockUpgradeableWithInit is ERC20WrapperMockUpgradeable {
-    constructor(
-        IERC20Upgradeable _underlyingToken,
-        string memory name,
-        string memory symbol
-    ) payable initializer {
-        __ERC20WrapperMock_init(_underlyingToken, name, symbol);
+contract ERC20VotesTimestampMockUpgradeableWithInit is ERC20VotesTimestampMockUpgradeable {
+    constructor() payable initializer {
+        __ERC20VotesTimestampMock_init();
     }
 }
-import "../finance/VestingWalletUpgradeable.sol";
+import "./token/ERC20VotesTimestampMockUpgradeable.sol";
 
-contract VestingWalletUpgradeableWithInit is VestingWalletUpgradeable {
-    constructor(
-        address beneficiaryAddress,
-        uint64 startTimestamp,
-        uint64 durationSeconds
-    ) payable initializer {
-        __VestingWallet_init(beneficiaryAddress, startTimestamp, durationSeconds);
+contract ERC721VotesTimestampMockUpgradeableWithInit is ERC721VotesTimestampMockUpgradeable {
+    constructor() payable initializer {
+        __ERC721VotesTimestampMock_init();
     }
 }
-import "../finance/PaymentSplitterUpgradeable.sol";
+import "./token/ERC4626LimitsMockUpgradeable.sol";
 
-contract PaymentSplitterUpgradeableWithInit is PaymentSplitterUpgradeable {
-    constructor(address[] memory payees, uint256[] memory shares_) payable initializer {
-        __PaymentSplitter_init(payees, shares_);
+contract ERC4626LimitsMockUpgradeableWithInit is ERC4626LimitsMockUpgradeable {
+    constructor() payable initializer {
+        __ERC4626LimitsMock_init();
     }
 }
-import "./ERC3156FlashBorrowerMockUpgradeable.sol";
+import "./token/ERC4626MockUpgradeable.sol";
 
-contract ERC3156FlashBorrowerMockUpgradeableWithInit is ERC3156FlashBorrowerMockUpgradeable {
-    constructor(bool enableReturn, bool enableApprove) payable initializer {
-        __ERC3156FlashBorrowerMock_init(enableReturn, enableApprove);
+contract ERC4626MockUpgradeableWithInit is ERC4626MockUpgradeable {
+    constructor(address underlying) payable initializer {
+        __ERC4626Mock_init(underlying);
     }
 }
-import "./ERC20FlashMintMockUpgradeable.sol";
+import "./token/ERC4626OffsetMockUpgradeable.sol";
 
-contract ERC20FlashMintMockUpgradeableWithInit is ERC20FlashMintMockUpgradeable {
-    constructor(
-        string memory name,
-        string memory symbol,
-        address initialAccount,
-        uint256 initialBalance
-    ) payable initializer {
-        __ERC20FlashMintMock_init(name, symbol, initialAccount, initialBalance);
+contract ERC4626OffsetMockUpgradeableWithInit is ERC4626OffsetMockUpgradeable {
+    constructor(uint8 offset_) payable initializer {
+        __ERC4626OffsetMock_init(offset_);
     }
 }
-import "./ERC777MockUpgradeable.sol";
+import "./token/ERC4646FeesMockUpgradeable.sol";
 
-contract ERC777MockUpgradeableWithInit is ERC777MockUpgradeable {
+contract ERC4626FeesMockUpgradeableWithInit is ERC4626FeesMockUpgradeable {
     constructor(
-        address initialHolder,
-        uint256 initialBalance,
-        string memory name,
-        string memory symbol,
-        address[] memory defaultOperators
+        uint256 entryFeeBasisPoints,
+        address entryFeeRecipient,
+        uint256 exitFeeBasisPoints,
+        address exitFeeRecipient
     ) payable initializer {
-        __ERC777Mock_init(initialHolder, initialBalance, name, symbol, defaultOperators);
+        __ERC4626FeesMock_init(entryFeeBasisPoints, entryFeeRecipient, exitFeeBasisPoints, exitFeeRecipient);
     }
 }
-import "../token/ERC20/presets/ERC20PresetFixedSupplyUpgradeable.sol";
+import "./token/ERC721ConsecutiveEnumerableMockUpgradeable.sol";
 
-contract ERC20PresetFixedSupplyUpgradeableWithInit is ERC20PresetFixedSupplyUpgradeable {
+contract ERC721ConsecutiveEnumerableMockUpgradeableWithInit is ERC721ConsecutiveEnumerableMockUpgradeable {
     constructor(
         string memory name,
         string memory symbol,
-        uint256 initialSupply,
-        address owner
+        address[] memory receivers,
+        uint96[] memory amounts
     ) payable initializer {
-        __ERC20PresetFixedSupply_init(name, symbol, initialSupply, owner);
+        __ERC721ConsecutiveEnumerableMock_init(name, symbol, receivers, amounts);
     }
 }
-import "./ERC20BurnableMockUpgradeable.sol";
+import "./token/ERC721ConsecutiveMockUpgradeable.sol";
 
-contract ERC20BurnableMockUpgradeableWithInit is ERC20BurnableMockUpgradeable {
+contract ERC721ConsecutiveMockUpgradeableWithInit is ERC721ConsecutiveMockUpgradeable {
     constructor(
         string memory name,
         string memory symbol,
-        address initialAccount,
-        uint256 initialBalance
+        uint96 offset,
+        address[] memory delegates,
+        address[] memory receivers,
+        uint96[] memory amounts
     ) payable initializer {
-        __ERC20BurnableMock_init(name, symbol, initialAccount, initialBalance);
+        __ERC721ConsecutiveMock_init(name, symbol, offset, delegates, receivers, amounts);
     }
 }
-import "./ReentrancyAttackUpgradeable.sol";
+import "./token/ERC721ConsecutiveMockUpgradeable.sol";
 
-contract ReentrancyAttackUpgradeableWithInit is ReentrancyAttackUpgradeable {
-    constructor() payable initializer {
-        __ReentrancyAttack_init();
+contract ERC721ConsecutiveNoConstructorMintMockUpgradeableWithInit is ERC721ConsecutiveNoConstructorMintMockUpgradeable {
+    constructor(string memory name, string memory symbol) payable initializer {
+        __ERC721ConsecutiveNoConstructorMintMock_init(name, symbol);
     }
 }
-import "./ReentrancyMockUpgradeable.sol";
+import "./token/ERC721ReceiverMockUpgradeable.sol";
 
-contract ReentrancyMockUpgradeableWithInit is ReentrancyMockUpgradeable {
-    constructor() payable initializer {
-        __ReentrancyMock_init();
+contract ERC721ReceiverMockUpgradeableWithInit is ERC721ReceiverMockUpgradeable {
+    constructor(bytes4 retval, RevertType error) payable initializer {
+        __ERC721ReceiverMock_init(retval, error);
     }
 }
-import "../security/ReentrancyGuardUpgradeable.sol";
+import "./token/ERC721URIStorageMockUpgradeable.sol";
 
-contract ReentrancyGuardUpgradeableWithInit is ReentrancyGuardUpgradeable {
+contract ERC721URIStorageMockUpgradeableWithInit is ERC721URIStorageMockUpgradeable {
     constructor() payable initializer {
-        __ReentrancyGuard_init();
+        __ERC721URIStorageMock_init();
     }
 }
-import "../crosschain/polygon/CrossChainEnabledPolygonChildUpgradeable.sol";
-
-contract CrossChainEnabledPolygonChildUpgradeableWithInit is CrossChainEnabledPolygonChildUpgradeable {
-    constructor(address fxChild) CrossChainEnabledPolygonChildUpgradeable(fxChild) payable initializer {
+import "./TransientSlotMockUpgradeable.sol";
 
+contract TransientSlotMockUpgradeableWithInit is TransientSlotMockUpgradeable {
+    constructor() payable initializer {
+        __TransientSlotMock_init();
     }
 }
-import "./crosschain/receiversUpgradeable.sol";
-
-contract CrossChainEnabledAMBMockUpgradeableWithInit is CrossChainEnabledAMBMockUpgradeable {
-    constructor(address bridge) CrossChainEnabledAMBMockUpgradeable(bridge) payable initializer {
+import "./UpgradeableBeaconMockUpgradeable.sol";
 
+contract UpgradeableBeaconMockUpgradeableWithInit is UpgradeableBeaconMockUpgradeable {
+    constructor(address impl) payable initializer {
+        __UpgradeableBeaconMock_init(impl);
     }
 }
-import "./crosschain/receiversUpgradeable.sol";
-
-contract CrossChainEnabledArbitrumL1MockUpgradeableWithInit is CrossChainEnabledArbitrumL1MockUpgradeable {
-    constructor(address bridge) CrossChainEnabledArbitrumL1MockUpgradeable(bridge) payable initializer {
+import "./UpgradeableBeaconMockUpgradeable.sol";
 
+contract UpgradeableBeaconReentrantMockUpgradeableWithInit is UpgradeableBeaconReentrantMockUpgradeable {
+    constructor() payable initializer {
+        __UpgradeableBeaconReentrantMock_init();
     }
 }
-import "./crosschain/receiversUpgradeable.sol";
+import "./utils/cryptography/ERC7739MockUpgradeable.sol";
 
-contract CrossChainEnabledArbitrumL2MockUpgradeableWithInit is CrossChainEnabledArbitrumL2MockUpgradeable {
+contract ERC7739ECDSAMockUpgradeableWithInit is ERC7739ECDSAMockUpgradeable {
     constructor() payable initializer {
-        __CrossChainEnabledArbitrumL2Mock_init();
+        __ERC7739ECDSAMock_init();
     }
 }
-import "./crosschain/receiversUpgradeable.sol";
-
-contract CrossChainEnabledOptimismMockUpgradeableWithInit is CrossChainEnabledOptimismMockUpgradeable {
-    constructor(address bridge) CrossChainEnabledOptimismMockUpgradeable(bridge) payable initializer {
+import "./utils/cryptography/ERC7739MockUpgradeable.sol";
 
+contract ERC7739P256MockUpgradeableWithInit is ERC7739P256MockUpgradeable {
+    constructor() payable initializer {
+        __ERC7739P256Mock_init();
     }
 }
-import "./crosschain/receiversUpgradeable.sol";
-
-contract CrossChainEnabledPolygonChildMockUpgradeableWithInit is CrossChainEnabledPolygonChildMockUpgradeable {
-    constructor(address bridge) CrossChainEnabledPolygonChildMockUpgradeable(bridge) payable initializer {
+import "./utils/cryptography/ERC7739MockUpgradeable.sol";
 
+contract ERC7739RSAMockUpgradeableWithInit is ERC7739RSAMockUpgradeable {
+    constructor() payable initializer {
+        __ERC7739RSAMock_init();
     }
 }
-import "../crosschain/amb/CrossChainEnabledAMBUpgradeable.sol";
-
-contract CrossChainEnabledAMBUpgradeableWithInit is CrossChainEnabledAMBUpgradeable {
-    constructor(address bridge) CrossChainEnabledAMBUpgradeable(bridge) payable initializer {
+import "./VotesExtendedMockUpgradeable.sol";
 
+contract VotesExtendedMockUpgradeableWithInit is VotesExtendedMockUpgradeable {
+    constructor() payable initializer {
+        __VotesExtendedMock_init();
     }
 }
-import "../crosschain/arbitrum/CrossChainEnabledArbitrumL1Upgradeable.sol";
-
-contract CrossChainEnabledArbitrumL1UpgradeableWithInit is CrossChainEnabledArbitrumL1Upgradeable {
-    constructor(address bridge) CrossChainEnabledArbitrumL1Upgradeable(bridge) payable initializer {
+import "./VotesExtendedMockUpgradeable.sol";
 
+contract VotesExtendedTimestampMockUpgradeableWithInit is VotesExtendedTimestampMockUpgradeable {
+    constructor() payable initializer {
+        __VotesExtendedTimestampMock_init();
     }
 }
-import "../crosschain/arbitrum/CrossChainEnabledArbitrumL2Upgradeable.sol";
+import "./VotesMockUpgradeable.sol";
 
-contract CrossChainEnabledArbitrumL2UpgradeableWithInit is CrossChainEnabledArbitrumL2Upgradeable {
+contract VotesMockUpgradeableWithInit is VotesMockUpgradeable {
     constructor() payable initializer {
-        __CrossChainEnabledArbitrumL2_init();
+        __VotesMock_init();
     }
 }
-import "../crosschain/optimism/CrossChainEnabledOptimismUpgradeable.sol";
-
-contract CrossChainEnabledOptimismUpgradeableWithInit is CrossChainEnabledOptimismUpgradeable {
-    constructor(address messenger) CrossChainEnabledOptimismUpgradeable(messenger) payable initializer {
+import "./VotesMockUpgradeable.sol";
 
+contract VotesTimestampMockUpgradeableWithInit is VotesTimestampMockUpgradeable {
+    constructor() payable initializer {
+        __VotesTimestampMock_init();
     }
 }
-import "./AccessControlCrossChainMockUpgradeable.sol";
+import "../token/common/ERC2981Upgradeable.sol";
 
-contract AccessControlCrossChainMockUpgradeableWithInit is AccessControlCrossChainMockUpgradeable {
+contract ERC2981UpgradeableWithInit is ERC2981Upgradeable {
     constructor() payable initializer {
-        __AccessControlCrossChainMock_init();
+        __ERC2981_init();
     }
 }
-import "./crosschain/bridgesUpgradeable.sol";
+import "../token/ERC1155/ERC1155Upgradeable.sol";
 
-contract BaseRelayMockUpgradeableWithInit is BaseRelayMockUpgradeable {
-    constructor() payable initializer {
-        __BaseRelayMock_init();
+contract ERC1155UpgradeableWithInit is ERC1155Upgradeable {
+    constructor(string memory uri_) payable initializer {
+        __ERC1155_init(uri_);
     }
 }
-import "./crosschain/bridgesUpgradeable.sol";
+import "../token/ERC1155/extensions/ERC1155BurnableUpgradeable.sol";
 
-contract BridgeAMBMockUpgradeableWithInit is BridgeAMBMockUpgradeable {
+contract ERC1155BurnableUpgradeableWithInit is ERC1155BurnableUpgradeable {
     constructor() payable initializer {
-        __BridgeAMBMock_init();
+        __ERC1155Burnable_init();
     }
 }
-import "./crosschain/bridgesUpgradeable.sol";
+import "../token/ERC1155/extensions/ERC1155PausableUpgradeable.sol";
 
-contract BridgeArbitrumL1MockUpgradeableWithInit is BridgeArbitrumL1MockUpgradeable {
+contract ERC1155PausableUpgradeableWithInit is ERC1155PausableUpgradeable {
     constructor() payable initializer {
-        __BridgeArbitrumL1Mock_init();
+        __ERC1155Pausable_init();
     }
 }
-import "./crosschain/bridgesUpgradeable.sol";
+import "../token/ERC1155/extensions/ERC1155SupplyUpgradeable.sol";
 
-contract BridgeArbitrumL1InboxUpgradeableWithInit is BridgeArbitrumL1InboxUpgradeable {
+contract ERC1155SupplyUpgradeableWithInit is ERC1155SupplyUpgradeable {
     constructor() payable initializer {
-        __BridgeArbitrumL1Inbox_init();
+        __ERC1155Supply_init();
     }
 }
-import "./crosschain/bridgesUpgradeable.sol";
+import "../token/ERC1155/extensions/ERC1155URIStorageUpgradeable.sol";
 
-contract BridgeArbitrumL1OutboxUpgradeableWithInit is BridgeArbitrumL1OutboxUpgradeable {
+contract ERC1155URIStorageUpgradeableWithInit is ERC1155URIStorageUpgradeable {
     constructor() payable initializer {
-        __BridgeArbitrumL1Outbox_init();
+        __ERC1155URIStorage_init();
     }
 }
-import "./crosschain/bridgesUpgradeable.sol";
+import "../token/ERC1155/utils/ERC1155HolderUpgradeable.sol";
 
-contract BridgeArbitrumL2MockUpgradeableWithInit is BridgeArbitrumL2MockUpgradeable {
+contract ERC1155HolderUpgradeableWithInit is ERC1155HolderUpgradeable {
     constructor() payable initializer {
-        __BridgeArbitrumL2Mock_init();
+        __ERC1155Holder_init();
     }
 }
-import "./crosschain/bridgesUpgradeable.sol";
+import "../token/ERC20/ERC20Upgradeable.sol";
 
-contract BridgeOptimismMockUpgradeableWithInit is BridgeOptimismMockUpgradeable {
-    constructor() payable initializer {
-        __BridgeOptimismMock_init();
+contract ERC20UpgradeableWithInit is ERC20Upgradeable {
+    constructor(string memory name_, string memory symbol_) payable initializer {
+        __ERC20_init(name_, symbol_);
     }
 }
-import "./crosschain/bridgesUpgradeable.sol";
+import "../token/ERC20/extensions/draft-ERC20TemporaryApprovalUpgradeable.sol";
 
-contract BridgePolygonChildMockUpgradeableWithInit is BridgePolygonChildMockUpgradeable {
+contract ERC20TemporaryApprovalUpgradeableWithInit is ERC20TemporaryApprovalUpgradeable {
     constructor() payable initializer {
-        __BridgePolygonChildMock_init();
+        __ERC20TemporaryApproval_init();
     }
 }
-import "./ContextMockUpgradeable.sol";
+import "../token/ERC20/extensions/ERC1363Upgradeable.sol";
 
-contract ContextMockUpgradeableWithInit is ContextMockUpgradeable {
+contract ERC1363UpgradeableWithInit is ERC1363Upgradeable {
     constructor() payable initializer {
-        __ContextMock_init();
+        __ERC1363_init();
     }
 }
-import "./ContextMockUpgradeable.sol";
+import "../token/ERC20/extensions/ERC20BurnableUpgradeable.sol";
 
-contract ContextMockCallerUpgradeableWithInit is ContextMockCallerUpgradeable {
+contract ERC20BurnableUpgradeableWithInit is ERC20BurnableUpgradeable {
     constructor() payable initializer {
-        __ContextMockCaller_init();
+        __ERC20Burnable_init();
     }
 }
-import "./ERC2771ContextMockUpgradeable.sol";
-
-contract ERC2771ContextMockUpgradeableWithInit is ERC2771ContextMockUpgradeable {
-    constructor(address trustedForwarder) ERC2771ContextMockUpgradeable(trustedForwarder) payable initializer {
+import "../token/ERC20/extensions/ERC20CappedUpgradeable.sol";
 
+contract ERC20CappedUpgradeableWithInit is ERC20CappedUpgradeable {
+    constructor(uint256 cap_) payable initializer {
+        __ERC20Capped_init(cap_);
     }
 }
-import "../metatx/ERC2771ContextUpgradeable.sol";
-
-contract ERC2771ContextUpgradeableWithInit is ERC2771ContextUpgradeable {
-    constructor(address trustedForwarder) ERC2771ContextUpgradeable(trustedForwarder) payable initializer {
+import "../token/ERC20/extensions/ERC20FlashMintUpgradeable.sol";
 
+contract ERC20FlashMintUpgradeableWithInit is ERC20FlashMintUpgradeable {
+    constructor() payable initializer {
+        __ERC20FlashMint_init();
     }
 }
-import "./ERC20CappedMockUpgradeable.sol";
+import "../token/ERC20/extensions/ERC20PausableUpgradeable.sol";
 
-contract ERC20CappedMockUpgradeableWithInit is ERC20CappedMockUpgradeable {
-    constructor(
-        string memory name,
-        string memory symbol,
-        uint256 cap
-    ) payable initializer {
-        __ERC20CappedMock_init(name, symbol, cap);
+contract ERC20PausableUpgradeableWithInit is ERC20PausableUpgradeable {
+    constructor() payable initializer {
+        __ERC20Pausable_init();
     }
 }
-import "./ERC20DecimalsMockUpgradeable.sol";
+import "../token/ERC20/extensions/ERC20PermitUpgradeable.sol";
 
-contract ERC20DecimalsMockUpgradeableWithInit is ERC20DecimalsMockUpgradeable {
-    constructor(
-        string memory name_,
-        string memory symbol_,
-        uint8 decimals_
-    ) payable initializer {
-        __ERC20DecimalsMock_init(name_, symbol_, decimals_);
+contract ERC20PermitUpgradeableWithInit is ERC20PermitUpgradeable {
+    constructor(string memory name) payable initializer {
+        __ERC20Permit_init(name);
     }
 }
-import "./MulticallTestUpgradeable.sol";
+import "../token/ERC20/extensions/ERC20VotesUpgradeable.sol";
 
-contract MulticallTestUpgradeableWithInit is MulticallTestUpgradeable {
+contract ERC20VotesUpgradeableWithInit is ERC20VotesUpgradeable {
     constructor() payable initializer {
-        __MulticallTest_init();
+        __ERC20Votes_init();
     }
 }
-import "./ClonesMockUpgradeable.sol";
+import "../token/ERC20/extensions/ERC20WrapperUpgradeable.sol";
 
-contract ClonesMockUpgradeableWithInit is ClonesMockUpgradeable {
-    constructor() payable initializer {
-        __ClonesMock_init();
+contract ERC20WrapperUpgradeableWithInit is ERC20WrapperUpgradeable {
+    constructor(IERC20 underlyingToken) payable initializer {
+        __ERC20Wrapper_init(underlyingToken);
     }
 }
-import "./AddressImplUpgradeable.sol";
+import "../token/ERC20/extensions/ERC4626Upgradeable.sol";
 
-contract AddressImplUpgradeableWithInit is AddressImplUpgradeable {
-    constructor() payable initializer {
-        __AddressImpl_init();
+contract ERC4626UpgradeableWithInit is ERC4626Upgradeable {
+    constructor(IERC20 asset_) payable initializer {
+        __ERC4626_init(asset_);
     }
 }
-import "../utils/escrow/RefundEscrowUpgradeable.sol";
+import "../token/ERC6909/draft-ERC6909Upgradeable.sol";
 
-contract RefundEscrowUpgradeableWithInit is RefundEscrowUpgradeable {
-    constructor(address payable beneficiary_) payable initializer {
-        __RefundEscrow_init(beneficiary_);
+contract ERC6909UpgradeableWithInit is ERC6909Upgradeable {
+    constructor() payable initializer {
+        __ERC6909_init();
     }
 }
-import "./ConditionalEscrowMockUpgradeable.sol";
+import "../token/ERC6909/extensions/draft-ERC6909ContentURIUpgradeable.sol";
 
-contract ConditionalEscrowMockUpgradeableWithInit is ConditionalEscrowMockUpgradeable {
+contract ERC6909ContentURIUpgradeableWithInit is ERC6909ContentURIUpgradeable {
     constructor() payable initializer {
-        __ConditionalEscrowMock_init();
+        __ERC6909ContentURI_init();
     }
 }
-import "../security/PullPaymentUpgradeable.sol";
+import "../token/ERC6909/extensions/draft-ERC6909MetadataUpgradeable.sol";
 
-contract PullPaymentUpgradeableWithInit is PullPaymentUpgradeable {
+contract ERC6909MetadataUpgradeableWithInit is ERC6909MetadataUpgradeable {
     constructor() payable initializer {
-        __PullPayment_init();
+        __ERC6909Metadata_init();
     }
 }
-import "./PullPaymentMockUpgradeable.sol";
+import "../token/ERC6909/extensions/draft-ERC6909TokenSupplyUpgradeable.sol";
 
-contract PullPaymentMockUpgradeableWithInit is PullPaymentMockUpgradeable {
+contract ERC6909TokenSupplyUpgradeableWithInit is ERC6909TokenSupplyUpgradeable {
     constructor() payable initializer {
-        __PullPaymentMock_init();
+        __ERC6909TokenSupply_init();
+    }
+}
+import "../token/ERC721/ERC721Upgradeable.sol";
+
+contract ERC721UpgradeableWithInit is ERC721Upgradeable {
+    constructor(string memory name_, string memory symbol_) payable initializer {
+        __ERC721_init(name_, symbol_);
     }
 }
-import "./OwnableMockUpgradeable.sol";
+import "../token/ERC721/extensions/ERC721BurnableUpgradeable.sol";
 
-contract OwnableMockUpgradeableWithInit is OwnableMockUpgradeable {
+contract ERC721BurnableUpgradeableWithInit is ERC721BurnableUpgradeable {
     constructor() payable initializer {
-        __OwnableMock_init();
+        __ERC721Burnable_init();
     }
 }
-import "../access/Ownable2StepUpgradeable.sol";
+import "../token/ERC721/extensions/ERC721ConsecutiveUpgradeable.sol";
 
-contract Ownable2StepUpgradeableWithInit is Ownable2StepUpgradeable {
+contract ERC721ConsecutiveUpgradeableWithInit is ERC721ConsecutiveUpgradeable {
     constructor() payable initializer {
-        __Ownable2Step_init();
+        __ERC721Consecutive_init();
     }
 }
-import "./Ownable2StepMockUpgradeable.sol";
+import "../token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
 
-contract Ownable2StepMockUpgradeableWithInit is Ownable2StepMockUpgradeable {
+contract ERC721EnumerableUpgradeableWithInit is ERC721EnumerableUpgradeable {
     constructor() payable initializer {
-        __Ownable2StepMock_init();
+        __ERC721Enumerable_init();
     }
 }
-import "./SignatureCheckerMockUpgradeable.sol";
+import "../token/ERC721/extensions/ERC721PausableUpgradeable.sol";
 
-contract SignatureCheckerMockUpgradeableWithInit is SignatureCheckerMockUpgradeable {
+contract ERC721PausableUpgradeableWithInit is ERC721PausableUpgradeable {
     constructor() payable initializer {
-        __SignatureCheckerMock_init();
+        __ERC721Pausable_init();
     }
 }
-import "./ECDSAMockUpgradeable.sol";
+import "../token/ERC721/extensions/ERC721RoyaltyUpgradeable.sol";
 
-contract ECDSAMockUpgradeableWithInit is ECDSAMockUpgradeable {
+contract ERC721RoyaltyUpgradeableWithInit is ERC721RoyaltyUpgradeable {
     constructor() payable initializer {
-        __ECDSAMock_init();
+        __ERC721Royalty_init();
     }
 }
-import "./ERC20VotesMockUpgradeable.sol";
+import "../token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
 
-contract ERC20VotesMockUpgradeableWithInit is ERC20VotesMockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC20VotesMock_init(name, symbol);
+contract ERC721URIStorageUpgradeableWithInit is ERC721URIStorageUpgradeable {
+    constructor() payable initializer {
+        __ERC721URIStorage_init();
     }
 }
-import "./ERC20VotesCompMockUpgradeable.sol";
+import "../token/ERC721/extensions/ERC721VotesUpgradeable.sol";
 
-contract ERC20VotesCompMockUpgradeableWithInit is ERC20VotesCompMockUpgradeable {
-    constructor(string memory name, string memory symbol) payable initializer {
-        __ERC20VotesCompMock_init(name, symbol);
+contract ERC721VotesUpgradeableWithInit is ERC721VotesUpgradeable {
+    constructor() payable initializer {
+        __ERC721Votes_init();
     }
 }
-import "../governance/TimelockControllerWith46MigrationUpgradeable.sol";
+import "../token/ERC721/extensions/ERC721WrapperUpgradeable.sol";
 
-contract TimelockControllerWith46MigrationUpgradeableWithInit is TimelockControllerWith46MigrationUpgradeable {
-    constructor(
-        uint256 minDelay,
-        address[] memory proposers,
-        address[] memory executors,
-        address admin
-    ) payable initializer {
-        __TimelockControllerWith46Migration_init(minDelay, proposers, executors, admin);
+contract ERC721WrapperUpgradeableWithInit is ERC721WrapperUpgradeable {
+    constructor(IERC721 underlyingToken) payable initializer {
+        __ERC721Wrapper_init(underlyingToken);
     }
 }
-import "./BadBeaconUpgradeable.sol";
+import "../token/ERC721/utils/ERC721HolderUpgradeable.sol";
 
-contract BadBeaconNoImplUpgradeableWithInit is BadBeaconNoImplUpgradeable {
+contract ERC721HolderUpgradeableWithInit is ERC721HolderUpgradeable {
     constructor() payable initializer {
-        __BadBeaconNoImpl_init();
+        __ERC721Holder_init();
     }
 }
-import "./BadBeaconUpgradeable.sol";
+import "../utils/ContextUpgradeable.sol";
 
-contract BadBeaconNotContractUpgradeableWithInit is BadBeaconNotContractUpgradeable {
+contract ContextUpgradeableWithInit is ContextUpgradeable {
     constructor() payable initializer {
-        __BadBeaconNotContract_init();
+        __Context_init();
     }
 }
-import "./Base64MockUpgradeable.sol";
+import "../utils/cryptography/EIP712Upgradeable.sol";
 
-contract Base64MockUpgradeableWithInit is Base64MockUpgradeable {
-    constructor() payable initializer {
-        __Base64Mock_init();
+contract EIP712UpgradeableWithInit is EIP712Upgradeable {
+    constructor(string memory name, string memory version) payable initializer {
+        __EIP712_init(name, version);
     }
 }
-import "./CallReceiverMockUpgradeable.sol";
+import "../utils/cryptography/signers/MultiSignerERC7913Upgradeable.sol";
 
-contract CallReceiverMockUpgradeableWithInit is CallReceiverMockUpgradeable {
-    constructor() payable initializer {
-        __CallReceiverMock_init();
+contract MultiSignerERC7913UpgradeableWithInit is MultiSignerERC7913Upgradeable {
+    constructor(bytes[] memory signers_, uint64 threshold_) payable initializer {
+        __MultiSignerERC7913_init(signers_, threshold_);
     }
 }
-import "./ClashingImplementationUpgradeable.sol";
+import "../utils/cryptography/signers/MultiSignerERC7913WeightedUpgradeable.sol";
 
-contract ClashingImplementationUpgradeableWithInit is ClashingImplementationUpgradeable {
-    constructor() payable initializer {
-        __ClashingImplementation_init();
+contract MultiSignerERC7913WeightedUpgradeableWithInit is MultiSignerERC7913WeightedUpgradeable {
+    constructor(bytes[] memory signers_, uint64[] memory weights_, uint64 threshold_) payable initializer {
+        __MultiSignerERC7913Weighted_init(signers_, weights_, threshold_);
     }
 }
-import "./DummyImplementationUpgradeable.sol";
+import "../utils/cryptography/signers/SignerECDSAUpgradeable.sol";
 
-contract DummyImplementationUpgradeableWithInit is DummyImplementationUpgradeable {
-    constructor() payable initializer {
-        __DummyImplementation_init();
+contract SignerECDSAUpgradeableWithInit is SignerECDSAUpgradeable {
+    constructor(address signerAddr) payable initializer {
+        __SignerECDSA_init(signerAddr);
     }
 }
-import "./DummyImplementationUpgradeable.sol";
+import "../utils/cryptography/signers/SignerERC7913Upgradeable.sol";
 
-contract DummyImplementationV2UpgradeableWithInit is DummyImplementationV2Upgradeable {
-    constructor() payable initializer {
-        __DummyImplementationV2_init();
+contract SignerERC7913UpgradeableWithInit is SignerERC7913Upgradeable {
+    constructor(bytes memory signer_) payable initializer {
+        __SignerERC7913_init(signer_);
     }
 }
-import "./ERC165/ERC165MaliciousDataUpgradeable.sol";
+import "../utils/cryptography/signers/SignerP256Upgradeable.sol";
 
-contract ERC165MaliciousDataUpgradeableWithInit is ERC165MaliciousDataUpgradeable {
-    constructor() payable initializer {
-        __ERC165MaliciousData_init();
+contract SignerP256UpgradeableWithInit is SignerP256Upgradeable {
+    constructor(bytes32 qx, bytes32 qy) payable initializer {
+        __SignerP256_init(qx, qy);
     }
 }
-import "./ERC165/ERC165MissingDataUpgradeable.sol";
+import "../utils/cryptography/signers/SignerRSAUpgradeable.sol";
 
-contract ERC165MissingDataUpgradeableWithInit is ERC165MissingDataUpgradeable {
-    constructor() payable initializer {
-        __ERC165MissingData_init();
+contract SignerRSAUpgradeableWithInit is SignerRSAUpgradeable {
+    constructor(bytes memory e, bytes memory n) payable initializer {
+        __SignerRSA_init(e, n);
     }
 }
-import "./ERC165/ERC165NotSupportedUpgradeable.sol";
+import "../utils/introspection/ERC165Upgradeable.sol";
 
-contract ERC165NotSupportedUpgradeableWithInit is ERC165NotSupportedUpgradeable {
+contract ERC165UpgradeableWithInit is ERC165Upgradeable {
     constructor() payable initializer {
-        __ERC165NotSupported_init();
+        __ERC165_init();
     }
 }
-import "./EtherReceiverMockUpgradeable.sol";
+import "../utils/MulticallUpgradeable.sol";
 
-contract EtherReceiverMockUpgradeableWithInit is EtherReceiverMockUpgradeable {
+contract MulticallUpgradeableWithInit is MulticallUpgradeable {
     constructor() payable initializer {
-        __EtherReceiverMock_init();
+        __Multicall_init();
     }
 }
-import "./MerkleProofWrapperUpgradeable.sol";
+import "../utils/NoncesUpgradeable.sol";
 
-contract MerkleProofWrapperUpgradeableWithInit is MerkleProofWrapperUpgradeable {
+contract NoncesUpgradeableWithInit is NoncesUpgradeable {
     constructor() payable initializer {
-        __MerkleProofWrapper_init();
+        __Nonces_init();
     }
 }
-import "./SafeMathMockUpgradeable.sol";
+import "../utils/NoncesKeyedUpgradeable.sol";
 
-contract SafeMathMockUpgradeableWithInit is SafeMathMockUpgradeable {
+contract NoncesKeyedUpgradeableWithInit is NoncesKeyedUpgradeable {
     constructor() payable initializer {
-        __SafeMathMock_init();
+        __NoncesKeyed_init();
     }
 }
-import "./SignedMathMockUpgradeable.sol";
+import "../utils/PausableUpgradeable.sol";
 
-contract SignedMathMockUpgradeableWithInit is SignedMathMockUpgradeable {
+contract PausableUpgradeableWithInit is PausableUpgradeable {
     constructor() payable initializer {
-        __SignedMathMock_init();
+        __Pausable_init();
     }
 }
-import "./SignedSafeMathMockUpgradeable.sol";
+import "../utils/ReentrancyGuardUpgradeable.sol";
 
-contract SignedSafeMathMockUpgradeableWithInit is SignedSafeMathMockUpgradeable {
+contract ReentrancyGuardUpgradeableWithInit is ReentrancyGuardUpgradeable {
     constructor() payable initializer {
-        __SignedSafeMathMock_init();
+        __ReentrancyGuard_init();
     }
 }
-import "./compound/CompTimelockUpgradeable.sol";
+import "../utils/ReentrancyGuardTransientUpgradeable.sol";
 
-contract CompTimelockUpgradeableWithInit is CompTimelockUpgradeable {
-    constructor(address admin_, uint256 delay_) payable initializer {
-        __CompTimelock_init(admin_, delay_);
+contract ReentrancyGuardTransientUpgradeableWithInit is ReentrancyGuardTransientUpgradeable {
+    constructor() payable initializer {
+        __ReentrancyGuardTransient_init();
     }
 }