@story-protocol/core-sdk 0.0.1-beta-rc.11 → 0.0.1-beta-rc.13
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/declarations/src/client.d.ts +9 -9
- package/dist/declarations/src/client.d.ts.map +1 -1
- package/dist/declarations/src/clients/storyAPI.d.ts +0 -2
- package/dist/declarations/src/clients/storyAPI.d.ts.map +1 -1
- package/dist/declarations/src/index.d.ts +3 -4
- package/dist/declarations/src/index.d.ts.map +1 -1
- package/dist/declarations/src/resources/dispute.d.ts +419 -78
- package/dist/declarations/src/resources/dispute.d.ts.map +1 -1
- package/dist/declarations/src/resources/ipAccount.d.ts +400 -76
- package/dist/declarations/src/resources/ipAccount.d.ts.map +1 -1
- package/dist/declarations/src/resources/ipAsset.d.ts +26 -756
- package/dist/declarations/src/resources/ipAsset.d.ts.map +1 -1
- package/dist/declarations/src/resources/license.d.ts +3411 -650
- package/dist/declarations/src/resources/license.d.ts.map +1 -1
- package/dist/declarations/src/resources/permission.d.ts +1000 -313
- package/dist/declarations/src/resources/permission.d.ts.map +1 -1
- package/dist/declarations/src/resources/royalty.d.ts +3103 -0
- package/dist/declarations/src/resources/{policy.d.ts.map → royalty.d.ts.map} +1 -1
- package/dist/declarations/src/types/config.d.ts +6 -2
- package/dist/declarations/src/types/config.d.ts.map +1 -1
- package/dist/declarations/src/types/resources/ipAsset.d.ts +5 -21
- package/dist/declarations/src/types/resources/ipAsset.d.ts.map +1 -1
- package/dist/declarations/src/types/resources/license.d.ts +54 -18
- package/dist/declarations/src/types/resources/license.d.ts.map +1 -1
- package/dist/declarations/src/types/resources/royalty.d.ts +41 -0
- package/dist/declarations/src/types/resources/royalty.d.ts.map +1 -1
- package/dist/story-protocol-core-sdk.cjs.dev.js +1580 -1371
- package/dist/story-protocol-core-sdk.cjs.prod.js +1580 -1371
- package/dist/story-protocol-core-sdk.esm.js +1583 -1373
- package/package.json +5 -5
- package/dist/declarations/src/resources/policy.d.ts +0 -2436
- package/dist/declarations/src/types/resources/policy.d.ts +0 -83
- package/dist/declarations/src/types/resources/policy.d.ts.map +0 -1
| @@ -1,5 +1,6 @@ | |
| 1 1 | 
             
            import { PublicClient, WalletClient } from "viem";
         | 
| 2 2 | 
             
            import { SetPermissionsRequest, SetPermissionsResponse } from "../types/resources/permission.js";
         | 
| 3 | 
            +
            import { SupportedChainIds } from "../types/config.js";
         | 
| 3 4 | 
             
            export declare class PermissionClient {
         | 
| 4 5 | 
             
                private readonly wallet;
         | 
| 5 6 | 
             
                private readonly rpcClient;
         | 
| @@ -24,7 +25,38 @@ export declare class PermissionClient { | |
| 24 25 | 
             
                    readonly name: "AccessControlled__ZeroAddress";
         | 
| 25 26 | 
             
                    readonly type: "error";
         | 
| 26 27 | 
             
                } | {
         | 
| 27 | 
            -
                    readonly inputs: readonly [ | 
| 28 | 
            +
                    readonly inputs: readonly [{
         | 
| 29 | 
            +
                        readonly internalType: "address";
         | 
| 30 | 
            +
                        readonly name: "signer";
         | 
| 31 | 
            +
                        readonly type: "address";
         | 
| 32 | 
            +
                    }, {
         | 
| 33 | 
            +
                        readonly internalType: "address";
         | 
| 34 | 
            +
                        readonly name: "to";
         | 
| 35 | 
            +
                        readonly type: "address";
         | 
| 36 | 
            +
                    }];
         | 
| 37 | 
            +
                    readonly name: "AccessController__BothCallerAndRecipientAreNotRegisteredModule";
         | 
| 38 | 
            +
                    readonly type: "error";
         | 
| 39 | 
            +
                } | {
         | 
| 40 | 
            +
                    readonly inputs: readonly [];
         | 
| 41 | 
            +
                    /**
         | 
| 42 | 
            +
                     * Sets the permission for a specific function call
         | 
| 43 | 
            +
                     * Each policy is represented as a mapping from an IP account address to a signer address to a recipient
         | 
| 44 | 
            +
                     * address to a function selector to a permission level. The permission level can be 0 (ABSTAIN), 1 (ALLOW), or
         | 
| 45 | 
            +
                     * 2 (DENY).
         | 
| 46 | 
            +
                     * By default, all policies are set to 0 (ABSTAIN), which means that the permission is not set.
         | 
| 47 | 
            +
                     * The owner of ipAccount by default has all permission.
         | 
| 48 | 
            +
                     * address(0) => wildcard
         | 
| 49 | 
            +
                     * bytes4(0) => wildcard
         | 
| 50 | 
            +
                     * Specific permission overrides wildcard permission.
         | 
| 51 | 
            +
                     * @param request The request object containing necessary data to set permissions.
         | 
| 52 | 
            +
                     *   @param request.ipAsset The address of the IP account that grants the permission for `signer`
         | 
| 53 | 
            +
                     *   @param request.signer The address that can call `to` on behalf of the `ipAccount`
         | 
| 54 | 
            +
                     *   @param request.to The address that can be called by the `signer` (currently only modules can be `to`)
         | 
| 55 | 
            +
                     *   @param request.func Optional. The function selector string of `to` that can be called by the `signer` on behalf of the `ipAccount`. Be default, it allows all functions.
         | 
| 56 | 
            +
                     *   @param request.permission The new permission level
         | 
| 57 | 
            +
                     * @returns A Promise that resolves to an object containing the transaction hash
         | 
| 58 | 
            +
                     * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
         | 
| 59 | 
            +
                     */
         | 
| 28 60 | 
             
                    readonly name: "AccessController__CallerIsNotIPAccount";
         | 
| 29 61 | 
             
                    readonly type: "error";
         | 
| 30 62 | 
             
                } | {
         | 
| @@ -63,61 +95,29 @@ export declare class PermissionClient { | |
| 63 95 | 
             
                    readonly inputs: readonly [];
         | 
| 64 96 | 
             
                    readonly name: "AccessController__PermissionIsNotValid";
         | 
| 65 97 | 
             
                    readonly type: "error";
         | 
| 66 | 
            -
                } | {
         | 
| 67 | 
            -
                    readonly inputs: readonly [{
         | 
| 68 | 
            -
                        readonly internalType: "address";
         | 
| 69 | 
            -
                        readonly name: "to";
         | 
| 70 | 
            -
                        readonly type: "address";
         | 
| 71 | 
            -
                    }];
         | 
| 72 | 
            -
                    readonly name: "AccessController__RecipientIsNotRegisteredModule";
         | 
| 73 | 
            -
                    readonly type: "error";
         | 
| 74 98 | 
             
                } | {
         | 
| 75 99 | 
             
                    readonly inputs: readonly [];
         | 
| 76 100 | 
             
                    readonly name: "AccessController__SignerIsZeroAddress";
         | 
| 77 101 | 
             
                    readonly type: "error";
         | 
| 78 102 | 
             
                } | {
         | 
| 79 103 | 
             
                    readonly inputs: readonly [];
         | 
| 80 | 
            -
                    readonly name: " | 
| 81 | 
            -
                    readonly type: "error";
         | 
| 82 | 
            -
                } | {
         | 
| 83 | 
            -
                    readonly inputs: readonly [];
         | 
| 84 | 
            -
                    readonly name: "AncestorsVaultLAP__ClaimerNotAnAncestor";
         | 
| 85 | 
            -
                    readonly type: "error";
         | 
| 86 | 
            -
                } | {
         | 
| 87 | 
            -
                    readonly inputs: readonly [];
         | 
| 88 | 
            -
                    readonly name: "AncestorsVaultLAP__ERC20BalanceNotZero";
         | 
| 89 | 
            -
                    readonly type: "error";
         | 
| 90 | 
            -
                } | {
         | 
| 91 | 
            -
                    readonly inputs: readonly [];
         | 
| 92 | 
            -
                    readonly name: "AncestorsVaultLAP__ETHBalanceNotZero";
         | 
| 93 | 
            -
                    readonly type: "error";
         | 
| 94 | 
            -
                } | {
         | 
| 95 | 
            -
                    readonly inputs: readonly [];
         | 
| 96 | 
            -
                    readonly name: "AncestorsVaultLAP__InvalidAncestorsHash";
         | 
| 97 | 
            -
                    readonly type: "error";
         | 
| 98 | 
            -
                } | {
         | 
| 99 | 
            -
                    readonly inputs: readonly [];
         | 
| 100 | 
            -
                    readonly name: "AncestorsVaultLAP__InvalidClaimer";
         | 
| 101 | 
            -
                    readonly type: "error";
         | 
| 102 | 
            -
                } | {
         | 
| 103 | 
            -
                    readonly inputs: readonly [];
         | 
| 104 | 
            -
                    readonly name: "AncestorsVaultLAP__TransferFailed";
         | 
| 104 | 
            +
                    readonly name: "ArbitrationPolicySP__NotDisputeModule";
         | 
| 105 105 | 
             
                    readonly type: "error";
         | 
| 106 106 | 
             
                } | {
         | 
| 107 107 | 
             
                    readonly inputs: readonly [];
         | 
| 108 | 
            -
                    readonly name: " | 
| 108 | 
            +
                    readonly name: "ArbitrationPolicySP__ZeroDisputeModule";
         | 
| 109 109 | 
             
                    readonly type: "error";
         | 
| 110 110 | 
             
                } | {
         | 
| 111 111 | 
             
                    readonly inputs: readonly [];
         | 
| 112 | 
            -
                    readonly name: " | 
| 112 | 
            +
                    readonly name: "ArbitrationPolicySP__ZeroPaymentToken";
         | 
| 113 113 | 
             
                    readonly type: "error";
         | 
| 114 114 | 
             
                } | {
         | 
| 115 115 | 
             
                    readonly inputs: readonly [];
         | 
| 116 | 
            -
                    readonly name: " | 
| 116 | 
            +
                    readonly name: "BasePolicyFrameworkManager__CallerNotLicensingModule";
         | 
| 117 117 | 
             
                    readonly type: "error";
         | 
| 118 118 | 
             
                } | {
         | 
| 119 119 | 
             
                    readonly inputs: readonly [];
         | 
| 120 | 
            -
                    readonly name: " | 
| 120 | 
            +
                    readonly name: "CoreMetadataModule__MetadataAlreadyFrozen";
         | 
| 121 121 | 
             
                    readonly type: "error";
         | 
| 122 122 | 
             
                } | {
         | 
| 123 123 | 
             
                    readonly inputs: readonly [];
         | 
| @@ -147,10 +147,6 @@ export declare class PermissionClient { | |
| 147 147 | 
             
                    readonly inputs: readonly [];
         | 
| 148 148 | 
             
                    readonly name: "DisputeModule__NotWhitelistedDisputeTag";
         | 
| 149 149 | 
             
                    readonly type: "error";
         | 
| 150 | 
            -
                } | {
         | 
| 151 | 
            -
                    readonly inputs: readonly [];
         | 
| 152 | 
            -
                    readonly name: "DisputeModule__UnauthorizedAccess";
         | 
| 153 | 
            -
                    readonly type: "error";
         | 
| 154 150 | 
             
                } | {
         | 
| 155 151 | 
             
                    readonly inputs: readonly [];
         | 
| 156 152 | 
             
                    readonly name: "DisputeModule__ZeroArbitrationPolicy";
         | 
| @@ -235,6 +231,18 @@ export declare class PermissionClient { | |
| 235 231 | 
             
                    readonly inputs: readonly [];
         | 
| 236 232 | 
             
                    readonly name: "IPAssetRegistry__InvalidMetadataProvider";
         | 
| 237 233 | 
             
                    readonly type: "error";
         | 
| 234 | 
            +
                } | {
         | 
| 235 | 
            +
                    readonly inputs: readonly [{
         | 
| 236 | 
            +
                        readonly internalType: "address";
         | 
| 237 | 
            +
                        readonly name: "contractAddress";
         | 
| 238 | 
            +
                        readonly type: "address";
         | 
| 239 | 
            +
                    }, {
         | 
| 240 | 
            +
                        readonly internalType: "uint256";
         | 
| 241 | 
            +
                        readonly name: "tokenId";
         | 
| 242 | 
            +
                        readonly type: "uint256";
         | 
| 243 | 
            +
                    }];
         | 
| 244 | 
            +
                    readonly name: "IPAssetRegistry__InvalidToken";
         | 
| 245 | 
            +
                    readonly type: "error";
         | 
| 238 246 | 
             
                } | {
         | 
| 239 247 | 
             
                    readonly inputs: readonly [];
         | 
| 240 248 | 
             
                    readonly name: "IPAssetRegistry__NotYetRegistered";
         | 
| @@ -252,208 +260,564 @@ export declare class PermissionClient { | |
| 252 260 | 
             
                    readonly name: "IPAssetRegistry__Unauthorized";
         | 
| 253 261 | 
             
                    readonly type: "error";
         | 
| 254 262 | 
             
                } | {
         | 
| 255 | 
            -
                    readonly inputs: readonly [ | 
| 256 | 
            -
             | 
| 263 | 
            +
                    readonly inputs: readonly [{
         | 
| 264 | 
            +
                        readonly internalType: "address";
         | 
| 265 | 
            +
                        readonly name: "contractAddress";
         | 
| 266 | 
            +
                        readonly type: "address";
         | 
| 267 | 
            +
                    }];
         | 
| 268 | 
            +
                    readonly name: "IPAssetRegistry__UnsupportedIERC721";
         | 
| 257 269 | 
             
                    readonly type: "error";
         | 
| 258 270 | 
             
                } | {
         | 
| 259 | 
            -
                    readonly inputs: readonly [ | 
| 260 | 
            -
             | 
| 271 | 
            +
                    readonly inputs: readonly [{
         | 
| 272 | 
            +
                        readonly internalType: "address";
         | 
| 273 | 
            +
                        readonly name: "contractAddress";
         | 
| 274 | 
            +
                        readonly type: "address";
         | 
| 275 | 
            +
                    }];
         | 
| 276 | 
            +
                    readonly name: "IPAssetRegistry__UnsupportedIERC721Metadata";
         | 
| 261 277 | 
             
                    readonly type: "error";
         | 
| 262 278 | 
             
                } | {
         | 
| 263 279 | 
             
                    readonly inputs: readonly [];
         | 
| 264 | 
            -
                    readonly name: " | 
| 280 | 
            +
                    readonly name: "IPResolver_InvalidIP";
         | 
| 265 281 | 
             
                    readonly type: "error";
         | 
| 266 282 | 
             
                } | {
         | 
| 267 283 | 
             
                    readonly inputs: readonly [];
         | 
| 268 | 
            -
                    readonly name: " | 
| 284 | 
            +
                    readonly name: "IPResolver_Unauthorized";
         | 
| 269 285 | 
             
                    readonly type: "error";
         | 
| 270 286 | 
             
                } | {
         | 
| 271 287 | 
             
                    readonly inputs: readonly [];
         | 
| 272 | 
            -
                    readonly name: " | 
| 288 | 
            +
                    readonly name: "IpRoyaltyVault__AlreadyClaimed";
         | 
| 273 289 | 
             
                    readonly type: "error";
         | 
| 274 290 | 
             
                } | {
         | 
| 275 291 | 
             
                    readonly inputs: readonly [];
         | 
| 276 | 
            -
                    readonly name: " | 
| 292 | 
            +
                    readonly name: "IpRoyaltyVault__ClaimerNotAnAncestor";
         | 
| 277 293 | 
             
                    readonly type: "error";
         | 
| 278 294 | 
             
                } | {
         | 
| 279 295 | 
             
                    readonly inputs: readonly [];
         | 
| 280 | 
            -
                    readonly name: " | 
| 296 | 
            +
                    readonly name: "IpRoyaltyVault__IpTagged";
         | 
| 281 297 | 
             
                    readonly type: "error";
         | 
| 282 298 | 
             
                } | {
         | 
| 283 299 | 
             
                    readonly inputs: readonly [];
         | 
| 284 | 
            -
                    readonly name: " | 
| 300 | 
            +
                    readonly name: "IpRoyaltyVault__NotRoyaltyPolicyLAP";
         | 
| 285 301 | 
             
                    readonly type: "error";
         | 
| 286 302 | 
             
                } | {
         | 
| 287 303 | 
             
                    readonly inputs: readonly [];
         | 
| 288 | 
            -
                    readonly name: " | 
| 304 | 
            +
                    readonly name: "IpRoyaltyVault__SnapshotIntervalTooShort";
         | 
| 289 305 | 
             
                    readonly type: "error";
         | 
| 290 306 | 
             
                } | {
         | 
| 291 307 | 
             
                    readonly inputs: readonly [];
         | 
| 292 | 
            -
                    readonly name: " | 
| 308 | 
            +
                    readonly name: "IpRoyaltyVault__ZeroDisputeModule";
         | 
| 293 309 | 
             
                    readonly type: "error";
         | 
| 294 310 | 
             
                } | {
         | 
| 295 311 | 
             
                    readonly inputs: readonly [];
         | 
| 296 | 
            -
                    readonly name: " | 
| 312 | 
            +
                    readonly name: "IpRoyaltyVault__ZeroIpId";
         | 
| 297 313 | 
             
                    readonly type: "error";
         | 
| 298 314 | 
             
                } | {
         | 
| 299 315 | 
             
                    readonly inputs: readonly [];
         | 
| 300 | 
            -
                    readonly name: " | 
| 316 | 
            +
                    readonly name: "IpRoyaltyVault__ZeroRoyaltyPolicyLAP";
         | 
| 301 317 | 
             
                    readonly type: "error";
         | 
| 302 318 | 
             
                } | {
         | 
| 303 319 | 
             
                    readonly inputs: readonly [];
         | 
| 304 | 
            -
                    readonly name: " | 
| 320 | 
            +
                    readonly name: "LicenseRegistry__CallerNotLicensingModule";
         | 
| 305 321 | 
             
                    readonly type: "error";
         | 
| 306 322 | 
             
                } | {
         | 
| 307 | 
            -
                    readonly inputs: readonly [ | 
| 308 | 
            -
             | 
| 323 | 
            +
                    readonly inputs: readonly [{
         | 
| 324 | 
            +
                        readonly internalType: "address";
         | 
| 325 | 
            +
                        readonly name: "childIpId";
         | 
| 326 | 
            +
                        readonly type: "address";
         | 
| 327 | 
            +
                    }];
         | 
| 328 | 
            +
                    readonly name: "LicenseRegistry__DerivativeAlreadyRegistered";
         | 
| 309 329 | 
             
                    readonly type: "error";
         | 
| 310 330 | 
             
                } | {
         | 
| 311 | 
            -
                    readonly inputs: readonly [ | 
| 312 | 
            -
             | 
| 331 | 
            +
                    readonly inputs: readonly [{
         | 
| 332 | 
            +
                        readonly internalType: "address";
         | 
| 333 | 
            +
                        readonly name: "childIpId";
         | 
| 334 | 
            +
                        readonly type: "address";
         | 
| 335 | 
            +
                    }];
         | 
| 336 | 
            +
                    readonly name: "LicenseRegistry__DerivativeIpAlreadyHasLicense";
         | 
| 313 337 | 
             
                    readonly type: "error";
         | 
| 314 338 | 
             
                } | {
         | 
| 315 | 
            -
                    readonly inputs: readonly [ | 
| 316 | 
            -
             | 
| 339 | 
            +
                    readonly inputs: readonly [{
         | 
| 340 | 
            +
                        readonly internalType: "address";
         | 
| 341 | 
            +
                        readonly name: "ipId";
         | 
| 342 | 
            +
                        readonly type: "address";
         | 
| 343 | 
            +
                    }];
         | 
| 344 | 
            +
                    readonly name: "LicenseRegistry__DerivativeIsParent";
         | 
| 317 345 | 
             
                    readonly type: "error";
         | 
| 318 346 | 
             
                } | {
         | 
| 319 | 
            -
                    readonly inputs: readonly [ | 
| 320 | 
            -
             | 
| 347 | 
            +
                    readonly inputs: readonly [{
         | 
| 348 | 
            +
                        readonly internalType: "address";
         | 
| 349 | 
            +
                        readonly name: "ipId";
         | 
| 350 | 
            +
                        readonly type: "address";
         | 
| 351 | 
            +
                    }, {
         | 
| 352 | 
            +
                        readonly internalType: "uint256";
         | 
| 353 | 
            +
                        readonly name: "index";
         | 
| 354 | 
            +
                        readonly type: "uint256";
         | 
| 355 | 
            +
                    }, {
         | 
| 356 | 
            +
                        readonly internalType: "uint256";
         | 
| 357 | 
            +
                        readonly name: "length";
         | 
| 358 | 
            +
                        readonly type: "uint256";
         | 
| 359 | 
            +
                    }];
         | 
| 360 | 
            +
                    readonly name: "LicenseRegistry__IndexOutOfBounds";
         | 
| 321 361 | 
             
                    readonly type: "error";
         | 
| 322 362 | 
             
                } | {
         | 
| 323 | 
            -
                    readonly inputs: readonly [ | 
| 324 | 
            -
             | 
| 363 | 
            +
                    readonly inputs: readonly [{
         | 
| 364 | 
            +
                        readonly internalType: "address";
         | 
| 365 | 
            +
                        readonly name: "ipId";
         | 
| 366 | 
            +
                        readonly type: "address";
         | 
| 367 | 
            +
                    }];
         | 
| 368 | 
            +
                    readonly name: "LicenseRegistry__IpExpired";
         | 
| 325 369 | 
             
                    readonly type: "error";
         | 
| 326 370 | 
             
                } | {
         | 
| 327 | 
            -
                    readonly inputs: readonly [ | 
| 328 | 
            -
             | 
| 371 | 
            +
                    readonly inputs: readonly [{
         | 
| 372 | 
            +
                        readonly internalType: "address";
         | 
| 373 | 
            +
                        readonly name: "licenseTemplate";
         | 
| 374 | 
            +
                        readonly type: "address";
         | 
| 375 | 
            +
                    }, {
         | 
| 376 | 
            +
                        readonly internalType: "uint256";
         | 
| 377 | 
            +
                        readonly name: "licenseTermsId";
         | 
| 378 | 
            +
                        readonly type: "uint256";
         | 
| 379 | 
            +
                    }];
         | 
| 380 | 
            +
                    readonly name: "LicenseRegistry__LicenseTermsNotExists";
         | 
| 329 381 | 
             
                    readonly type: "error";
         | 
| 330 382 | 
             
                } | {
         | 
| 331 383 | 
             
                    readonly inputs: readonly [];
         | 
| 332 | 
            -
                    readonly name: " | 
| 384 | 
            +
                    readonly name: "LicenseRegistry__NoParentIp";
         | 
| 333 385 | 
             
                    readonly type: "error";
         | 
| 334 386 | 
             
                } | {
         | 
| 335 | 
            -
                    readonly inputs: readonly [ | 
| 336 | 
            -
             | 
| 387 | 
            +
                    readonly inputs: readonly [{
         | 
| 388 | 
            +
                        readonly internalType: "address";
         | 
| 389 | 
            +
                        readonly name: "licenseTemplate";
         | 
| 390 | 
            +
                        readonly type: "address";
         | 
| 391 | 
            +
                    }];
         | 
| 392 | 
            +
                    readonly name: "LicenseRegistry__NotLicenseTemplate";
         | 
| 337 393 | 
             
                    readonly type: "error";
         | 
| 338 394 | 
             
                } | {
         | 
| 339 395 | 
             
                    readonly inputs: readonly [];
         | 
| 340 | 
            -
                    readonly name: " | 
| 396 | 
            +
                    readonly name: "LicenseRegistry__NotTransferable";
         | 
| 341 397 | 
             
                    readonly type: "error";
         | 
| 342 398 | 
             
                } | {
         | 
| 343 | 
            -
                    readonly inputs: readonly [ | 
| 344 | 
            -
             | 
| 399 | 
            +
                    readonly inputs: readonly [{
         | 
| 400 | 
            +
                        readonly internalType: "address";
         | 
| 401 | 
            +
                        readonly name: "ipId";
         | 
| 402 | 
            +
                        readonly type: "address";
         | 
| 403 | 
            +
                    }];
         | 
| 404 | 
            +
                    readonly name: "LicenseRegistry__ParentIpExpired";
         | 
| 345 405 | 
             
                    readonly type: "error";
         | 
| 346 406 | 
             
                } | {
         | 
| 347 | 
            -
                    readonly inputs: readonly [ | 
| 348 | 
            -
             | 
| 407 | 
            +
                    readonly inputs: readonly [{
         | 
| 408 | 
            +
                        readonly internalType: "address";
         | 
| 409 | 
            +
                        readonly name: "ipId";
         | 
| 410 | 
            +
                        readonly type: "address";
         | 
| 411 | 
            +
                    }, {
         | 
| 412 | 
            +
                        readonly internalType: "uint256";
         | 
| 413 | 
            +
                        readonly name: "licenseTermsId";
         | 
| 414 | 
            +
                        readonly type: "uint256";
         | 
| 415 | 
            +
                    }];
         | 
| 416 | 
            +
                    readonly name: "LicenseRegistry__ParentIpHasNoLicenseTerms";
         | 
| 349 417 | 
             
                    readonly type: "error";
         | 
| 350 418 | 
             
                } | {
         | 
| 351 | 
            -
                    readonly inputs: readonly [ | 
| 352 | 
            -
             | 
| 419 | 
            +
                    readonly inputs: readonly [{
         | 
| 420 | 
            +
                        readonly internalType: "address";
         | 
| 421 | 
            +
                        readonly name: "ipId";
         | 
| 422 | 
            +
                        readonly type: "address";
         | 
| 423 | 
            +
                    }];
         | 
| 424 | 
            +
                    readonly name: "LicenseRegistry__ParentIpTagged";
         | 
| 353 425 | 
             
                    readonly type: "error";
         | 
| 354 426 | 
             
                } | {
         | 
| 355 | 
            -
                    readonly inputs: readonly [ | 
| 356 | 
            -
             | 
| 427 | 
            +
                    readonly inputs: readonly [{
         | 
| 428 | 
            +
                        readonly internalType: "address";
         | 
| 429 | 
            +
                        readonly name: "ipId";
         | 
| 430 | 
            +
                        readonly type: "address";
         | 
| 431 | 
            +
                    }, {
         | 
| 432 | 
            +
                        readonly internalType: "address";
         | 
| 433 | 
            +
                        readonly name: "licenseTemplate";
         | 
| 434 | 
            +
                        readonly type: "address";
         | 
| 435 | 
            +
                    }];
         | 
| 436 | 
            +
                    readonly name: "LicenseRegistry__ParentIpUnmachedLicenseTemplate";
         | 
| 357 437 | 
             
                    readonly type: "error";
         | 
| 358 438 | 
             
                } | {
         | 
| 359 | 
            -
                    readonly inputs: readonly [ | 
| 360 | 
            -
             | 
| 439 | 
            +
                    readonly inputs: readonly [{
         | 
| 440 | 
            +
                        readonly internalType: "address";
         | 
| 441 | 
            +
                        readonly name: "licenseTemplate";
         | 
| 442 | 
            +
                        readonly type: "address";
         | 
| 443 | 
            +
                    }];
         | 
| 444 | 
            +
                    readonly name: "LicenseRegistry__UnregisteredLicenseTemplate";
         | 
| 361 445 | 
             
                    readonly type: "error";
         | 
| 362 446 | 
             
                } | {
         | 
| 363 447 | 
             
                    readonly inputs: readonly [];
         | 
| 364 | 
            -
                    readonly name: " | 
| 448 | 
            +
                    readonly name: "LicenseRegistry__ZeroDisputeModule";
         | 
| 365 449 | 
             
                    readonly type: "error";
         | 
| 366 450 | 
             
                } | {
         | 
| 367 451 | 
             
                    readonly inputs: readonly [];
         | 
| 368 | 
            -
                    readonly name: " | 
| 452 | 
            +
                    readonly name: "LicenseRegistry__ZeroLicensingModule";
         | 
| 369 453 | 
             
                    readonly type: "error";
         | 
| 370 454 | 
             
                } | {
         | 
| 371 | 
            -
                    readonly inputs: readonly [ | 
| 372 | 
            -
             | 
| 455 | 
            +
                    readonly inputs: readonly [{
         | 
| 456 | 
            +
                        readonly internalType: "address";
         | 
| 457 | 
            +
                        readonly name: "licenseTemplate";
         | 
| 458 | 
            +
                        readonly type: "address";
         | 
| 459 | 
            +
                    }, {
         | 
| 460 | 
            +
                        readonly internalType: "address";
         | 
| 461 | 
            +
                        readonly name: "anotherLicenseTemplate";
         | 
| 462 | 
            +
                        readonly type: "address";
         | 
| 463 | 
            +
                    }];
         | 
| 464 | 
            +
                    readonly name: "LicenseToken__AllLicenseTokensMustFromSameLicenseTemplate";
         | 
| 373 465 | 
             
                    readonly type: "error";
         | 
| 374 466 | 
             
                } | {
         | 
| 375 467 | 
             
                    readonly inputs: readonly [];
         | 
| 376 | 
            -
                    readonly name: " | 
| 468 | 
            +
                    readonly name: "LicenseToken__CallerNotLicensingModule";
         | 
| 377 469 | 
             
                    readonly type: "error";
         | 
| 378 470 | 
             
                } | {
         | 
| 379 | 
            -
                    readonly inputs: readonly [ | 
| 380 | 
            -
             | 
| 471 | 
            +
                    readonly inputs: readonly [{
         | 
| 472 | 
            +
                        readonly internalType: "uint256";
         | 
| 473 | 
            +
                        readonly name: "tokenId";
         | 
| 474 | 
            +
                        readonly type: "uint256";
         | 
| 475 | 
            +
                    }, {
         | 
| 476 | 
            +
                        readonly internalType: "uint256";
         | 
| 477 | 
            +
                        readonly name: "expiredAt";
         | 
| 478 | 
            +
                        readonly type: "uint256";
         | 
| 479 | 
            +
                    }, {
         | 
| 480 | 
            +
                        readonly internalType: "uint256";
         | 
| 481 | 
            +
                        readonly name: "currentTimestamp";
         | 
| 482 | 
            +
                        readonly type: "uint256";
         | 
| 483 | 
            +
                    }];
         | 
| 484 | 
            +
                    readonly name: "LicenseToken__LicenseTokenExpired";
         | 
| 381 485 | 
             
                    readonly type: "error";
         | 
| 382 486 | 
             
                } | {
         | 
| 383 | 
            -
                    readonly inputs: readonly [ | 
| 384 | 
            -
             | 
| 487 | 
            +
                    readonly inputs: readonly [{
         | 
| 488 | 
            +
                        readonly internalType: "uint256";
         | 
| 489 | 
            +
                        readonly name: "tokenId";
         | 
| 490 | 
            +
                        readonly type: "uint256";
         | 
| 491 | 
            +
                    }, {
         | 
| 492 | 
            +
                        readonly internalType: "address";
         | 
| 493 | 
            +
                        readonly name: "iPowner";
         | 
| 494 | 
            +
                        readonly type: "address";
         | 
| 495 | 
            +
                    }, {
         | 
| 496 | 
            +
                        readonly internalType: "address";
         | 
| 497 | 
            +
                        readonly name: "tokenOwner";
         | 
| 498 | 
            +
                        readonly type: "address";
         | 
| 499 | 
            +
                    }];
         | 
| 500 | 
            +
                    readonly name: "LicenseToken__NotLicenseTokenOwner";
         | 
| 385 501 | 
             
                    readonly type: "error";
         | 
| 386 502 | 
             
                } | {
         | 
| 387 503 | 
             
                    readonly inputs: readonly [];
         | 
| 388 | 
            -
                    readonly name: " | 
| 504 | 
            +
                    readonly name: "LicenseToken__NotTransferable";
         | 
| 389 505 | 
             
                    readonly type: "error";
         | 
| 390 506 | 
             
                } | {
         | 
| 391 | 
            -
                    readonly inputs: readonly [ | 
| 392 | 
            -
             | 
| 507 | 
            +
                    readonly inputs: readonly [{
         | 
| 508 | 
            +
                        readonly internalType: "uint256";
         | 
| 509 | 
            +
                        readonly name: "tokenId";
         | 
| 510 | 
            +
                        readonly type: "uint256";
         | 
| 511 | 
            +
                    }];
         | 
| 512 | 
            +
                    readonly name: "LicenseToken__RevokedLicense";
         | 
| 393 513 | 
             
                    readonly type: "error";
         | 
| 394 514 | 
             
                } | {
         | 
| 395 515 | 
             
                    readonly inputs: readonly [];
         | 
| 396 | 
            -
                    readonly name: " | 
| 516 | 
            +
                    readonly name: "LicenseToken__ZeroDisputeModule";
         | 
| 397 517 | 
             
                    readonly type: "error";
         | 
| 398 518 | 
             
                } | {
         | 
| 399 519 | 
             
                    readonly inputs: readonly [];
         | 
| 400 | 
            -
                    readonly name: " | 
| 520 | 
            +
                    readonly name: "LicenseToken__ZeroLicensingModule";
         | 
| 401 521 | 
             
                    readonly type: "error";
         | 
| 402 522 | 
             
                } | {
         | 
| 403 523 | 
             
                    readonly inputs: readonly [];
         | 
| 404 | 
            -
                    readonly name: " | 
| 524 | 
            +
                    readonly name: "LicensingModule__CallerNotLicenseRegistry";
         | 
| 405 525 | 
             
                    readonly type: "error";
         | 
| 406 526 | 
             
                } | {
         | 
| 407 | 
            -
                    readonly inputs: readonly [ | 
| 408 | 
            -
             | 
| 527 | 
            +
                    readonly inputs: readonly [{
         | 
| 528 | 
            +
                        readonly internalType: "address";
         | 
| 529 | 
            +
                        readonly name: "caller";
         | 
| 530 | 
            +
                        readonly type: "address";
         | 
| 531 | 
            +
                    }, {
         | 
| 532 | 
            +
                        readonly internalType: "address";
         | 
| 533 | 
            +
                        readonly name: "licensorIpId";
         | 
| 534 | 
            +
                        readonly type: "address";
         | 
| 535 | 
            +
                    }, {
         | 
| 536 | 
            +
                        readonly internalType: "address";
         | 
| 537 | 
            +
                        readonly name: "licenseTemplate";
         | 
| 538 | 
            +
                        readonly type: "address";
         | 
| 539 | 
            +
                    }, {
         | 
| 540 | 
            +
                        readonly internalType: "uint256";
         | 
| 541 | 
            +
                        readonly name: "licenseTermsId";
         | 
| 542 | 
            +
                        readonly type: "uint256";
         | 
| 543 | 
            +
                    }];
         | 
| 544 | 
            +
                    readonly name: "LicensingModule__CallerNotLicensorAndIpHasNotAttachedLicenseTerms";
         | 
| 409 545 | 
             
                    readonly type: "error";
         | 
| 410 546 | 
             
                } | {
         | 
| 411 547 | 
             
                    readonly inputs: readonly [];
         | 
| 412 | 
            -
                    readonly name: " | 
| 548 | 
            +
                    readonly name: "LicensingModule__CallerNotLicensorAndPolicyNotSet";
         | 
| 413 549 | 
             
                    readonly type: "error";
         | 
| 414 550 | 
             
                } | {
         | 
| 415 551 | 
             
                    readonly inputs: readonly [];
         | 
| 416 | 
            -
                    readonly name: " | 
| 552 | 
            +
                    readonly name: "LicensingModule__CommercialTermInNonCommercialPolicy";
         | 
| 417 553 | 
             
                    readonly type: "error";
         | 
| 418 554 | 
             
                } | {
         | 
| 419 | 
            -
                    readonly inputs: readonly [ | 
| 420 | 
            -
             | 
| 555 | 
            +
                    readonly inputs: readonly [{
         | 
| 556 | 
            +
                        readonly internalType: "address";
         | 
| 557 | 
            +
                        readonly name: "ipId";
         | 
| 558 | 
            +
                        readonly type: "address";
         | 
| 559 | 
            +
                    }];
         | 
| 560 | 
            +
                    readonly name: "LicensingModule__DerivativeAlreadyHasLicenseTerms";
         | 
| 421 561 | 
             
                    readonly type: "error";
         | 
| 422 562 | 
             
                } | {
         | 
| 423 563 | 
             
                    readonly inputs: readonly [];
         | 
| 424 | 
            -
                    readonly name: " | 
| 564 | 
            +
                    readonly name: "LicensingModule__DerivativeAlreadyRegistered";
         | 
| 425 565 | 
             
                    readonly type: "error";
         | 
| 426 566 | 
             
                } | {
         | 
| 427 567 | 
             
                    readonly inputs: readonly [];
         | 
| 428 | 
            -
                    readonly name: " | 
| 568 | 
            +
                    readonly name: "LicensingModule__DerivativeIsParent";
         | 
| 429 569 | 
             
                    readonly type: "error";
         | 
| 430 570 | 
             
                } | {
         | 
| 431 571 | 
             
                    readonly inputs: readonly [];
         | 
| 432 | 
            -
                    readonly name: " | 
| 572 | 
            +
                    readonly name: "LicensingModule__DerivativeRevShareSumExceedsMaxRNFTSupply";
         | 
| 433 573 | 
             
                    readonly type: "error";
         | 
| 434 574 | 
             
                } | {
         | 
| 435 575 | 
             
                    readonly inputs: readonly [];
         | 
| 436 | 
            -
                    readonly name: " | 
| 576 | 
            +
                    readonly name: "LicensingModule__DerivativesCannotAddLicenseTerms";
         | 
| 437 577 | 
             
                    readonly type: "error";
         | 
| 438 578 | 
             
                } | {
         | 
| 439 579 | 
             
                    readonly inputs: readonly [];
         | 
| 440 | 
            -
                    readonly name: " | 
| 580 | 
            +
                    readonly name: "LicensingModule__DerivativesCannotAddPolicy";
         | 
| 441 581 | 
             
                    readonly type: "error";
         | 
| 442 582 | 
             
                } | {
         | 
| 443 583 | 
             
                    readonly inputs: readonly [];
         | 
| 444 | 
            -
                    readonly name: " | 
| 584 | 
            +
                    readonly name: "LicensingModule__DisputedIpId";
         | 
| 445 585 | 
             
                    readonly type: "error";
         | 
| 446 586 | 
             
                } | {
         | 
| 447 587 | 
             
                    readonly inputs: readonly [];
         | 
| 448 | 
            -
                    readonly name: " | 
| 588 | 
            +
                    readonly name: "LicensingModule__EmptyLicenseUrl";
         | 
| 449 589 | 
             
                    readonly type: "error";
         | 
| 450 590 | 
             
                } | {
         | 
| 451 591 | 
             
                    readonly inputs: readonly [];
         | 
| 452 | 
            -
                    readonly name: " | 
| 592 | 
            +
                    readonly name: "LicensingModule__EmptyParamName";
         | 
| 453 593 | 
             
                    readonly type: "error";
         | 
| 454 594 | 
             
                } | {
         | 
| 455 595 | 
             
                    readonly inputs: readonly [];
         | 
| 456 | 
            -
                    readonly name: " | 
| 596 | 
            +
                    readonly name: "LicensingModule__FrameworkNotFound";
         | 
| 597 | 
            +
                    readonly type: "error";
         | 
| 598 | 
            +
                } | {
         | 
| 599 | 
            +
                    readonly inputs: readonly [];
         | 
| 600 | 
            +
                    readonly name: "LicensingModule__IncompatibleLicensorRoyaltyDerivativeRevShare";
         | 
| 601 | 
            +
                    readonly type: "error";
         | 
| 602 | 
            +
                } | {
         | 
| 603 | 
            +
                    readonly inputs: readonly [{
         | 
| 604 | 
            +
                        readonly internalType: "address";
         | 
| 605 | 
            +
                        readonly name: "royaltyPolicy";
         | 
| 606 | 
            +
                        readonly type: "address";
         | 
| 607 | 
            +
                    }, {
         | 
| 608 | 
            +
                        readonly internalType: "address";
         | 
| 609 | 
            +
                        readonly name: "anotherRoyaltyPolicy";
         | 
| 610 | 
            +
                        readonly type: "address";
         | 
| 611 | 
            +
                    }];
         | 
| 612 | 
            +
                    readonly name: "LicensingModule__IncompatibleRoyaltyPolicy";
         | 
| 613 | 
            +
                    readonly type: "error";
         | 
| 614 | 
            +
                } | {
         | 
| 615 | 
            +
                    readonly inputs: readonly [];
         | 
| 616 | 
            +
                    readonly name: "LicensingModule__IncompatibleRoyaltyPolicyAddress";
         | 
| 617 | 
            +
                    readonly type: "error";
         | 
| 618 | 
            +
                } | {
         | 
| 619 | 
            +
                    readonly inputs: readonly [];
         | 
| 620 | 
            +
                    readonly name: "LicensingModule__IncompatibleRoyaltyPolicyDerivativeRevShare";
         | 
| 621 | 
            +
                    readonly type: "error";
         | 
| 622 | 
            +
                } | {
         | 
| 623 | 
            +
                    readonly inputs: readonly [];
         | 
| 624 | 
            +
                    readonly name: "LicensingModule__InvalidLicensor";
         | 
| 625 | 
            +
                    readonly type: "error";
         | 
| 626 | 
            +
                } | {
         | 
| 627 | 
            +
                    readonly inputs: readonly [];
         | 
| 628 | 
            +
                    readonly name: "LicensingModule__InvalidPolicyFramework";
         | 
| 629 | 
            +
                    readonly type: "error";
         | 
| 630 | 
            +
                } | {
         | 
| 631 | 
            +
                    readonly inputs: readonly [];
         | 
| 632 | 
            +
                    readonly name: "LicensingModule__IpAlreadyLinked";
         | 
| 633 | 
            +
                    readonly type: "error";
         | 
| 634 | 
            +
                } | {
         | 
| 635 | 
            +
                    readonly inputs: readonly [{
         | 
| 636 | 
            +
                        readonly internalType: "address";
         | 
| 637 | 
            +
                        readonly name: "childIpId";
         | 
| 638 | 
            +
                        readonly type: "address";
         | 
| 639 | 
            +
                    }];
         | 
| 640 | 
            +
                    readonly name: "LicensingModule__LicenseNotCompatibleForDerivative";
         | 
| 641 | 
            +
                    readonly type: "error";
         | 
| 642 | 
            +
                } | {
         | 
| 643 | 
            +
                    readonly inputs: readonly [{
         | 
| 644 | 
            +
                        readonly internalType: "uint256";
         | 
| 645 | 
            +
                        readonly name: "ipLength";
         | 
| 646 | 
            +
                        readonly type: "uint256";
         | 
| 647 | 
            +
                    }, {
         | 
| 648 | 
            +
                        readonly internalType: "uint256";
         | 
| 649 | 
            +
                        readonly name: "licenseTermsLength";
         | 
| 650 | 
            +
                        readonly type: "uint256";
         | 
| 651 | 
            +
                    }];
         | 
| 652 | 
            +
                    readonly name: "LicensingModule__LicenseTermsLengthMismatch";
         | 
| 653 | 
            +
                    readonly type: "error";
         | 
| 654 | 
            +
                } | {
         | 
| 655 | 
            +
                    readonly inputs: readonly [{
         | 
| 656 | 
            +
                        readonly internalType: "address";
         | 
| 657 | 
            +
                        readonly name: "licenseTemplate";
         | 
| 658 | 
            +
                        readonly type: "address";
         | 
| 659 | 
            +
                    }, {
         | 
| 660 | 
            +
                        readonly internalType: "uint256";
         | 
| 661 | 
            +
                        readonly name: "licenseTermsId";
         | 
| 662 | 
            +
                        readonly type: "uint256";
         | 
| 663 | 
            +
                    }];
         | 
| 664 | 
            +
                    readonly name: "LicensingModule__LicenseTermsNotFound";
         | 
| 665 | 
            +
                    readonly type: "error";
         | 
| 666 | 
            +
                } | {
         | 
| 667 | 
            +
                    readonly inputs: readonly [{
         | 
| 668 | 
            +
                        readonly internalType: "address";
         | 
| 669 | 
            +
                        readonly name: "childIpId";
         | 
| 670 | 
            +
                        readonly type: "address";
         | 
| 671 | 
            +
                    }, {
         | 
| 672 | 
            +
                        readonly internalType: "uint256[]";
         | 
| 673 | 
            +
                        readonly name: "licenseTokenIds";
         | 
| 674 | 
            +
                        readonly type: "uint256[]";
         | 
| 675 | 
            +
                    }];
         | 
| 676 | 
            +
                    readonly name: "LicensingModule__LicenseTokenNotCompatibleForDerivative";
         | 
| 677 | 
            +
                    readonly type: "error";
         | 
| 678 | 
            +
                } | {
         | 
| 679 | 
            +
                    readonly inputs: readonly [];
         | 
| 680 | 
            +
                    readonly name: "LicensingModule__LicensorDoesntHaveThisPolicy";
         | 
| 681 | 
            +
                    readonly type: "error";
         | 
| 682 | 
            +
                } | {
         | 
| 683 | 
            +
                    readonly inputs: readonly [];
         | 
| 684 | 
            +
                    readonly name: "LicensingModule__LicensorNotRegistered";
         | 
| 685 | 
            +
                    readonly type: "error";
         | 
| 686 | 
            +
                } | {
         | 
| 687 | 
            +
                    readonly inputs: readonly [];
         | 
| 688 | 
            +
                    readonly name: "LicensingModule__LinkParentParamFailed";
         | 
| 689 | 
            +
                    readonly type: "error";
         | 
| 690 | 
            +
                } | {
         | 
| 691 | 
            +
                    readonly inputs: readonly [];
         | 
| 692 | 
            +
                    readonly name: "LicensingModule__LinkingRevokedLicense";
         | 
| 693 | 
            +
                    readonly type: "error";
         | 
| 694 | 
            +
                } | {
         | 
| 695 | 
            +
                    readonly inputs: readonly [];
         | 
| 696 | 
            +
                    readonly name: "LicensingModule__MintAmountZero";
         | 
| 697 | 
            +
                    readonly type: "error";
         | 
| 698 | 
            +
                } | {
         | 
| 699 | 
            +
                    readonly inputs: readonly [];
         | 
| 700 | 
            +
                    readonly name: "LicensingModule__MintLicenseParamFailed";
         | 
| 701 | 
            +
                    readonly type: "error";
         | 
| 702 | 
            +
                } | {
         | 
| 703 | 
            +
                    readonly inputs: readonly [];
         | 
| 704 | 
            +
                    readonly name: "LicensingModule__MintingFeeTokenNotWhitelisted";
         | 
| 705 | 
            +
                    readonly type: "error";
         | 
| 706 | 
            +
                } | {
         | 
| 707 | 
            +
                    readonly inputs: readonly [];
         | 
| 708 | 
            +
                    readonly name: "LicensingModule__MismatchBetweenRoyaltyPolicy";
         | 
| 709 | 
            +
                    readonly type: "error";
         | 
| 710 | 
            +
                } | {
         | 
| 711 | 
            +
                    readonly inputs: readonly [];
         | 
| 712 | 
            +
                    readonly name: "LicensingModule__NoLicenseToken";
         | 
| 713 | 
            +
                    readonly type: "error";
         | 
| 714 | 
            +
                } | {
         | 
| 715 | 
            +
                    readonly inputs: readonly [];
         | 
| 716 | 
            +
                    readonly name: "LicensingModule__NoParentIp";
         | 
| 717 | 
            +
                    readonly type: "error";
         | 
| 718 | 
            +
                } | {
         | 
| 719 | 
            +
                    readonly inputs: readonly [];
         | 
| 720 | 
            +
                    readonly name: "LicensingModule__NotLicensee";
         | 
| 721 | 
            +
                    readonly type: "error";
         | 
| 722 | 
            +
                } | {
         | 
| 723 | 
            +
                    readonly inputs: readonly [];
         | 
| 724 | 
            +
                    readonly name: "LicensingModule__ParamVerifierAlreadySet";
         | 
| 725 | 
            +
                    readonly type: "error";
         | 
| 726 | 
            +
                } | {
         | 
| 727 | 
            +
                    readonly inputs: readonly [];
         | 
| 728 | 
            +
                    readonly name: "LicensingModule__ParamVerifierLengthMismatch";
         | 
| 729 | 
            +
                    readonly type: "error";
         | 
| 730 | 
            +
                } | {
         | 
| 731 | 
            +
                    readonly inputs: readonly [];
         | 
| 732 | 
            +
                    readonly name: "LicensingModule__ParentIdEqualThanChild";
         | 
| 733 | 
            +
                    readonly type: "error";
         | 
| 734 | 
            +
                } | {
         | 
| 735 | 
            +
                    readonly inputs: readonly [{
         | 
| 736 | 
            +
                        readonly internalType: "address";
         | 
| 737 | 
            +
                        readonly name: "ipId";
         | 
| 738 | 
            +
                        readonly type: "address";
         | 
| 739 | 
            +
                    }];
         | 
| 740 | 
            +
                    readonly name: "LicensingModule__ParentIpHasNoLicenseTerms";
         | 
| 741 | 
            +
                    readonly type: "error";
         | 
| 742 | 
            +
                } | {
         | 
| 743 | 
            +
                    readonly inputs: readonly [];
         | 
| 744 | 
            +
                    readonly name: "LicensingModule__PolicyAlreadySetForIpId";
         | 
| 745 | 
            +
                    readonly type: "error";
         | 
| 746 | 
            +
                } | {
         | 
| 747 | 
            +
                    readonly inputs: readonly [];
         | 
| 748 | 
            +
                    readonly name: "LicensingModule__PolicyNotFound";
         | 
| 749 | 
            +
                    readonly type: "error";
         | 
| 750 | 
            +
                } | {
         | 
| 751 | 
            +
                    readonly inputs: readonly [{
         | 
| 752 | 
            +
                        readonly internalType: "address";
         | 
| 753 | 
            +
                        readonly name: "receiver";
         | 
| 754 | 
            +
                        readonly type: "address";
         | 
| 755 | 
            +
                    }];
         | 
| 756 | 
            +
                    readonly name: "LicensingModule__ReceiverCheckFailed";
         | 
| 757 | 
            +
                    readonly type: "error";
         | 
| 758 | 
            +
                } | {
         | 
| 759 | 
            +
                    readonly inputs: readonly [];
         | 
| 760 | 
            +
                    readonly name: "LicensingModule__ReceiverZeroAddress";
         | 
| 761 | 
            +
                    readonly type: "error";
         | 
| 762 | 
            +
                } | {
         | 
| 763 | 
            +
                    readonly inputs: readonly [];
         | 
| 764 | 
            +
                    readonly name: "LicensingModule__RegisterPolicyFrameworkMismatch";
         | 
| 765 | 
            +
                    readonly type: "error";
         | 
| 766 | 
            +
                } | {
         | 
| 767 | 
            +
                    readonly inputs: readonly [];
         | 
| 768 | 
            +
                    readonly name: "LicensingModule__RoyaltyPolicyNotWhitelisted";
         | 
| 769 | 
            +
                    readonly type: "error";
         | 
| 770 | 
            +
                } | {
         | 
| 771 | 
            +
                    readonly inputs: readonly [];
         | 
| 772 | 
            +
                    readonly name: "LicensingModule__TransferParamFailed";
         | 
| 773 | 
            +
                    readonly type: "error";
         | 
| 774 | 
            +
                } | {
         | 
| 775 | 
            +
                    readonly inputs: readonly [];
         | 
| 776 | 
            +
                    readonly name: "LicensingModule__UnauthorizedAccess";
         | 
| 777 | 
            +
                    readonly type: "error";
         | 
| 778 | 
            +
                } | {
         | 
| 779 | 
            +
                    readonly inputs: readonly [];
         | 
| 780 | 
            +
                    readonly name: "LicensingModule__UnregisteredFrameworkAddingPolicy";
         | 
| 781 | 
            +
                    readonly type: "error";
         | 
| 782 | 
            +
                } | {
         | 
| 783 | 
            +
                    readonly inputs: readonly [];
         | 
| 784 | 
            +
                    readonly name: "LicensorApprovalChecker__Unauthorized";
         | 
| 785 | 
            +
                    readonly type: "error";
         | 
| 786 | 
            +
                } | {
         | 
| 787 | 
            +
                    readonly inputs: readonly [];
         | 
| 788 | 
            +
                    readonly name: "MetadataProvider__HashInvalid";
         | 
| 789 | 
            +
                    readonly type: "error";
         | 
| 790 | 
            +
                } | {
         | 
| 791 | 
            +
                    readonly inputs: readonly [];
         | 
| 792 | 
            +
                    readonly name: "MetadataProvider__IPAssetOwnerInvalid";
         | 
| 793 | 
            +
                    readonly type: "error";
         | 
| 794 | 
            +
                } | {
         | 
| 795 | 
            +
                    readonly inputs: readonly [];
         | 
| 796 | 
            +
                    readonly name: "MetadataProvider__MetadataNotCompatible";
         | 
| 797 | 
            +
                    readonly type: "error";
         | 
| 798 | 
            +
                } | {
         | 
| 799 | 
            +
                    readonly inputs: readonly [];
         | 
| 800 | 
            +
                    readonly name: "MetadataProvider__NameInvalid";
         | 
| 801 | 
            +
                    readonly type: "error";
         | 
| 802 | 
            +
                } | {
         | 
| 803 | 
            +
                    readonly inputs: readonly [];
         | 
| 804 | 
            +
                    readonly name: "MetadataProvider__RegistrantInvalid";
         | 
| 805 | 
            +
                    readonly type: "error";
         | 
| 806 | 
            +
                } | {
         | 
| 807 | 
            +
                    readonly inputs: readonly [];
         | 
| 808 | 
            +
                    readonly name: "MetadataProvider__RegistrationDateInvalid";
         | 
| 809 | 
            +
                    readonly type: "error";
         | 
| 810 | 
            +
                } | {
         | 
| 811 | 
            +
                    readonly inputs: readonly [];
         | 
| 812 | 
            +
                    readonly name: "MetadataProvider__URIInvalid";
         | 
| 813 | 
            +
                    readonly type: "error";
         | 
| 814 | 
            +
                } | {
         | 
| 815 | 
            +
                    readonly inputs: readonly [];
         | 
| 816 | 
            +
                    readonly name: "MetadataProvider__Unauthorized";
         | 
| 817 | 
            +
                    readonly type: "error";
         | 
| 818 | 
            +
                } | {
         | 
| 819 | 
            +
                    readonly inputs: readonly [];
         | 
| 820 | 
            +
                    readonly name: "MetadataProvider__UpgradeProviderInvalid";
         | 
| 457 821 | 
             
                    readonly type: "error";
         | 
| 458 822 | 
             
                } | {
         | 
| 459 823 | 
             
                    readonly inputs: readonly [];
         | 
| @@ -525,15 +889,15 @@ export declare class PermissionClient { | |
| 525 889 | 
             
                    readonly type: "error";
         | 
| 526 890 | 
             
                } | {
         | 
| 527 891 | 
             
                    readonly inputs: readonly [];
         | 
| 528 | 
            -
                    readonly name: " | 
| 892 | 
            +
                    readonly name: "RoyaltyModule__CanOnlyMintSelectedPolicy";
         | 
| 529 893 | 
             
                    readonly type: "error";
         | 
| 530 894 | 
             
                } | {
         | 
| 531 895 | 
             
                    readonly inputs: readonly [];
         | 
| 532 | 
            -
                    readonly name: " | 
| 896 | 
            +
                    readonly name: "RoyaltyModule__IncompatibleRoyaltyPolicy";
         | 
| 533 897 | 
             
                    readonly type: "error";
         | 
| 534 898 | 
             
                } | {
         | 
| 535 899 | 
             
                    readonly inputs: readonly [];
         | 
| 536 | 
            -
                    readonly name: " | 
| 900 | 
            +
                    readonly name: "RoyaltyModule__IpIsTagged";
         | 
| 537 901 | 
             
                    readonly type: "error";
         | 
| 538 902 | 
             
                } | {
         | 
| 539 903 | 
             
                    readonly inputs: readonly [];
         | 
| @@ -549,15 +913,15 @@ export declare class PermissionClient { | |
| 549 913 | 
             
                    readonly type: "error";
         | 
| 550 914 | 
             
                } | {
         | 
| 551 915 | 
             
                    readonly inputs: readonly [];
         | 
| 552 | 
            -
                    readonly name: " | 
| 916 | 
            +
                    readonly name: "RoyaltyModule__NotWhitelistedRoyaltyPolicy";
         | 
| 553 917 | 
             
                    readonly type: "error";
         | 
| 554 918 | 
             
                } | {
         | 
| 555 919 | 
             
                    readonly inputs: readonly [];
         | 
| 556 | 
            -
                    readonly name: " | 
| 920 | 
            +
                    readonly name: "RoyaltyModule__NotWhitelistedRoyaltyToken";
         | 
| 557 921 | 
             
                    readonly type: "error";
         | 
| 558 922 | 
             
                } | {
         | 
| 559 923 | 
             
                    readonly inputs: readonly [];
         | 
| 560 | 
            -
                    readonly name: " | 
| 924 | 
            +
                    readonly name: "RoyaltyModule__ZeroDisputeModule";
         | 
| 561 925 | 
             
                    readonly type: "error";
         | 
| 562 926 | 
             
                } | {
         | 
| 563 927 | 
             
                    readonly inputs: readonly [];
         | 
| @@ -587,30 +951,10 @@ export declare class PermissionClient { | |
| 587 951 | 
             
                    readonly inputs: readonly [];
         | 
| 588 952 | 
             
                    readonly name: "RoyaltyPolicyLAP__ImplementationAlreadySet";
         | 
| 589 953 | 
             
                    readonly type: "error";
         | 
| 590 | 
            -
                } | {
         | 
| 591 | 
            -
                    readonly inputs: readonly [];
         | 
| 592 | 
            -
                    readonly name: "RoyaltyPolicyLAP__InvalidAncestors";
         | 
| 593 | 
            -
                    readonly type: "error";
         | 
| 594 | 
            -
                } | {
         | 
| 595 | 
            -
                    readonly inputs: readonly [];
         | 
| 596 | 
            -
                    readonly name: "RoyaltyPolicyLAP__InvalidAncestorsHash";
         | 
| 597 | 
            -
                    readonly type: "error";
         | 
| 598 | 
            -
                } | {
         | 
| 599 | 
            -
                    readonly inputs: readonly [];
         | 
| 600 | 
            -
                    readonly name: "RoyaltyPolicyLAP__InvalidAncestorsLength";
         | 
| 601 | 
            -
                    readonly type: "error";
         | 
| 602 | 
            -
                } | {
         | 
| 603 | 
            -
                    readonly inputs: readonly [];
         | 
| 604 | 
            -
                    readonly name: "RoyaltyPolicyLAP__InvalidAncestorsRoyalty";
         | 
| 605 | 
            -
                    readonly type: "error";
         | 
| 606 954 | 
             
                } | {
         | 
| 607 955 | 
             
                    readonly inputs: readonly [];
         | 
| 608 956 | 
             
                    readonly name: "RoyaltyPolicyLAP__InvalidParentRoyaltiesLength";
         | 
| 609 957 | 
             
                    readonly type: "error";
         | 
| 610 | 
            -
                } | {
         | 
| 611 | 
            -
                    readonly inputs: readonly [];
         | 
| 612 | 
            -
                    readonly name: "RoyaltyPolicyLAP__InvalidRoyaltyAmountLength";
         | 
| 613 | 
            -
                    readonly type: "error";
         | 
| 614 958 | 
             
                } | {
         | 
| 615 959 | 
             
                    readonly inputs: readonly [];
         | 
| 616 960 | 
             
                    readonly name: "RoyaltyPolicyLAP__LastPositionNotAbleToMintLicense";
         | 
| @@ -625,15 +969,15 @@ export declare class PermissionClient { | |
| 625 969 | 
             
                    readonly type: "error";
         | 
| 626 970 | 
             
                } | {
         | 
| 627 971 | 
             
                    readonly inputs: readonly [];
         | 
| 628 | 
            -
                    readonly name: " | 
| 972 | 
            +
                    readonly name: "RoyaltyPolicyLAP__UnlinkableToParents";
         | 
| 629 973 | 
             
                    readonly type: "error";
         | 
| 630 974 | 
             
                } | {
         | 
| 631 975 | 
             
                    readonly inputs: readonly [];
         | 
| 632 | 
            -
                    readonly name: " | 
| 976 | 
            +
                    readonly name: "RoyaltyPolicyLAP__ZeroAncestorsVaultImpl";
         | 
| 633 977 | 
             
                    readonly type: "error";
         | 
| 634 978 | 
             
                } | {
         | 
| 635 979 | 
             
                    readonly inputs: readonly [];
         | 
| 636 | 
            -
                    readonly name: " | 
| 980 | 
            +
                    readonly name: "RoyaltyPolicyLAP__ZeroIpRoyaltyVaultBeacon";
         | 
| 637 981 | 
             
                    readonly type: "error";
         | 
| 638 982 | 
             
                } | {
         | 
| 639 983 | 
             
                    readonly inputs: readonly [];
         | 
| @@ -710,6 +1054,67 @@ export declare class PermissionClient { | |
| 710 1054 | 
             
                })[];
         | 
| 711 1055 | 
             
                accessControllerConfig: {
         | 
| 712 1056 | 
             
                    abi: ({
         | 
| 1057 | 
            +
                        readonly anonymous: false;
         | 
| 1058 | 
            +
                        readonly inputs: readonly [{
         | 
| 1059 | 
            +
                            readonly indexed: false;
         | 
| 1060 | 
            +
                            readonly internalType: "address";
         | 
| 1061 | 
            +
                            readonly name: "ipAccountOwner";
         | 
| 1062 | 
            +
                            readonly type: "address";
         | 
| 1063 | 
            +
                        }, {
         | 
| 1064 | 
            +
                            readonly indexed: true;
         | 
| 1065 | 
            +
                            readonly internalType: "address";
         | 
| 1066 | 
            +
                            readonly name: "ipAccount";
         | 
| 1067 | 
            +
                            readonly type: "address";
         | 
| 1068 | 
            +
                        }, {
         | 
| 1069 | 
            +
                            readonly indexed: true;
         | 
| 1070 | 
            +
                            readonly internalType: "address";
         | 
| 1071 | 
            +
                            readonly name: "signer";
         | 
| 1072 | 
            +
                            readonly type: "address";
         | 
| 1073 | 
            +
                        }, {
         | 
| 1074 | 
            +
                            readonly indexed: true;
         | 
| 1075 | 
            +
                            readonly internalType: "address";
         | 
| 1076 | 
            +
                            readonly name: "to";
         | 
| 1077 | 
            +
                            readonly type: "address";
         | 
| 1078 | 
            +
                        }, {
         | 
| 1079 | 
            +
                            readonly indexed: false;
         | 
| 1080 | 
            +
                            readonly internalType: "bytes4";
         | 
| 1081 | 
            +
                            readonly name: "func";
         | 
| 1082 | 
            +
                            readonly type: "bytes4";
         | 
| 1083 | 
            +
                        }, {
         | 
| 1084 | 
            +
                            readonly indexed: false;
         | 
| 1085 | 
            +
                            readonly internalType: "uint8";
         | 
| 1086 | 
            +
                            readonly name: "permission";
         | 
| 1087 | 
            +
                            readonly type: "uint8";
         | 
| 1088 | 
            +
                        }];
         | 
| 1089 | 
            +
                        readonly name: "PermissionSet";
         | 
| 1090 | 
            +
                        readonly type: "event";
         | 
| 1091 | 
            +
                    } | {
         | 
| 1092 | 
            +
                        readonly inputs: readonly [{
         | 
| 1093 | 
            +
                            readonly internalType: "address";
         | 
| 1094 | 
            +
                            readonly name: "ipAccount";
         | 
| 1095 | 
            +
                            readonly type: "address";
         | 
| 1096 | 
            +
                        }, {
         | 
| 1097 | 
            +
                            readonly internalType: "address";
         | 
| 1098 | 
            +
                            readonly name: "signer";
         | 
| 1099 | 
            +
                            readonly type: "address";
         | 
| 1100 | 
            +
                        }, {
         | 
| 1101 | 
            +
                            readonly internalType: "address";
         | 
| 1102 | 
            +
                            readonly name: "to";
         | 
| 1103 | 
            +
                            readonly type: "address";
         | 
| 1104 | 
            +
                        }, {
         | 
| 1105 | 
            +
                            readonly internalType: "bytes4";
         | 
| 1106 | 
            +
                            readonly name: "func";
         | 
| 1107 | 
            +
                            readonly type: "bytes4";
         | 
| 1108 | 
            +
                        }, {
         | 
| 1109 | 
            +
                            readonly internalType: "uint8";
         | 
| 1110 | 
            +
                            readonly name: "permission";
         | 
| 1111 | 
            +
                            readonly type: "uint8";
         | 
| 1112 | 
            +
                        }];
         | 
| 1113 | 
            +
                        readonly name: "setPermission";
         | 
| 1114 | 
            +
                        readonly outputs: readonly [];
         | 
| 1115 | 
            +
                        readonly stateMutability: "nonpayable";
         | 
| 1116 | 
            +
                        readonly type: "function";
         | 
| 1117 | 
            +
                    } | {
         | 
| 713 1118 | 
             
                        readonly inputs: readonly [{
         | 
| 714 1119 | 
             
                            readonly internalType: "address";
         | 
| 715 1120 | 
             
                            readonly name: "caller";
         | 
| @@ -730,7 +1135,38 @@ export declare class PermissionClient { | |
| 730 1135 | 
             
                        readonly name: "AccessControlled__ZeroAddress";
         | 
| 731 1136 | 
             
                        readonly type: "error";
         | 
| 732 1137 | 
             
                    } | {
         | 
| 733 | 
            -
                        readonly inputs: readonly [ | 
| 1138 | 
            +
                        readonly inputs: readonly [{
         | 
| 1139 | 
            +
                            readonly internalType: "address";
         | 
| 1140 | 
            +
                            readonly name: "signer";
         | 
| 1141 | 
            +
                            readonly type: "address";
         | 
| 1142 | 
            +
                        }, {
         | 
| 1143 | 
            +
                            readonly internalType: "address";
         | 
| 1144 | 
            +
                            readonly name: "to";
         | 
| 1145 | 
            +
                            readonly type: "address";
         | 
| 1146 | 
            +
                        }];
         | 
| 1147 | 
            +
                        readonly name: "AccessController__BothCallerAndRecipientAreNotRegisteredModule";
         | 
| 1148 | 
            +
                        readonly type: "error";
         | 
| 1149 | 
            +
                    } | {
         | 
| 1150 | 
            +
                        readonly inputs: readonly [];
         | 
| 1151 | 
            +
                        /**
         | 
| 1152 | 
            +
                         * Sets the permission for a specific function call
         | 
| 1153 | 
            +
                         * Each policy is represented as a mapping from an IP account address to a signer address to a recipient
         | 
| 1154 | 
            +
                         * address to a function selector to a permission level. The permission level can be 0 (ABSTAIN), 1 (ALLOW), or
         | 
| 1155 | 
            +
                         * 2 (DENY).
         | 
| 1156 | 
            +
                         * By default, all policies are set to 0 (ABSTAIN), which means that the permission is not set.
         | 
| 1157 | 
            +
                         * The owner of ipAccount by default has all permission.
         | 
| 1158 | 
            +
                         * address(0) => wildcard
         | 
| 1159 | 
            +
                         * bytes4(0) => wildcard
         | 
| 1160 | 
            +
                         * Specific permission overrides wildcard permission.
         | 
| 1161 | 
            +
                         * @param request The request object containing necessary data to set permissions.
         | 
| 1162 | 
            +
                         *   @param request.ipAsset The address of the IP account that grants the permission for `signer`
         | 
| 1163 | 
            +
                         *   @param request.signer The address that can call `to` on behalf of the `ipAccount`
         | 
| 1164 | 
            +
                         *   @param request.to The address that can be called by the `signer` (currently only modules can be `to`)
         | 
| 1165 | 
            +
                         *   @param request.func Optional. The function selector string of `to` that can be called by the `signer` on behalf of the `ipAccount`. Be default, it allows all functions.
         | 
| 1166 | 
            +
                         *   @param request.permission The new permission level
         | 
| 1167 | 
            +
                         * @returns A Promise that resolves to an object containing the transaction hash
         | 
| 1168 | 
            +
                         * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
         | 
| 1169 | 
            +
                         */
         | 
| 734 1170 | 
             
                        readonly name: "AccessController__CallerIsNotIPAccount";
         | 
| 735 1171 | 
             
                        readonly type: "error";
         | 
| 736 1172 | 
             
                    } | {
         | 
| @@ -770,240 +1206,484 @@ export declare class PermissionClient { | |
| 770 1206 | 
             
                        readonly name: "AccessController__PermissionIsNotValid";
         | 
| 771 1207 | 
             
                        readonly type: "error";
         | 
| 772 1208 | 
             
                    } | {
         | 
| 773 | 
            -
                        readonly inputs: readonly [ | 
| 774 | 
            -
             | 
| 775 | 
            -
                            readonly name: "to";
         | 
| 776 | 
            -
                            readonly type: "address";
         | 
| 777 | 
            -
                        }];
         | 
| 778 | 
            -
                        readonly name: "AccessController__RecipientIsNotRegisteredModule";
         | 
| 1209 | 
            +
                        readonly inputs: readonly [];
         | 
| 1210 | 
            +
                        readonly name: "AccessController__SignerIsZeroAddress";
         | 
| 779 1211 | 
             
                        readonly type: "error";
         | 
| 780 1212 | 
             
                    } | {
         | 
| 781 1213 | 
             
                        readonly inputs: readonly [];
         | 
| 782 | 
            -
                        readonly name: " | 
| 1214 | 
            +
                        readonly name: "ArbitrationPolicySP__NotDisputeModule";
         | 
| 783 1215 | 
             
                        readonly type: "error";
         | 
| 784 1216 | 
             
                    } | {
         | 
| 785 1217 | 
             
                        readonly inputs: readonly [];
         | 
| 786 | 
            -
                        readonly name: " | 
| 1218 | 
            +
                        readonly name: "ArbitrationPolicySP__ZeroDisputeModule";
         | 
| 787 1219 | 
             
                        readonly type: "error";
         | 
| 788 1220 | 
             
                    } | {
         | 
| 789 1221 | 
             
                        readonly inputs: readonly [];
         | 
| 790 | 
            -
                        readonly name: " | 
| 1222 | 
            +
                        readonly name: "ArbitrationPolicySP__ZeroPaymentToken";
         | 
| 791 1223 | 
             
                        readonly type: "error";
         | 
| 792 1224 | 
             
                    } | {
         | 
| 793 1225 | 
             
                        readonly inputs: readonly [];
         | 
| 794 | 
            -
                        readonly name: " | 
| 1226 | 
            +
                        readonly name: "BasePolicyFrameworkManager__CallerNotLicensingModule";
         | 
| 795 1227 | 
             
                        readonly type: "error";
         | 
| 796 1228 | 
             
                    } | {
         | 
| 797 1229 | 
             
                        readonly inputs: readonly [];
         | 
| 798 | 
            -
                        readonly name: " | 
| 1230 | 
            +
                        readonly name: "CoreMetadataModule__MetadataAlreadyFrozen";
         | 
| 799 1231 | 
             
                        readonly type: "error";
         | 
| 800 1232 | 
             
                    } | {
         | 
| 801 1233 | 
             
                        readonly inputs: readonly [];
         | 
| 802 | 
            -
                        readonly name: " | 
| 1234 | 
            +
                        readonly name: "DisputeModule__NotAbleToResolve";
         | 
| 803 1235 | 
             
                        readonly type: "error";
         | 
| 804 1236 | 
             
                    } | {
         | 
| 805 1237 | 
             
                        readonly inputs: readonly [];
         | 
| 806 | 
            -
                        readonly name: " | 
| 1238 | 
            +
                        readonly name: "DisputeModule__NotDisputeInitiator";
         | 
| 807 1239 | 
             
                        readonly type: "error";
         | 
| 808 1240 | 
             
                    } | {
         | 
| 809 1241 | 
             
                        readonly inputs: readonly [];
         | 
| 810 | 
            -
                        readonly name: " | 
| 1242 | 
            +
                        readonly name: "DisputeModule__NotInDisputeState";
         | 
| 811 1243 | 
             
                        readonly type: "error";
         | 
| 812 1244 | 
             
                    } | {
         | 
| 813 1245 | 
             
                        readonly inputs: readonly [];
         | 
| 814 | 
            -
                        readonly name: " | 
| 1246 | 
            +
                        readonly name: "DisputeModule__NotRegisteredIpId";
         | 
| 815 1247 | 
             
                        readonly type: "error";
         | 
| 816 1248 | 
             
                    } | {
         | 
| 817 1249 | 
             
                        readonly inputs: readonly [];
         | 
| 818 | 
            -
                        readonly name: " | 
| 1250 | 
            +
                        readonly name: "DisputeModule__NotWhitelistedArbitrationPolicy";
         | 
| 819 1251 | 
             
                        readonly type: "error";
         | 
| 820 1252 | 
             
                    } | {
         | 
| 821 1253 | 
             
                        readonly inputs: readonly [];
         | 
| 822 | 
            -
                        readonly name: " | 
| 1254 | 
            +
                        readonly name: "DisputeModule__NotWhitelistedArbitrationRelayer";
         | 
| 823 1255 | 
             
                        readonly type: "error";
         | 
| 824 1256 | 
             
                    } | {
         | 
| 825 1257 | 
             
                        readonly inputs: readonly [];
         | 
| 826 | 
            -
                        readonly name: " | 
| 1258 | 
            +
                        readonly name: "DisputeModule__NotWhitelistedDisputeTag";
         | 
| 827 1259 | 
             
                        readonly type: "error";
         | 
| 828 1260 | 
             
                    } | {
         | 
| 829 1261 | 
             
                        readonly inputs: readonly [];
         | 
| 830 | 
            -
                        readonly name: " | 
| 1262 | 
            +
                        readonly name: "DisputeModule__ZeroArbitrationPolicy";
         | 
| 831 1263 | 
             
                        readonly type: "error";
         | 
| 832 1264 | 
             
                    } | {
         | 
| 833 1265 | 
             
                        readonly inputs: readonly [];
         | 
| 834 | 
            -
                        readonly name: " | 
| 1266 | 
            +
                        readonly name: "DisputeModule__ZeroArbitrationRelayer";
         | 
| 835 1267 | 
             
                        readonly type: "error";
         | 
| 836 1268 | 
             
                    } | {
         | 
| 837 1269 | 
             
                        readonly inputs: readonly [];
         | 
| 838 | 
            -
                        readonly name: " | 
| 1270 | 
            +
                        readonly name: "DisputeModule__ZeroDisputeTag";
         | 
| 839 1271 | 
             
                        readonly type: "error";
         | 
| 840 1272 | 
             
                    } | {
         | 
| 841 1273 | 
             
                        readonly inputs: readonly [];
         | 
| 842 | 
            -
                        readonly name: " | 
| 1274 | 
            +
                        readonly name: "DisputeModule__ZeroLinkToDisputeEvidence";
         | 
| 843 1275 | 
             
                        readonly type: "error";
         | 
| 844 1276 | 
             
                    } | {
         | 
| 845 1277 | 
             
                        readonly inputs: readonly [];
         | 
| 846 | 
            -
                        readonly name: " | 
| 1278 | 
            +
                        readonly name: "Governance__InconsistentState";
         | 
| 847 1279 | 
             
                        readonly type: "error";
         | 
| 848 1280 | 
             
                    } | {
         | 
| 849 1281 | 
             
                        readonly inputs: readonly [];
         | 
| 850 | 
            -
                        readonly name: " | 
| 1282 | 
            +
                        readonly name: "Governance__NewStateIsTheSameWithOldState";
         | 
| 851 1283 | 
             
                        readonly type: "error";
         | 
| 852 1284 | 
             
                    } | {
         | 
| 853 1285 | 
             
                        readonly inputs: readonly [];
         | 
| 854 | 
            -
                        readonly name: " | 
| 1286 | 
            +
                        readonly name: "Governance__OnlyProtocolAdmin";
         | 
| 855 1287 | 
             
                        readonly type: "error";
         | 
| 856 1288 | 
             
                    } | {
         | 
| 857 1289 | 
             
                        readonly inputs: readonly [];
         | 
| 858 | 
            -
                        readonly name: " | 
| 1290 | 
            +
                        readonly name: "Governance__ProtocolPaused";
         | 
| 1291 | 
            +
                        readonly type: "error";
         | 
| 1292 | 
            +
                    } | {
         | 
| 1293 | 
            +
                        readonly inputs: readonly [{
         | 
| 1294 | 
            +
                            readonly internalType: "string";
         | 
| 1295 | 
            +
                            readonly name: "interfaceName";
         | 
| 1296 | 
            +
                            readonly type: "string";
         | 
| 1297 | 
            +
                        }];
         | 
| 1298 | 
            +
                        readonly name: "Governance__UnsupportedInterface";
         | 
| 859 1299 | 
             
                        readonly type: "error";
         | 
| 860 1300 | 
             
                    } | {
         | 
| 861 1301 | 
             
                        readonly inputs: readonly [];
         | 
| 862 | 
            -
                        readonly name: " | 
| 1302 | 
            +
                        readonly name: "Governance__ZeroAddress";
         | 
| 863 1303 | 
             
                        readonly type: "error";
         | 
| 864 1304 | 
             
                    } | {
         | 
| 865 1305 | 
             
                        readonly inputs: readonly [];
         | 
| 866 | 
            -
                        readonly name: " | 
| 1306 | 
            +
                        readonly name: "IPAccountRegistry_InvalidIpAccountImpl";
         | 
| 867 1307 | 
             
                        readonly type: "error";
         | 
| 868 1308 | 
             
                    } | {
         | 
| 869 1309 | 
             
                        readonly inputs: readonly [];
         | 
| 870 | 
            -
                        readonly name: " | 
| 1310 | 
            +
                        readonly name: "IPAccount__ExpiredSignature";
         | 
| 871 1311 | 
             
                        readonly type: "error";
         | 
| 872 1312 | 
             
                    } | {
         | 
| 873 1313 | 
             
                        readonly inputs: readonly [];
         | 
| 874 | 
            -
                        readonly name: " | 
| 1314 | 
            +
                        readonly name: "IPAccount__InvalidAccessController";
         | 
| 875 1315 | 
             
                        readonly type: "error";
         | 
| 876 1316 | 
             
                    } | {
         | 
| 877 1317 | 
             
                        readonly inputs: readonly [];
         | 
| 878 | 
            -
                        readonly name: " | 
| 1318 | 
            +
                        readonly name: "IPAccount__InvalidCalldata";
         | 
| 879 1319 | 
             
                        readonly type: "error";
         | 
| 880 1320 | 
             
                    } | {
         | 
| 881 1321 | 
             
                        readonly inputs: readonly [];
         | 
| 882 | 
            -
                        readonly name: " | 
| 1322 | 
            +
                        readonly name: "IPAccount__InvalidSignature";
         | 
| 883 1323 | 
             
                        readonly type: "error";
         | 
| 884 1324 | 
             
                    } | {
         | 
| 885 1325 | 
             
                        readonly inputs: readonly [];
         | 
| 886 | 
            -
                        readonly name: " | 
| 1326 | 
            +
                        readonly name: "IPAccount__InvalidSigner";
         | 
| 887 1327 | 
             
                        readonly type: "error";
         | 
| 888 1328 | 
             
                    } | {
         | 
| 889 1329 | 
             
                        readonly inputs: readonly [];
         | 
| 890 | 
            -
                        readonly name: " | 
| 1330 | 
            +
                        readonly name: "IPAssetRegistry__AlreadyRegistered";
         | 
| 1331 | 
            +
                        readonly type: "error";
         | 
| 1332 | 
            +
                    } | {
         | 
| 1333 | 
            +
                        readonly inputs: readonly [];
         | 
| 1334 | 
            +
                        readonly name: "IPAssetRegistry__IPAccountAlreadyCreated";
         | 
| 1335 | 
            +
                        readonly type: "error";
         | 
| 1336 | 
            +
                    } | {
         | 
| 1337 | 
            +
                        readonly inputs: readonly [];
         | 
| 1338 | 
            +
                        readonly name: "IPAssetRegistry__InvalidAccount";
         | 
| 1339 | 
            +
                        readonly type: "error";
         | 
| 1340 | 
            +
                    } | {
         | 
| 1341 | 
            +
                        readonly inputs: readonly [];
         | 
| 1342 | 
            +
                        readonly name: "IPAssetRegistry__InvalidMetadataProvider";
         | 
| 891 1343 | 
             
                        readonly type: "error";
         | 
| 892 1344 | 
             
                    } | {
         | 
| 893 1345 | 
             
                        readonly inputs: readonly [{
         | 
| 894 | 
            -
                            readonly internalType: " | 
| 895 | 
            -
                            readonly name: " | 
| 896 | 
            -
                            readonly type: " | 
| 1346 | 
            +
                            readonly internalType: "address";
         | 
| 1347 | 
            +
                            readonly name: "contractAddress";
         | 
| 1348 | 
            +
                            readonly type: "address";
         | 
| 1349 | 
            +
                        }, {
         | 
| 1350 | 
            +
                            readonly internalType: "uint256";
         | 
| 1351 | 
            +
                            readonly name: "tokenId";
         | 
| 1352 | 
            +
                            readonly type: "uint256";
         | 
| 897 1353 | 
             
                        }];
         | 
| 898 | 
            -
                        readonly name: " | 
| 1354 | 
            +
                        readonly name: "IPAssetRegistry__InvalidToken";
         | 
| 899 1355 | 
             
                        readonly type: "error";
         | 
| 900 1356 | 
             
                    } | {
         | 
| 901 1357 | 
             
                        readonly inputs: readonly [];
         | 
| 902 | 
            -
                        readonly name: " | 
| 1358 | 
            +
                        readonly name: "IPAssetRegistry__NotYetRegistered";
         | 
| 903 1359 | 
             
                        readonly type: "error";
         | 
| 904 1360 | 
             
                    } | {
         | 
| 905 1361 | 
             
                        readonly inputs: readonly [];
         | 
| 906 | 
            -
                        readonly name: " | 
| 1362 | 
            +
                        readonly name: "IPAssetRegistry__RegistrantUnauthorized";
         | 
| 1363 | 
            +
                        readonly type: "error";
         | 
| 1364 | 
            +
                    } | {
         | 
| 1365 | 
            +
                        readonly inputs: readonly [];
         | 
| 1366 | 
            +
                        readonly name: "IPAssetRegistry__ResolverInvalid";
         | 
| 1367 | 
            +
                        readonly type: "error";
         | 
| 1368 | 
            +
                    } | {
         | 
| 1369 | 
            +
                        readonly inputs: readonly [];
         | 
| 1370 | 
            +
                        readonly name: "IPAssetRegistry__Unauthorized";
         | 
| 1371 | 
            +
                        readonly type: "error";
         | 
| 1372 | 
            +
                    } | {
         | 
| 1373 | 
            +
                        readonly inputs: readonly [{
         | 
| 1374 | 
            +
                            readonly internalType: "address";
         | 
| 1375 | 
            +
                            readonly name: "contractAddress";
         | 
| 1376 | 
            +
                            readonly type: "address";
         | 
| 1377 | 
            +
                        }];
         | 
| 1378 | 
            +
                        readonly name: "IPAssetRegistry__UnsupportedIERC721";
         | 
| 1379 | 
            +
                        readonly type: "error";
         | 
| 1380 | 
            +
                    } | {
         | 
| 1381 | 
            +
                        readonly inputs: readonly [{
         | 
| 1382 | 
            +
                            readonly internalType: "address";
         | 
| 1383 | 
            +
                            readonly name: "contractAddress";
         | 
| 1384 | 
            +
                            readonly type: "address";
         | 
| 1385 | 
            +
                        }];
         | 
| 1386 | 
            +
                        readonly name: "IPAssetRegistry__UnsupportedIERC721Metadata";
         | 
| 1387 | 
            +
                        readonly type: "error";
         | 
| 1388 | 
            +
                    } | {
         | 
| 1389 | 
            +
                        readonly inputs: readonly [];
         | 
| 1390 | 
            +
                        readonly name: "IPResolver_InvalidIP";
         | 
| 1391 | 
            +
                        readonly type: "error";
         | 
| 1392 | 
            +
                    } | {
         | 
| 1393 | 
            +
                        readonly inputs: readonly [];
         | 
| 1394 | 
            +
                        readonly name: "IPResolver_Unauthorized";
         | 
| 1395 | 
            +
                        readonly type: "error";
         | 
| 1396 | 
            +
                    } | {
         | 
| 1397 | 
            +
                        readonly inputs: readonly [];
         | 
| 1398 | 
            +
                        readonly name: "IpRoyaltyVault__AlreadyClaimed";
         | 
| 1399 | 
            +
                        readonly type: "error";
         | 
| 1400 | 
            +
                    } | {
         | 
| 1401 | 
            +
                        readonly inputs: readonly [];
         | 
| 1402 | 
            +
                        readonly name: "IpRoyaltyVault__ClaimerNotAnAncestor";
         | 
| 1403 | 
            +
                        readonly type: "error";
         | 
| 1404 | 
            +
                    } | {
         | 
| 1405 | 
            +
                        readonly inputs: readonly [];
         | 
| 1406 | 
            +
                        readonly name: "IpRoyaltyVault__IpTagged";
         | 
| 1407 | 
            +
                        readonly type: "error";
         | 
| 1408 | 
            +
                    } | {
         | 
| 1409 | 
            +
                        readonly inputs: readonly [];
         | 
| 1410 | 
            +
                        readonly name: "IpRoyaltyVault__NotRoyaltyPolicyLAP";
         | 
| 1411 | 
            +
                        readonly type: "error";
         | 
| 1412 | 
            +
                    } | {
         | 
| 1413 | 
            +
                        readonly inputs: readonly [];
         | 
| 1414 | 
            +
                        readonly name: "IpRoyaltyVault__SnapshotIntervalTooShort";
         | 
| 1415 | 
            +
                        readonly type: "error";
         | 
| 1416 | 
            +
                    } | {
         | 
| 1417 | 
            +
                        readonly inputs: readonly [];
         | 
| 1418 | 
            +
                        readonly name: "IpRoyaltyVault__ZeroDisputeModule";
         | 
| 1419 | 
            +
                        readonly type: "error";
         | 
| 1420 | 
            +
                    } | {
         | 
| 1421 | 
            +
                        readonly inputs: readonly [];
         | 
| 1422 | 
            +
                        readonly name: "IpRoyaltyVault__ZeroIpId";
         | 
| 1423 | 
            +
                        readonly type: "error";
         | 
| 1424 | 
            +
                    } | {
         | 
| 1425 | 
            +
                        readonly inputs: readonly [];
         | 
| 1426 | 
            +
                        readonly name: "IpRoyaltyVault__ZeroRoyaltyPolicyLAP";
         | 
| 1427 | 
            +
                        readonly type: "error";
         | 
| 1428 | 
            +
                    } | {
         | 
| 1429 | 
            +
                        readonly inputs: readonly [];
         | 
| 1430 | 
            +
                        readonly name: "LicenseRegistry__CallerNotLicensingModule";
         | 
| 1431 | 
            +
                        readonly type: "error";
         | 
| 1432 | 
            +
                    } | {
         | 
| 1433 | 
            +
                        readonly inputs: readonly [{
         | 
| 1434 | 
            +
                            readonly internalType: "address";
         | 
| 1435 | 
            +
                            readonly name: "childIpId";
         | 
| 1436 | 
            +
                            readonly type: "address";
         | 
| 1437 | 
            +
                        }];
         | 
| 1438 | 
            +
                        readonly name: "LicenseRegistry__DerivativeAlreadyRegistered";
         | 
| 1439 | 
            +
                        readonly type: "error";
         | 
| 1440 | 
            +
                    } | {
         | 
| 1441 | 
            +
                        readonly inputs: readonly [{
         | 
| 1442 | 
            +
                            readonly internalType: "address";
         | 
| 1443 | 
            +
                            readonly name: "childIpId";
         | 
| 1444 | 
            +
                            readonly type: "address";
         | 
| 1445 | 
            +
                        }];
         | 
| 1446 | 
            +
                        readonly name: "LicenseRegistry__DerivativeIpAlreadyHasLicense";
         | 
| 1447 | 
            +
                        readonly type: "error";
         | 
| 1448 | 
            +
                    } | {
         | 
| 1449 | 
            +
                        readonly inputs: readonly [{
         | 
| 1450 | 
            +
                            readonly internalType: "address";
         | 
| 1451 | 
            +
                            readonly name: "ipId";
         | 
| 1452 | 
            +
                            readonly type: "address";
         | 
| 1453 | 
            +
                        }];
         | 
| 1454 | 
            +
                        readonly name: "LicenseRegistry__DerivativeIsParent";
         | 
| 1455 | 
            +
                        readonly type: "error";
         | 
| 1456 | 
            +
                    } | {
         | 
| 1457 | 
            +
                        readonly inputs: readonly [{
         | 
| 1458 | 
            +
                            readonly internalType: "address";
         | 
| 1459 | 
            +
                            readonly name: "ipId";
         | 
| 1460 | 
            +
                            readonly type: "address";
         | 
| 1461 | 
            +
                        }, {
         | 
| 1462 | 
            +
                            readonly internalType: "uint256";
         | 
| 1463 | 
            +
                            readonly name: "index";
         | 
| 1464 | 
            +
                            readonly type: "uint256";
         | 
| 1465 | 
            +
                        }, {
         | 
| 1466 | 
            +
                            readonly internalType: "uint256";
         | 
| 1467 | 
            +
                            readonly name: "length";
         | 
| 1468 | 
            +
                            readonly type: "uint256";
         | 
| 1469 | 
            +
                        }];
         | 
| 1470 | 
            +
                        readonly name: "LicenseRegistry__IndexOutOfBounds";
         | 
| 1471 | 
            +
                        readonly type: "error";
         | 
| 1472 | 
            +
                    } | {
         | 
| 1473 | 
            +
                        readonly inputs: readonly [{
         | 
| 1474 | 
            +
                            readonly internalType: "address";
         | 
| 1475 | 
            +
                            readonly name: "ipId";
         | 
| 1476 | 
            +
                            readonly type: "address";
         | 
| 1477 | 
            +
                        }];
         | 
| 1478 | 
            +
                        readonly name: "LicenseRegistry__IpExpired";
         | 
| 1479 | 
            +
                        readonly type: "error";
         | 
| 1480 | 
            +
                    } | {
         | 
| 1481 | 
            +
                        readonly inputs: readonly [{
         | 
| 1482 | 
            +
                            readonly internalType: "address";
         | 
| 1483 | 
            +
                            readonly name: "licenseTemplate";
         | 
| 1484 | 
            +
                            readonly type: "address";
         | 
| 1485 | 
            +
                        }, {
         | 
| 1486 | 
            +
                            readonly internalType: "uint256";
         | 
| 1487 | 
            +
                            readonly name: "licenseTermsId";
         | 
| 1488 | 
            +
                            readonly type: "uint256";
         | 
| 1489 | 
            +
                        }];
         | 
| 1490 | 
            +
                        readonly name: "LicenseRegistry__LicenseTermsNotExists";
         | 
| 1491 | 
            +
                        readonly type: "error";
         | 
| 1492 | 
            +
                    } | {
         | 
| 1493 | 
            +
                        readonly inputs: readonly [];
         | 
| 1494 | 
            +
                        readonly name: "LicenseRegistry__NoParentIp";
         | 
| 1495 | 
            +
                        readonly type: "error";
         | 
| 1496 | 
            +
                    } | {
         | 
| 1497 | 
            +
                        readonly inputs: readonly [{
         | 
| 1498 | 
            +
                            readonly internalType: "address";
         | 
| 1499 | 
            +
                            readonly name: "licenseTemplate";
         | 
| 1500 | 
            +
                            readonly type: "address";
         | 
| 1501 | 
            +
                        }];
         | 
| 1502 | 
            +
                        readonly name: "LicenseRegistry__NotLicenseTemplate";
         | 
| 907 1503 | 
             
                        readonly type: "error";
         | 
| 908 1504 | 
             
                    } | {
         | 
| 909 1505 | 
             
                        readonly inputs: readonly [];
         | 
| 910 | 
            -
                        readonly name: " | 
| 1506 | 
            +
                        readonly name: "LicenseRegistry__NotTransferable";
         | 
| 911 1507 | 
             
                        readonly type: "error";
         | 
| 912 1508 | 
             
                    } | {
         | 
| 913 | 
            -
                        readonly inputs: readonly [ | 
| 914 | 
            -
             | 
| 1509 | 
            +
                        readonly inputs: readonly [{
         | 
| 1510 | 
            +
                            readonly internalType: "address";
         | 
| 1511 | 
            +
                            readonly name: "ipId";
         | 
| 1512 | 
            +
                            readonly type: "address";
         | 
| 1513 | 
            +
                        }];
         | 
| 1514 | 
            +
                        readonly name: "LicenseRegistry__ParentIpExpired";
         | 
| 915 1515 | 
             
                        readonly type: "error";
         | 
| 916 1516 | 
             
                    } | {
         | 
| 917 | 
            -
                        readonly inputs: readonly [ | 
| 918 | 
            -
             | 
| 1517 | 
            +
                        readonly inputs: readonly [{
         | 
| 1518 | 
            +
                            readonly internalType: "address";
         | 
| 1519 | 
            +
                            readonly name: "ipId";
         | 
| 1520 | 
            +
                            readonly type: "address";
         | 
| 1521 | 
            +
                        }, {
         | 
| 1522 | 
            +
                            readonly internalType: "uint256";
         | 
| 1523 | 
            +
                            readonly name: "licenseTermsId";
         | 
| 1524 | 
            +
                            readonly type: "uint256";
         | 
| 1525 | 
            +
                        }];
         | 
| 1526 | 
            +
                        readonly name: "LicenseRegistry__ParentIpHasNoLicenseTerms";
         | 
| 919 1527 | 
             
                        readonly type: "error";
         | 
| 920 1528 | 
             
                    } | {
         | 
| 921 | 
            -
                        readonly inputs: readonly [ | 
| 922 | 
            -
             | 
| 1529 | 
            +
                        readonly inputs: readonly [{
         | 
| 1530 | 
            +
                            readonly internalType: "address";
         | 
| 1531 | 
            +
                            readonly name: "ipId";
         | 
| 1532 | 
            +
                            readonly type: "address";
         | 
| 1533 | 
            +
                        }];
         | 
| 1534 | 
            +
                        readonly name: "LicenseRegistry__ParentIpTagged";
         | 
| 923 1535 | 
             
                        readonly type: "error";
         | 
| 924 1536 | 
             
                    } | {
         | 
| 925 | 
            -
                        readonly inputs: readonly [ | 
| 926 | 
            -
             | 
| 1537 | 
            +
                        readonly inputs: readonly [{
         | 
| 1538 | 
            +
                            readonly internalType: "address";
         | 
| 1539 | 
            +
                            readonly name: "ipId";
         | 
| 1540 | 
            +
                            readonly type: "address";
         | 
| 1541 | 
            +
                        }, {
         | 
| 1542 | 
            +
                            readonly internalType: "address";
         | 
| 1543 | 
            +
                            readonly name: "licenseTemplate";
         | 
| 1544 | 
            +
                            readonly type: "address";
         | 
| 1545 | 
            +
                        }];
         | 
| 1546 | 
            +
                        readonly name: "LicenseRegistry__ParentIpUnmachedLicenseTemplate";
         | 
| 927 1547 | 
             
                        readonly type: "error";
         | 
| 928 1548 | 
             
                    } | {
         | 
| 929 | 
            -
                        readonly inputs: readonly [ | 
| 930 | 
            -
             | 
| 1549 | 
            +
                        readonly inputs: readonly [{
         | 
| 1550 | 
            +
                            readonly internalType: "address";
         | 
| 1551 | 
            +
                            readonly name: "licenseTemplate";
         | 
| 1552 | 
            +
                            readonly type: "address";
         | 
| 1553 | 
            +
                        }];
         | 
| 1554 | 
            +
                        readonly name: "LicenseRegistry__UnregisteredLicenseTemplate";
         | 
| 931 1555 | 
             
                        readonly type: "error";
         | 
| 932 1556 | 
             
                    } | {
         | 
| 933 1557 | 
             
                        readonly inputs: readonly [];
         | 
| 934 | 
            -
                        readonly name: " | 
| 1558 | 
            +
                        readonly name: "LicenseRegistry__ZeroDisputeModule";
         | 
| 935 1559 | 
             
                        readonly type: "error";
         | 
| 936 1560 | 
             
                    } | {
         | 
| 937 1561 | 
             
                        readonly inputs: readonly [];
         | 
| 938 | 
            -
                        readonly name: " | 
| 1562 | 
            +
                        readonly name: "LicenseRegistry__ZeroLicensingModule";
         | 
| 939 1563 | 
             
                        readonly type: "error";
         | 
| 940 1564 | 
             
                    } | {
         | 
| 941 | 
            -
                        readonly inputs: readonly [ | 
| 942 | 
            -
             | 
| 1565 | 
            +
                        readonly inputs: readonly [{
         | 
| 1566 | 
            +
                            readonly internalType: "address";
         | 
| 1567 | 
            +
                            readonly name: "licenseTemplate";
         | 
| 1568 | 
            +
                            readonly type: "address";
         | 
| 1569 | 
            +
                        }, {
         | 
| 1570 | 
            +
                            readonly internalType: "address";
         | 
| 1571 | 
            +
                            readonly name: "anotherLicenseTemplate";
         | 
| 1572 | 
            +
                            readonly type: "address";
         | 
| 1573 | 
            +
                        }];
         | 
| 1574 | 
            +
                        readonly name: "LicenseToken__AllLicenseTokensMustFromSameLicenseTemplate";
         | 
| 943 1575 | 
             
                        readonly type: "error";
         | 
| 944 1576 | 
             
                    } | {
         | 
| 945 1577 | 
             
                        readonly inputs: readonly [];
         | 
| 946 | 
            -
                        readonly name: " | 
| 1578 | 
            +
                        readonly name: "LicenseToken__CallerNotLicensingModule";
         | 
| 947 1579 | 
             
                        readonly type: "error";
         | 
| 948 1580 | 
             
                    } | {
         | 
| 949 | 
            -
                        readonly inputs: readonly [ | 
| 950 | 
            -
             | 
| 1581 | 
            +
                        readonly inputs: readonly [{
         | 
| 1582 | 
            +
                            readonly internalType: "uint256";
         | 
| 1583 | 
            +
                            readonly name: "tokenId";
         | 
| 1584 | 
            +
                            readonly type: "uint256";
         | 
| 1585 | 
            +
                        }, {
         | 
| 1586 | 
            +
                            readonly internalType: "uint256";
         | 
| 1587 | 
            +
                            readonly name: "expiredAt";
         | 
| 1588 | 
            +
                            readonly type: "uint256";
         | 
| 1589 | 
            +
                        }, {
         | 
| 1590 | 
            +
                            readonly internalType: "uint256";
         | 
| 1591 | 
            +
                            readonly name: "currentTimestamp";
         | 
| 1592 | 
            +
                            readonly type: "uint256";
         | 
| 1593 | 
            +
                        }];
         | 
| 1594 | 
            +
                        readonly name: "LicenseToken__LicenseTokenExpired";
         | 
| 951 1595 | 
             
                        readonly type: "error";
         | 
| 952 1596 | 
             
                    } | {
         | 
| 953 | 
            -
                        readonly inputs: readonly [ | 
| 954 | 
            -
             | 
| 1597 | 
            +
                        readonly inputs: readonly [{
         | 
| 1598 | 
            +
                            readonly internalType: "uint256";
         | 
| 1599 | 
            +
                            readonly name: "tokenId";
         | 
| 1600 | 
            +
                            readonly type: "uint256";
         | 
| 1601 | 
            +
                        }, {
         | 
| 1602 | 
            +
                            readonly internalType: "address";
         | 
| 1603 | 
            +
                            readonly name: "iPowner";
         | 
| 1604 | 
            +
                            readonly type: "address";
         | 
| 1605 | 
            +
                        }, {
         | 
| 1606 | 
            +
                            readonly internalType: "address";
         | 
| 1607 | 
            +
                            readonly name: "tokenOwner";
         | 
| 1608 | 
            +
                            readonly type: "address";
         | 
| 1609 | 
            +
                        }];
         | 
| 1610 | 
            +
                        readonly name: "LicenseToken__NotLicenseTokenOwner";
         | 
| 955 1611 | 
             
                        readonly type: "error";
         | 
| 956 1612 | 
             
                    } | {
         | 
| 957 1613 | 
             
                        readonly inputs: readonly [];
         | 
| 958 | 
            -
                        readonly name: " | 
| 1614 | 
            +
                        readonly name: "LicenseToken__NotTransferable";
         | 
| 959 1615 | 
             
                        readonly type: "error";
         | 
| 960 1616 | 
             
                    } | {
         | 
| 961 | 
            -
                        readonly inputs: readonly [ | 
| 962 | 
            -
             | 
| 1617 | 
            +
                        readonly inputs: readonly [{
         | 
| 1618 | 
            +
                            readonly internalType: "uint256";
         | 
| 1619 | 
            +
                            readonly name: "tokenId";
         | 
| 1620 | 
            +
                            readonly type: "uint256";
         | 
| 1621 | 
            +
                        }];
         | 
| 1622 | 
            +
                        readonly name: "LicenseToken__RevokedLicense";
         | 
| 963 1623 | 
             
                        readonly type: "error";
         | 
| 964 1624 | 
             
                    } | {
         | 
| 965 1625 | 
             
                        readonly inputs: readonly [];
         | 
| 966 | 
            -
                        readonly name: " | 
| 1626 | 
            +
                        readonly name: "LicenseToken__ZeroDisputeModule";
         | 
| 967 1627 | 
             
                        readonly type: "error";
         | 
| 968 1628 | 
             
                    } | {
         | 
| 969 1629 | 
             
                        readonly inputs: readonly [];
         | 
| 970 | 
            -
                        readonly name: " | 
| 1630 | 
            +
                        readonly name: "LicenseToken__ZeroLicensingModule";
         | 
| 971 1631 | 
             
                        readonly type: "error";
         | 
| 972 1632 | 
             
                    } | {
         | 
| 973 1633 | 
             
                        readonly inputs: readonly [];
         | 
| 974 | 
            -
                        readonly name: " | 
| 1634 | 
            +
                        readonly name: "LicensingModule__CallerNotLicenseRegistry";
         | 
| 975 1635 | 
             
                        readonly type: "error";
         | 
| 976 1636 | 
             
                    } | {
         | 
| 977 | 
            -
                        readonly inputs: readonly [ | 
| 978 | 
            -
             | 
| 1637 | 
            +
                        readonly inputs: readonly [{
         | 
| 1638 | 
            +
                            readonly internalType: "address";
         | 
| 1639 | 
            +
                            readonly name: "caller";
         | 
| 1640 | 
            +
                            readonly type: "address";
         | 
| 1641 | 
            +
                        }, {
         | 
| 1642 | 
            +
                            readonly internalType: "address";
         | 
| 1643 | 
            +
                            readonly name: "licensorIpId";
         | 
| 1644 | 
            +
                            readonly type: "address";
         | 
| 1645 | 
            +
                        }, {
         | 
| 1646 | 
            +
                            readonly internalType: "address";
         | 
| 1647 | 
            +
                            readonly name: "licenseTemplate";
         | 
| 1648 | 
            +
                            readonly type: "address";
         | 
| 1649 | 
            +
                        }, {
         | 
| 1650 | 
            +
                            readonly internalType: "uint256";
         | 
| 1651 | 
            +
                            readonly name: "licenseTermsId";
         | 
| 1652 | 
            +
                            readonly type: "uint256";
         | 
| 1653 | 
            +
                        }];
         | 
| 1654 | 
            +
                        readonly name: "LicensingModule__CallerNotLicensorAndIpHasNotAttachedLicenseTerms";
         | 
| 979 1655 | 
             
                        readonly type: "error";
         | 
| 980 1656 | 
             
                    } | {
         | 
| 981 1657 | 
             
                        readonly inputs: readonly [];
         | 
| 982 | 
            -
                        readonly name: " | 
| 1658 | 
            +
                        readonly name: "LicensingModule__CallerNotLicensorAndPolicyNotSet";
         | 
| 983 1659 | 
             
                        readonly type: "error";
         | 
| 984 1660 | 
             
                    } | {
         | 
| 985 1661 | 
             
                        readonly inputs: readonly [];
         | 
| 986 | 
            -
                        readonly name: " | 
| 1662 | 
            +
                        readonly name: "LicensingModule__CommercialTermInNonCommercialPolicy";
         | 
| 987 1663 | 
             
                        readonly type: "error";
         | 
| 988 1664 | 
             
                    } | {
         | 
| 989 | 
            -
                        readonly inputs: readonly [ | 
| 990 | 
            -
             | 
| 1665 | 
            +
                        readonly inputs: readonly [{
         | 
| 1666 | 
            +
                            readonly internalType: "address";
         | 
| 1667 | 
            +
                            readonly name: "ipId";
         | 
| 1668 | 
            +
                            readonly type: "address";
         | 
| 1669 | 
            +
                        }];
         | 
| 1670 | 
            +
                        readonly name: "LicensingModule__DerivativeAlreadyHasLicenseTerms";
         | 
| 991 1671 | 
             
                        readonly type: "error";
         | 
| 992 1672 | 
             
                    } | {
         | 
| 993 1673 | 
             
                        readonly inputs: readonly [];
         | 
| 994 | 
            -
                        readonly name: " | 
| 1674 | 
            +
                        readonly name: "LicensingModule__DerivativeAlreadyRegistered";
         | 
| 995 1675 | 
             
                        readonly type: "error";
         | 
| 996 1676 | 
             
                    } | {
         | 
| 997 1677 | 
             
                        readonly inputs: readonly [];
         | 
| 998 | 
            -
                        readonly name: " | 
| 1678 | 
            +
                        readonly name: "LicensingModule__DerivativeIsParent";
         | 
| 999 1679 | 
             
                        readonly type: "error";
         | 
| 1000 1680 | 
             
                    } | {
         | 
| 1001 1681 | 
             
                        readonly inputs: readonly [];
         | 
| 1002 | 
            -
                        readonly name: " | 
| 1682 | 
            +
                        readonly name: "LicensingModule__DerivativeRevShareSumExceedsMaxRNFTSupply";
         | 
| 1003 1683 | 
             
                        readonly type: "error";
         | 
| 1004 1684 | 
             
                    } | {
         | 
| 1005 1685 | 
             
                        readonly inputs: readonly [];
         | 
| 1006 | 
            -
                        readonly name: " | 
| 1686 | 
            +
                        readonly name: "LicensingModule__DerivativesCannotAddLicenseTerms";
         | 
| 1007 1687 | 
             
                        readonly type: "error";
         | 
| 1008 1688 | 
             
                    } | {
         | 
| 1009 1689 | 
             
                        readonly inputs: readonly [];
         | 
| @@ -1027,11 +1707,19 @@ export declare class PermissionClient { | |
| 1027 1707 | 
             
                        readonly type: "error";
         | 
| 1028 1708 | 
             
                    } | {
         | 
| 1029 1709 | 
             
                        readonly inputs: readonly [];
         | 
| 1030 | 
            -
                        readonly name: " | 
| 1710 | 
            +
                        readonly name: "LicensingModule__IncompatibleLicensorRoyaltyDerivativeRevShare";
         | 
| 1031 1711 | 
             
                        readonly type: "error";
         | 
| 1032 1712 | 
             
                    } | {
         | 
| 1033 | 
            -
                        readonly inputs: readonly [ | 
| 1034 | 
            -
             | 
| 1713 | 
            +
                        readonly inputs: readonly [{
         | 
| 1714 | 
            +
                            readonly internalType: "address";
         | 
| 1715 | 
            +
                            readonly name: "royaltyPolicy";
         | 
| 1716 | 
            +
                            readonly type: "address";
         | 
| 1717 | 
            +
                        }, {
         | 
| 1718 | 
            +
                            readonly internalType: "address";
         | 
| 1719 | 
            +
                            readonly name: "anotherRoyaltyPolicy";
         | 
| 1720 | 
            +
                            readonly type: "address";
         | 
| 1721 | 
            +
                        }];
         | 
| 1722 | 
            +
                        readonly name: "LicensingModule__IncompatibleRoyaltyPolicy";
         | 
| 1035 1723 | 
             
                        readonly type: "error";
         | 
| 1036 1724 | 
             
                    } | {
         | 
| 1037 1725 | 
             
                        readonly inputs: readonly [];
         | 
| @@ -1049,6 +1737,54 @@ export declare class PermissionClient { | |
| 1049 1737 | 
             
                        readonly inputs: readonly [];
         | 
| 1050 1738 | 
             
                        readonly name: "LicensingModule__InvalidPolicyFramework";
         | 
| 1051 1739 | 
             
                        readonly type: "error";
         | 
| 1740 | 
            +
                    } | {
         | 
| 1741 | 
            +
                        readonly inputs: readonly [];
         | 
| 1742 | 
            +
                        readonly name: "LicensingModule__IpAlreadyLinked";
         | 
| 1743 | 
            +
                        readonly type: "error";
         | 
| 1744 | 
            +
                    } | {
         | 
| 1745 | 
            +
                        readonly inputs: readonly [{
         | 
| 1746 | 
            +
                            readonly internalType: "address";
         | 
| 1747 | 
            +
                            readonly name: "childIpId";
         | 
| 1748 | 
            +
                            readonly type: "address";
         | 
| 1749 | 
            +
                        }];
         | 
| 1750 | 
            +
                        readonly name: "LicensingModule__LicenseNotCompatibleForDerivative";
         | 
| 1751 | 
            +
                        readonly type: "error";
         | 
| 1752 | 
            +
                    } | {
         | 
| 1753 | 
            +
                        readonly inputs: readonly [{
         | 
| 1754 | 
            +
                            readonly internalType: "uint256";
         | 
| 1755 | 
            +
                            readonly name: "ipLength";
         | 
| 1756 | 
            +
                            readonly type: "uint256";
         | 
| 1757 | 
            +
                        }, {
         | 
| 1758 | 
            +
                            readonly internalType: "uint256";
         | 
| 1759 | 
            +
                            readonly name: "licenseTermsLength";
         | 
| 1760 | 
            +
                            readonly type: "uint256";
         | 
| 1761 | 
            +
                        }];
         | 
| 1762 | 
            +
                        readonly name: "LicensingModule__LicenseTermsLengthMismatch";
         | 
| 1763 | 
            +
                        readonly type: "error";
         | 
| 1764 | 
            +
                    } | {
         | 
| 1765 | 
            +
                        readonly inputs: readonly [{
         | 
| 1766 | 
            +
                            readonly internalType: "address";
         | 
| 1767 | 
            +
                            readonly name: "licenseTemplate";
         | 
| 1768 | 
            +
                            readonly type: "address";
         | 
| 1769 | 
            +
                        }, {
         | 
| 1770 | 
            +
                            readonly internalType: "uint256";
         | 
| 1771 | 
            +
                            readonly name: "licenseTermsId";
         | 
| 1772 | 
            +
                            readonly type: "uint256";
         | 
| 1773 | 
            +
                        }];
         | 
| 1774 | 
            +
                        readonly name: "LicensingModule__LicenseTermsNotFound";
         | 
| 1775 | 
            +
                        readonly type: "error";
         | 
| 1776 | 
            +
                    } | {
         | 
| 1777 | 
            +
                        readonly inputs: readonly [{
         | 
| 1778 | 
            +
                            readonly internalType: "address";
         | 
| 1779 | 
            +
                            readonly name: "childIpId";
         | 
| 1780 | 
            +
                            readonly type: "address";
         | 
| 1781 | 
            +
                        }, {
         | 
| 1782 | 
            +
                            readonly internalType: "uint256[]";
         | 
| 1783 | 
            +
                            readonly name: "licenseTokenIds";
         | 
| 1784 | 
            +
                            readonly type: "uint256[]";
         | 
| 1785 | 
            +
                        }];
         | 
| 1786 | 
            +
                        readonly name: "LicensingModule__LicenseTokenNotCompatibleForDerivative";
         | 
| 1787 | 
            +
                        readonly type: "error";
         | 
| 1052 1788 | 
             
                    } | {
         | 
| 1053 1789 | 
             
                        readonly inputs: readonly [];
         | 
| 1054 1790 | 
             
                        readonly name: "LicensingModule__LicensorDoesntHaveThisPolicy";
         | 
| @@ -1065,6 +1801,10 @@ export declare class PermissionClient { | |
| 1065 1801 | 
             
                        readonly inputs: readonly [];
         | 
| 1066 1802 | 
             
                        readonly name: "LicensingModule__LinkingRevokedLicense";
         | 
| 1067 1803 | 
             
                        readonly type: "error";
         | 
| 1804 | 
            +
                    } | {
         | 
| 1805 | 
            +
                        readonly inputs: readonly [];
         | 
| 1806 | 
            +
                        readonly name: "LicensingModule__MintAmountZero";
         | 
| 1807 | 
            +
                        readonly type: "error";
         | 
| 1068 1808 | 
             
                    } | {
         | 
| 1069 1809 | 
             
                        readonly inputs: readonly [];
         | 
| 1070 1810 | 
             
                        readonly name: "LicensingModule__MintLicenseParamFailed";
         | 
| @@ -1077,6 +1817,14 @@ export declare class PermissionClient { | |
| 1077 1817 | 
             
                        readonly inputs: readonly [];
         | 
| 1078 1818 | 
             
                        readonly name: "LicensingModule__MismatchBetweenRoyaltyPolicy";
         | 
| 1079 1819 | 
             
                        readonly type: "error";
         | 
| 1820 | 
            +
                    } | {
         | 
| 1821 | 
            +
                        readonly inputs: readonly [];
         | 
| 1822 | 
            +
                        readonly name: "LicensingModule__NoLicenseToken";
         | 
| 1823 | 
            +
                        readonly type: "error";
         | 
| 1824 | 
            +
                    } | {
         | 
| 1825 | 
            +
                        readonly inputs: readonly [];
         | 
| 1826 | 
            +
                        readonly name: "LicensingModule__NoParentIp";
         | 
| 1827 | 
            +
                        readonly type: "error";
         | 
| 1080 1828 | 
             
                    } | {
         | 
| 1081 1829 | 
             
                        readonly inputs: readonly [];
         | 
| 1082 1830 | 
             
                        readonly name: "LicensingModule__NotLicensee";
         | 
| @@ -1093,6 +1841,14 @@ export declare class PermissionClient { | |
| 1093 1841 | 
             
                        readonly inputs: readonly [];
         | 
| 1094 1842 | 
             
                        readonly name: "LicensingModule__ParentIdEqualThanChild";
         | 
| 1095 1843 | 
             
                        readonly type: "error";
         | 
| 1844 | 
            +
                    } | {
         | 
| 1845 | 
            +
                        readonly inputs: readonly [{
         | 
| 1846 | 
            +
                            readonly internalType: "address";
         | 
| 1847 | 
            +
                            readonly name: "ipId";
         | 
| 1848 | 
            +
                            readonly type: "address";
         | 
| 1849 | 
            +
                        }];
         | 
| 1850 | 
            +
                        readonly name: "LicensingModule__ParentIpHasNoLicenseTerms";
         | 
| 1851 | 
            +
                        readonly type: "error";
         | 
| 1096 1852 | 
             
                    } | {
         | 
| 1097 1853 | 
             
                        readonly inputs: readonly [];
         | 
| 1098 1854 | 
             
                        readonly name: "LicensingModule__PolicyAlreadySetForIpId";
         | 
| @@ -1101,6 +1857,18 @@ export declare class PermissionClient { | |
| 1101 1857 | 
             
                        readonly inputs: readonly [];
         | 
| 1102 1858 | 
             
                        readonly name: "LicensingModule__PolicyNotFound";
         | 
| 1103 1859 | 
             
                        readonly type: "error";
         | 
| 1860 | 
            +
                    } | {
         | 
| 1861 | 
            +
                        readonly inputs: readonly [{
         | 
| 1862 | 
            +
                            readonly internalType: "address";
         | 
| 1863 | 
            +
                            readonly name: "receiver";
         | 
| 1864 | 
            +
                            readonly type: "address";
         | 
| 1865 | 
            +
                        }];
         | 
| 1866 | 
            +
                        readonly name: "LicensingModule__ReceiverCheckFailed";
         | 
| 1867 | 
            +
                        readonly type: "error";
         | 
| 1868 | 
            +
                    } | {
         | 
| 1869 | 
            +
                        readonly inputs: readonly [];
         | 
| 1870 | 
            +
                        readonly name: "LicensingModule__ReceiverZeroAddress";
         | 
| 1871 | 
            +
                        readonly type: "error";
         | 
| 1104 1872 | 
             
                    } | {
         | 
| 1105 1873 | 
             
                        readonly inputs: readonly [];
         | 
| 1106 1874 | 
             
                        readonly name: "LicensingModule__RegisterPolicyFrameworkMismatch";
         | 
| @@ -1231,15 +1999,15 @@ export declare class PermissionClient { | |
| 1231 1999 | 
             
                        readonly type: "error";
         | 
| 1232 2000 | 
             
                    } | {
         | 
| 1233 2001 | 
             
                        readonly inputs: readonly [];
         | 
| 1234 | 
            -
                        readonly name: " | 
| 2002 | 
            +
                        readonly name: "RoyaltyModule__CanOnlyMintSelectedPolicy";
         | 
| 1235 2003 | 
             
                        readonly type: "error";
         | 
| 1236 2004 | 
             
                    } | {
         | 
| 1237 2005 | 
             
                        readonly inputs: readonly [];
         | 
| 1238 | 
            -
                        readonly name: " | 
| 2006 | 
            +
                        readonly name: "RoyaltyModule__IncompatibleRoyaltyPolicy";
         | 
| 1239 2007 | 
             
                        readonly type: "error";
         | 
| 1240 2008 | 
             
                    } | {
         | 
| 1241 2009 | 
             
                        readonly inputs: readonly [];
         | 
| 1242 | 
            -
                        readonly name: " | 
| 2010 | 
            +
                        readonly name: "RoyaltyModule__IpIsTagged";
         | 
| 1243 2011 | 
             
                        readonly type: "error";
         | 
| 1244 2012 | 
             
                    } | {
         | 
| 1245 2013 | 
             
                        readonly inputs: readonly [];
         | 
| @@ -1255,15 +2023,15 @@ export declare class PermissionClient { | |
| 1255 2023 | 
             
                        readonly type: "error";
         | 
| 1256 2024 | 
             
                    } | {
         | 
| 1257 2025 | 
             
                        readonly inputs: readonly [];
         | 
| 1258 | 
            -
                        readonly name: " | 
| 2026 | 
            +
                        readonly name: "RoyaltyModule__NotWhitelistedRoyaltyPolicy";
         | 
| 1259 2027 | 
             
                        readonly type: "error";
         | 
| 1260 2028 | 
             
                    } | {
         | 
| 1261 2029 | 
             
                        readonly inputs: readonly [];
         | 
| 1262 | 
            -
                        readonly name: " | 
| 2030 | 
            +
                        readonly name: "RoyaltyModule__NotWhitelistedRoyaltyToken";
         | 
| 1263 2031 | 
             
                        readonly type: "error";
         | 
| 1264 2032 | 
             
                    } | {
         | 
| 1265 2033 | 
             
                        readonly inputs: readonly [];
         | 
| 1266 | 
            -
                        readonly name: " | 
| 2034 | 
            +
                        readonly name: "RoyaltyModule__ZeroDisputeModule";
         | 
| 1267 2035 | 
             
                        readonly type: "error";
         | 
| 1268 2036 | 
             
                    } | {
         | 
| 1269 2037 | 
             
                        readonly inputs: readonly [];
         | 
| @@ -1293,30 +2061,10 @@ export declare class PermissionClient { | |
| 1293 2061 | 
             
                        readonly inputs: readonly [];
         | 
| 1294 2062 | 
             
                        readonly name: "RoyaltyPolicyLAP__ImplementationAlreadySet";
         | 
| 1295 2063 | 
             
                        readonly type: "error";
         | 
| 1296 | 
            -
                    } | {
         | 
| 1297 | 
            -
                        readonly inputs: readonly [];
         | 
| 1298 | 
            -
                        readonly name: "RoyaltyPolicyLAP__InvalidAncestors";
         | 
| 1299 | 
            -
                        readonly type: "error";
         | 
| 1300 | 
            -
                    } | {
         | 
| 1301 | 
            -
                        readonly inputs: readonly [];
         | 
| 1302 | 
            -
                        readonly name: "RoyaltyPolicyLAP__InvalidAncestorsHash";
         | 
| 1303 | 
            -
                        readonly type: "error";
         | 
| 1304 | 
            -
                    } | {
         | 
| 1305 | 
            -
                        readonly inputs: readonly [];
         | 
| 1306 | 
            -
                        readonly name: "RoyaltyPolicyLAP__InvalidAncestorsLength";
         | 
| 1307 | 
            -
                        readonly type: "error";
         | 
| 1308 | 
            -
                    } | {
         | 
| 1309 | 
            -
                        readonly inputs: readonly [];
         | 
| 1310 | 
            -
                        readonly name: "RoyaltyPolicyLAP__InvalidAncestorsRoyalty";
         | 
| 1311 | 
            -
                        readonly type: "error";
         | 
| 1312 2064 | 
             
                    } | {
         | 
| 1313 2065 | 
             
                        readonly inputs: readonly [];
         | 
| 1314 2066 | 
             
                        readonly name: "RoyaltyPolicyLAP__InvalidParentRoyaltiesLength";
         | 
| 1315 2067 | 
             
                        readonly type: "error";
         | 
| 1316 | 
            -
                    } | {
         | 
| 1317 | 
            -
                        readonly inputs: readonly [];
         | 
| 1318 | 
            -
                        readonly name: "RoyaltyPolicyLAP__InvalidRoyaltyAmountLength";
         | 
| 1319 | 
            -
                        readonly type: "error";
         | 
| 1320 2068 | 
             
                    } | {
         | 
| 1321 2069 | 
             
                        readonly inputs: readonly [];
         | 
| 1322 2070 | 
             
                        readonly name: "RoyaltyPolicyLAP__LastPositionNotAbleToMintLicense";
         | 
| @@ -1331,15 +2079,15 @@ export declare class PermissionClient { | |
| 1331 2079 | 
             
                        readonly type: "error";
         | 
| 1332 2080 | 
             
                    } | {
         | 
| 1333 2081 | 
             
                        readonly inputs: readonly [];
         | 
| 1334 | 
            -
                        readonly name: " | 
| 2082 | 
            +
                        readonly name: "RoyaltyPolicyLAP__UnlinkableToParents";
         | 
| 1335 2083 | 
             
                        readonly type: "error";
         | 
| 1336 2084 | 
             
                    } | {
         | 
| 1337 2085 | 
             
                        readonly inputs: readonly [];
         | 
| 1338 | 
            -
                        readonly name: " | 
| 2086 | 
            +
                        readonly name: "RoyaltyPolicyLAP__ZeroAncestorsVaultImpl";
         | 
| 1339 2087 | 
             
                        readonly type: "error";
         | 
| 1340 2088 | 
             
                    } | {
         | 
| 1341 2089 | 
             
                        readonly inputs: readonly [];
         | 
| 1342 | 
            -
                        readonly name: " | 
| 2090 | 
            +
                        readonly name: "RoyaltyPolicyLAP__ZeroIpRoyaltyVaultBeacon";
         | 
| 1343 2091 | 
             
                        readonly type: "error";
         | 
| 1344 2092 | 
             
                    } | {
         | 
| 1345 2093 | 
             
                        readonly inputs: readonly [];
         | 
| @@ -1357,71 +2105,10 @@ export declare class PermissionClient { | |
| 1357 2105 | 
             
                        readonly inputs: readonly [];
         | 
| 1358 2106 | 
             
                        readonly name: "RoyaltyPolicyLAP__ZeroRoyaltyModule";
         | 
| 1359 2107 | 
             
                        readonly type: "error";
         | 
| 1360 | 
            -
                    } | {
         | 
| 1361 | 
            -
                        readonly anonymous: false;
         | 
| 1362 | 
            -
                        readonly inputs: readonly [{
         | 
| 1363 | 
            -
                            readonly indexed: false;
         | 
| 1364 | 
            -
                            readonly internalType: "address";
         | 
| 1365 | 
            -
                            readonly name: "ipAccountOwner";
         | 
| 1366 | 
            -
                            readonly type: "address";
         | 
| 1367 | 
            -
                        }, {
         | 
| 1368 | 
            -
                            readonly indexed: true;
         | 
| 1369 | 
            -
                            readonly internalType: "address";
         | 
| 1370 | 
            -
                            readonly name: "ipAccount";
         | 
| 1371 | 
            -
                            readonly type: "address";
         | 
| 1372 | 
            -
                        }, {
         | 
| 1373 | 
            -
                            readonly indexed: true;
         | 
| 1374 | 
            -
                            readonly internalType: "address";
         | 
| 1375 | 
            -
                            readonly name: "signer";
         | 
| 1376 | 
            -
                            readonly type: "address";
         | 
| 1377 | 
            -
                        }, {
         | 
| 1378 | 
            -
                            readonly indexed: true;
         | 
| 1379 | 
            -
                            readonly internalType: "address";
         | 
| 1380 | 
            -
                            readonly name: "to";
         | 
| 1381 | 
            -
                            readonly type: "address";
         | 
| 1382 | 
            -
                        }, {
         | 
| 1383 | 
            -
                            readonly indexed: false;
         | 
| 1384 | 
            -
                            readonly internalType: "bytes4";
         | 
| 1385 | 
            -
                            readonly name: "func";
         | 
| 1386 | 
            -
                            readonly type: "bytes4";
         | 
| 1387 | 
            -
                        }, {
         | 
| 1388 | 
            -
                            readonly indexed: false;
         | 
| 1389 | 
            -
                            readonly internalType: "uint8";
         | 
| 1390 | 
            -
                            readonly name: "permission";
         | 
| 1391 | 
            -
                            readonly type: "uint8";
         | 
| 1392 | 
            -
                        }];
         | 
| 1393 | 
            -
                        readonly name: "PermissionSet";
         | 
| 1394 | 
            -
                        readonly type: "event";
         | 
| 1395 | 
            -
                    } | {
         | 
| 1396 | 
            -
                        readonly inputs: readonly [{
         | 
| 1397 | 
            -
                            readonly internalType: "address";
         | 
| 1398 | 
            -
                            readonly name: "ipAccount";
         | 
| 1399 | 
            -
                            readonly type: "address";
         | 
| 1400 | 
            -
                        }, {
         | 
| 1401 | 
            -
                            readonly internalType: "address";
         | 
| 1402 | 
            -
                            readonly name: "signer";
         | 
| 1403 | 
            -
                            readonly type: "address";
         | 
| 1404 | 
            -
                        }, {
         | 
| 1405 | 
            -
                            readonly internalType: "address";
         | 
| 1406 | 
            -
                            readonly name: "to";
         | 
| 1407 | 
            -
                            readonly type: "address";
         | 
| 1408 | 
            -
                        }, {
         | 
| 1409 | 
            -
                            readonly internalType: "bytes4";
         | 
| 1410 | 
            -
                            readonly name: "func";
         | 
| 1411 | 
            -
                            readonly type: "bytes4";
         | 
| 1412 | 
            -
                        }, {
         | 
| 1413 | 
            -
                            readonly internalType: "uint8";
         | 
| 1414 | 
            -
                            readonly name: "permission";
         | 
| 1415 | 
            -
                            readonly type: "uint8";
         | 
| 1416 | 
            -
                        }];
         | 
| 1417 | 
            -
                        readonly name: "setPermission";
         | 
| 1418 | 
            -
                        readonly outputs: readonly [];
         | 
| 1419 | 
            -
                        readonly stateMutability: "nonpayable";
         | 
| 1420 | 
            -
                        readonly type: "function";
         | 
| 1421 2108 | 
             
                    })[];
         | 
| 1422 2109 | 
             
                    address: `0x${string}`;
         | 
| 1423 2110 | 
             
                };
         | 
| 1424 | 
            -
                constructor(rpcClient: PublicClient, wallet: WalletClient);
         | 
| 2111 | 
            +
                constructor(rpcClient: PublicClient, wallet: WalletClient, chainId: SupportedChainIds);
         | 
| 1425 2112 | 
             
                /**
         | 
| 1426 2113 | 
             
                 * Sets the permission for a specific function call
         | 
| 1427 2114 | 
             
                 * Each policy is represented as a mapping from an IP account address to a signer address to a recipient
         |