@story-protocol/core-sdk 1.0.0-rc.3 → 1.0.0-rc.4
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/abi/generated.d.ts +1875 -0
 - package/dist/declarations/src/abi/generated.d.ts.map +1 -1
 - package/dist/declarations/src/resources/ipAsset.d.ts +17 -16
 - package/dist/declarations/src/resources/ipAsset.d.ts.map +1 -1
 - package/dist/declarations/src/resources/license.d.ts +30 -36
 - package/dist/declarations/src/resources/license.d.ts.map +1 -1
 - package/dist/declarations/src/resources/royalty.d.ts +18 -7
 - package/dist/declarations/src/resources/royalty.d.ts.map +1 -1
 - package/dist/declarations/src/types/resources/royalty.d.ts +11 -1
 - package/dist/declarations/src/types/resources/royalty.d.ts.map +1 -1
 - package/dist/story-protocol-core-sdk.cjs.dev.js +1835 -596
 - package/dist/story-protocol-core-sdk.cjs.prod.js +1835 -596
 - package/dist/story-protocol-core-sdk.esm.js +1835 -596
 - package/package.json +1 -1
 - package/dist/declarations/src/clients/storyAPI.d.ts +0 -9
 - package/dist/declarations/src/clients/storyAPI.d.ts.map +0 -1
 
| 
         @@ -7093,6 +7093,1837 @@ export declare const licenseRegistryConfig: { 
     | 
|
| 
       7093 
7093 
     | 
    
         
             
                    readonly stateMutability: "view";
         
     | 
| 
       7094 
7094 
     | 
    
         
             
                }];
         
     | 
| 
       7095 
7095 
     | 
    
         
             
            };
         
     | 
| 
      
 7096 
     | 
    
         
            +
            /**
         
     | 
| 
      
 7097 
     | 
    
         
            +
             *
         
     | 
| 
      
 7098 
     | 
    
         
            +
             */
         
     | 
| 
      
 7099 
     | 
    
         
            +
            export declare const licenseTokenAbi: readonly [{
         
     | 
| 
      
 7100 
     | 
    
         
            +
                readonly type: "constructor";
         
     | 
| 
      
 7101 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7102 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7103 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7104 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7105 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7106 
     | 
    
         
            +
                    readonly name: "target";
         
     | 
| 
      
 7107 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7108 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7109 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7110 
     | 
    
         
            +
                readonly name: "AddressEmptyCode";
         
     | 
| 
      
 7111 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7112 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7113 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7114 
     | 
    
         
            +
                    readonly name: "implementation";
         
     | 
| 
      
 7115 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7116 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7117 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7118 
     | 
    
         
            +
                readonly name: "ERC1967InvalidImplementation";
         
     | 
| 
      
 7119 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7120 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7121 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7122 
     | 
    
         
            +
                readonly name: "ERC1967NonPayable";
         
     | 
| 
      
 7123 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7124 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7125 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7126 
     | 
    
         
            +
                readonly name: "ERC721EnumerableForbiddenBatchMint";
         
     | 
| 
      
 7127 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7128 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7129 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7130 
     | 
    
         
            +
                    readonly name: "sender";
         
     | 
| 
      
 7131 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7132 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7133 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7134 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7135 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7136 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7137 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7138 
     | 
    
         
            +
                    readonly name: "owner";
         
     | 
| 
      
 7139 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7140 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7141 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7142 
     | 
    
         
            +
                readonly name: "ERC721IncorrectOwner";
         
     | 
| 
      
 7143 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7144 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7145 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7146 
     | 
    
         
            +
                    readonly name: "operator";
         
     | 
| 
      
 7147 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7148 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7149 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7150 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7151 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7152 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7153 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7154 
     | 
    
         
            +
                readonly name: "ERC721InsufficientApproval";
         
     | 
| 
      
 7155 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7156 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7157 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7158 
     | 
    
         
            +
                    readonly name: "approver";
         
     | 
| 
      
 7159 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7160 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7161 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7162 
     | 
    
         
            +
                readonly name: "ERC721InvalidApprover";
         
     | 
| 
      
 7163 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7164 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7165 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7166 
     | 
    
         
            +
                    readonly name: "operator";
         
     | 
| 
      
 7167 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7168 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7169 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7170 
     | 
    
         
            +
                readonly name: "ERC721InvalidOperator";
         
     | 
| 
      
 7171 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7172 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7173 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7174 
     | 
    
         
            +
                    readonly name: "owner";
         
     | 
| 
      
 7175 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7176 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7177 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7178 
     | 
    
         
            +
                readonly name: "ERC721InvalidOwner";
         
     | 
| 
      
 7179 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7180 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7181 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7182 
     | 
    
         
            +
                    readonly name: "receiver";
         
     | 
| 
      
 7183 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7184 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7185 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7186 
     | 
    
         
            +
                readonly name: "ERC721InvalidReceiver";
         
     | 
| 
      
 7187 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7188 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7189 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7190 
     | 
    
         
            +
                    readonly name: "sender";
         
     | 
| 
      
 7191 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7192 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7193 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7194 
     | 
    
         
            +
                readonly name: "ERC721InvalidSender";
         
     | 
| 
      
 7195 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7196 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7197 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7198 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7199 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7200 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7201 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7202 
     | 
    
         
            +
                readonly name: "ERC721NonexistentToken";
         
     | 
| 
      
 7203 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7204 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7205 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7206 
     | 
    
         
            +
                    readonly name: "owner";
         
     | 
| 
      
 7207 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7208 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7209 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7210 
     | 
    
         
            +
                    readonly name: "index";
         
     | 
| 
      
 7211 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7212 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7213 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7214 
     | 
    
         
            +
                readonly name: "ERC721OutOfBoundsIndex";
         
     | 
| 
      
 7215 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7216 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7217 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7218 
     | 
    
         
            +
                readonly name: "FailedInnerCall";
         
     | 
| 
      
 7219 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7220 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7221 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7222 
     | 
    
         
            +
                readonly name: "Governance__InconsistentState";
         
     | 
| 
      
 7223 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7224 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7225 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7226 
     | 
    
         
            +
                readonly name: "Governance__OnlyProtocolAdmin";
         
     | 
| 
      
 7227 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7228 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7229 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7230 
     | 
    
         
            +
                    readonly name: "interfaceName";
         
     | 
| 
      
 7231 
     | 
    
         
            +
                    readonly internalType: "string";
         
     | 
| 
      
 7232 
     | 
    
         
            +
                    readonly type: "string";
         
     | 
| 
      
 7233 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7234 
     | 
    
         
            +
                readonly name: "Governance__UnsupportedInterface";
         
     | 
| 
      
 7235 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7236 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7237 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7238 
     | 
    
         
            +
                readonly name: "Governance__ZeroAddress";
         
     | 
| 
      
 7239 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7240 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7241 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7242 
     | 
    
         
            +
                readonly name: "InvalidInitialization";
         
     | 
| 
      
 7243 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7244 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7245 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7246 
     | 
    
         
            +
                    readonly name: "licenseTemplate";
         
     | 
| 
      
 7247 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7248 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7249 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7250 
     | 
    
         
            +
                    readonly name: "anotherLicenseTemplate";
         
     | 
| 
      
 7251 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7252 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7253 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7254 
     | 
    
         
            +
                readonly name: "LicenseToken__AllLicenseTokensMustFromSameLicenseTemplate";
         
     | 
| 
      
 7255 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7256 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7257 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7258 
     | 
    
         
            +
                readonly name: "LicenseToken__CallerNotLicensingModule";
         
     | 
| 
      
 7259 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7260 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7261 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7262 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7263 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7264 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7265 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7266 
     | 
    
         
            +
                    readonly name: "expiredAt";
         
     | 
| 
      
 7267 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7268 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7269 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7270 
     | 
    
         
            +
                    readonly name: "currentTimestamp";
         
     | 
| 
      
 7271 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7272 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7273 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7274 
     | 
    
         
            +
                readonly name: "LicenseToken__LicenseTokenExpired";
         
     | 
| 
      
 7275 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7276 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7277 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7278 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7279 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7280 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7281 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7282 
     | 
    
         
            +
                    readonly name: "iPowner";
         
     | 
| 
      
 7283 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7284 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7285 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7286 
     | 
    
         
            +
                    readonly name: "tokenOwner";
         
     | 
| 
      
 7287 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7288 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7289 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7290 
     | 
    
         
            +
                readonly name: "LicenseToken__NotLicenseTokenOwner";
         
     | 
| 
      
 7291 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7292 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7293 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7294 
     | 
    
         
            +
                readonly name: "LicenseToken__NotTransferable";
         
     | 
| 
      
 7295 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7296 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7297 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7298 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7299 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7300 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7301 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7302 
     | 
    
         
            +
                readonly name: "LicenseToken__RevokedLicense";
         
     | 
| 
      
 7303 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7304 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7305 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7306 
     | 
    
         
            +
                readonly name: "LicenseToken__ZeroDisputeModule";
         
     | 
| 
      
 7307 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7308 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7309 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7310 
     | 
    
         
            +
                readonly name: "LicenseToken__ZeroLicensingModule";
         
     | 
| 
      
 7311 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7312 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7313 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7314 
     | 
    
         
            +
                readonly name: "NotInitializing";
         
     | 
| 
      
 7315 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7316 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7317 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7318 
     | 
    
         
            +
                    readonly name: "value";
         
     | 
| 
      
 7319 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7320 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7321 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7322 
     | 
    
         
            +
                    readonly name: "length";
         
     | 
| 
      
 7323 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7324 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7325 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7326 
     | 
    
         
            +
                readonly name: "StringsInsufficientHexLength";
         
     | 
| 
      
 7327 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7328 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7329 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7330 
     | 
    
         
            +
                readonly name: "UUPSUnauthorizedCallContext";
         
     | 
| 
      
 7331 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7332 
     | 
    
         
            +
                readonly type: "error";
         
     | 
| 
      
 7333 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7334 
     | 
    
         
            +
                    readonly name: "slot";
         
     | 
| 
      
 7335 
     | 
    
         
            +
                    readonly internalType: "bytes32";
         
     | 
| 
      
 7336 
     | 
    
         
            +
                    readonly type: "bytes32";
         
     | 
| 
      
 7337 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7338 
     | 
    
         
            +
                readonly name: "UUPSUnsupportedProxiableUUID";
         
     | 
| 
      
 7339 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7340 
     | 
    
         
            +
                readonly type: "event";
         
     | 
| 
      
 7341 
     | 
    
         
            +
                readonly anonymous: false;
         
     | 
| 
      
 7342 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7343 
     | 
    
         
            +
                    readonly name: "owner";
         
     | 
| 
      
 7344 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7345 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7346 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7347 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7348 
     | 
    
         
            +
                    readonly name: "approved";
         
     | 
| 
      
 7349 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7350 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7351 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7352 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7353 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7354 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7355 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7356 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7357 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7358 
     | 
    
         
            +
                readonly name: "Approval";
         
     | 
| 
      
 7359 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7360 
     | 
    
         
            +
                readonly type: "event";
         
     | 
| 
      
 7361 
     | 
    
         
            +
                readonly anonymous: false;
         
     | 
| 
      
 7362 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7363 
     | 
    
         
            +
                    readonly name: "owner";
         
     | 
| 
      
 7364 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7365 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7366 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7367 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7368 
     | 
    
         
            +
                    readonly name: "operator";
         
     | 
| 
      
 7369 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7370 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7371 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7372 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7373 
     | 
    
         
            +
                    readonly name: "approved";
         
     | 
| 
      
 7374 
     | 
    
         
            +
                    readonly internalType: "bool";
         
     | 
| 
      
 7375 
     | 
    
         
            +
                    readonly type: "bool";
         
     | 
| 
      
 7376 
     | 
    
         
            +
                    readonly indexed: false;
         
     | 
| 
      
 7377 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7378 
     | 
    
         
            +
                readonly name: "ApprovalForAll";
         
     | 
| 
      
 7379 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7380 
     | 
    
         
            +
                readonly type: "event";
         
     | 
| 
      
 7381 
     | 
    
         
            +
                readonly anonymous: false;
         
     | 
| 
      
 7382 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7383 
     | 
    
         
            +
                    readonly name: "_fromTokenId";
         
     | 
| 
      
 7384 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7385 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7386 
     | 
    
         
            +
                    readonly indexed: false;
         
     | 
| 
      
 7387 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7388 
     | 
    
         
            +
                    readonly name: "_toTokenId";
         
     | 
| 
      
 7389 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7390 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7391 
     | 
    
         
            +
                    readonly indexed: false;
         
     | 
| 
      
 7392 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7393 
     | 
    
         
            +
                readonly name: "BatchMetadataUpdate";
         
     | 
| 
      
 7394 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7395 
     | 
    
         
            +
                readonly type: "event";
         
     | 
| 
      
 7396 
     | 
    
         
            +
                readonly anonymous: false;
         
     | 
| 
      
 7397 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7398 
     | 
    
         
            +
                    readonly name: "newGovernance";
         
     | 
| 
      
 7399 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7400 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7401 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7402 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7403 
     | 
    
         
            +
                readonly name: "GovernanceUpdated";
         
     | 
| 
      
 7404 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7405 
     | 
    
         
            +
                readonly type: "event";
         
     | 
| 
      
 7406 
     | 
    
         
            +
                readonly anonymous: false;
         
     | 
| 
      
 7407 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7408 
     | 
    
         
            +
                    readonly name: "version";
         
     | 
| 
      
 7409 
     | 
    
         
            +
                    readonly internalType: "uint64";
         
     | 
| 
      
 7410 
     | 
    
         
            +
                    readonly type: "uint64";
         
     | 
| 
      
 7411 
     | 
    
         
            +
                    readonly indexed: false;
         
     | 
| 
      
 7412 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7413 
     | 
    
         
            +
                readonly name: "Initialized";
         
     | 
| 
      
 7414 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7415 
     | 
    
         
            +
                readonly type: "event";
         
     | 
| 
      
 7416 
     | 
    
         
            +
                readonly anonymous: false;
         
     | 
| 
      
 7417 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7418 
     | 
    
         
            +
                    readonly name: "minter";
         
     | 
| 
      
 7419 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7420 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7421 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7422 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7423 
     | 
    
         
            +
                    readonly name: "receiver";
         
     | 
| 
      
 7424 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7425 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7426 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7427 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7428 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7429 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7430 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7431 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7432 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7433 
     | 
    
         
            +
                readonly name: "LicenseTokenMinted";
         
     | 
| 
      
 7434 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7435 
     | 
    
         
            +
                readonly type: "event";
         
     | 
| 
      
 7436 
     | 
    
         
            +
                readonly anonymous: false;
         
     | 
| 
      
 7437 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7438 
     | 
    
         
            +
                    readonly name: "from";
         
     | 
| 
      
 7439 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7440 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7441 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7442 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7443 
     | 
    
         
            +
                    readonly name: "to";
         
     | 
| 
      
 7444 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7445 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7446 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7447 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7448 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7449 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7450 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7451 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7452 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7453 
     | 
    
         
            +
                readonly name: "Transfer";
         
     | 
| 
      
 7454 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7455 
     | 
    
         
            +
                readonly type: "event";
         
     | 
| 
      
 7456 
     | 
    
         
            +
                readonly anonymous: false;
         
     | 
| 
      
 7457 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7458 
     | 
    
         
            +
                    readonly name: "implementation";
         
     | 
| 
      
 7459 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7460 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7461 
     | 
    
         
            +
                    readonly indexed: true;
         
     | 
| 
      
 7462 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7463 
     | 
    
         
            +
                readonly name: "Upgraded";
         
     | 
| 
      
 7464 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7465 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7466 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7467 
     | 
    
         
            +
                readonly name: "UPGRADE_INTERFACE_VERSION";
         
     | 
| 
      
 7468 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7469 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7470 
     | 
    
         
            +
                    readonly internalType: "string";
         
     | 
| 
      
 7471 
     | 
    
         
            +
                    readonly type: "string";
         
     | 
| 
      
 7472 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7473 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7474 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7475 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7476 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7477 
     | 
    
         
            +
                    readonly name: "to";
         
     | 
| 
      
 7478 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7479 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7480 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7481 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7482 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7483 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7484 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7485 
     | 
    
         
            +
                readonly name: "approve";
         
     | 
| 
      
 7486 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7487 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7488 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7489 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7490 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7491 
     | 
    
         
            +
                    readonly name: "owner";
         
     | 
| 
      
 7492 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7493 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7494 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7495 
     | 
    
         
            +
                readonly name: "balanceOf";
         
     | 
| 
      
 7496 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7497 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7498 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7499 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7500 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7501 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7502 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7503 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7504 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7505 
     | 
    
         
            +
                    readonly name: "holder";
         
     | 
| 
      
 7506 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7507 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7508 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7509 
     | 
    
         
            +
                    readonly name: "tokenIds";
         
     | 
| 
      
 7510 
     | 
    
         
            +
                    readonly internalType: "uint256[]";
         
     | 
| 
      
 7511 
     | 
    
         
            +
                    readonly type: "uint256[]";
         
     | 
| 
      
 7512 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7513 
     | 
    
         
            +
                readonly name: "burnLicenseTokens";
         
     | 
| 
      
 7514 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7515 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7516 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7517 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7518 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7519 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7520 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7521 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7522 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7523 
     | 
    
         
            +
                readonly name: "getApproved";
         
     | 
| 
      
 7524 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7525 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7526 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7527 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7528 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7529 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7530 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7531 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7532 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7533 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7534 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7535 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7536 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7537 
     | 
    
         
            +
                readonly name: "getExpirationTime";
         
     | 
| 
      
 7538 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7539 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7540 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7541 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7542 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7543 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7544 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7545 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7546 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7547 
     | 
    
         
            +
                readonly name: "getGovernance";
         
     | 
| 
      
 7548 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7549 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7550 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7551 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7552 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7553 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7554 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7555 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7556 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7557 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7558 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7559 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7560 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7561 
     | 
    
         
            +
                readonly name: "getLicenseTemplate";
         
     | 
| 
      
 7562 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7563 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7564 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7565 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7566 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7567 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7568 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7569 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7570 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7571 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7572 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7573 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7574 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7575 
     | 
    
         
            +
                readonly name: "getLicenseTermsId";
         
     | 
| 
      
 7576 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7577 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7578 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7579 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7580 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7581 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7582 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7583 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7584 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7585 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7586 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7587 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7588 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7589 
     | 
    
         
            +
                readonly name: "getLicenseTokenMetadata";
         
     | 
| 
      
 7590 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7591 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7592 
     | 
    
         
            +
                    readonly internalType: "struct ILicenseToken.LicenseTokenMetadata";
         
     | 
| 
      
 7593 
     | 
    
         
            +
                    readonly type: "tuple";
         
     | 
| 
      
 7594 
     | 
    
         
            +
                    readonly components: readonly [{
         
     | 
| 
      
 7595 
     | 
    
         
            +
                        readonly name: "licensorIpId";
         
     | 
| 
      
 7596 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 7597 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 7598 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 7599 
     | 
    
         
            +
                        readonly name: "licenseTemplate";
         
     | 
| 
      
 7600 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 7601 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 7602 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 7603 
     | 
    
         
            +
                        readonly name: "licenseTermsId";
         
     | 
| 
      
 7604 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 7605 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 7606 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 7607 
     | 
    
         
            +
                        readonly name: "transferable";
         
     | 
| 
      
 7608 
     | 
    
         
            +
                        readonly internalType: "bool";
         
     | 
| 
      
 7609 
     | 
    
         
            +
                        readonly type: "bool";
         
     | 
| 
      
 7610 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 7611 
     | 
    
         
            +
                        readonly name: "mintedAt";
         
     | 
| 
      
 7612 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 7613 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 7614 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 7615 
     | 
    
         
            +
                        readonly name: "expiresAt";
         
     | 
| 
      
 7616 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 7617 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 7618 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 7619 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7620 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7621 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7622 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7623 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7624 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7625 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7626 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7627 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7628 
     | 
    
         
            +
                readonly name: "getLicensorIpId";
         
     | 
| 
      
 7629 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7630 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7631 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7632 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7633 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7634 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7635 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7636 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7637 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7638 
     | 
    
         
            +
                    readonly name: "governance";
         
     | 
| 
      
 7639 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7640 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7641 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7642 
     | 
    
         
            +
                    readonly name: "imageUrl";
         
     | 
| 
      
 7643 
     | 
    
         
            +
                    readonly internalType: "string";
         
     | 
| 
      
 7644 
     | 
    
         
            +
                    readonly type: "string";
         
     | 
| 
      
 7645 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7646 
     | 
    
         
            +
                readonly name: "initialize";
         
     | 
| 
      
 7647 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7648 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7649 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7650 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7651 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7652 
     | 
    
         
            +
                    readonly name: "owner";
         
     | 
| 
      
 7653 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7654 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7655 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7656 
     | 
    
         
            +
                    readonly name: "operator";
         
     | 
| 
      
 7657 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7658 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7659 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7660 
     | 
    
         
            +
                readonly name: "isApprovedForAll";
         
     | 
| 
      
 7661 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7662 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7663 
     | 
    
         
            +
                    readonly internalType: "bool";
         
     | 
| 
      
 7664 
     | 
    
         
            +
                    readonly type: "bool";
         
     | 
| 
      
 7665 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7666 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7667 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7668 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7669 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7670 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7671 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7672 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7673 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7674 
     | 
    
         
            +
                readonly name: "isLicenseTokenRevoked";
         
     | 
| 
      
 7675 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7676 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7677 
     | 
    
         
            +
                    readonly internalType: "bool";
         
     | 
| 
      
 7678 
     | 
    
         
            +
                    readonly type: "bool";
         
     | 
| 
      
 7679 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7680 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7681 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7682 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7683 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7684 
     | 
    
         
            +
                readonly name: "licensingModule";
         
     | 
| 
      
 7685 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7686 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7687 
     | 
    
         
            +
                    readonly internalType: "contract ILicensingModule";
         
     | 
| 
      
 7688 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7689 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7690 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7691 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7692 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7693 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7694 
     | 
    
         
            +
                    readonly name: "licensorIpId";
         
     | 
| 
      
 7695 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7696 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7697 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7698 
     | 
    
         
            +
                    readonly name: "licenseTemplate";
         
     | 
| 
      
 7699 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7700 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7701 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7702 
     | 
    
         
            +
                    readonly name: "licenseTermsId";
         
     | 
| 
      
 7703 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7704 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7705 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7706 
     | 
    
         
            +
                    readonly name: "amount";
         
     | 
| 
      
 7707 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7708 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7709 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7710 
     | 
    
         
            +
                    readonly name: "minter";
         
     | 
| 
      
 7711 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7712 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7713 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7714 
     | 
    
         
            +
                    readonly name: "receiver";
         
     | 
| 
      
 7715 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7716 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7717 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7718 
     | 
    
         
            +
                readonly name: "mintLicenseTokens";
         
     | 
| 
      
 7719 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7720 
     | 
    
         
            +
                    readonly name: "startLicenseTokenId";
         
     | 
| 
      
 7721 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7722 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7723 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7724 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7725 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7726 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7727 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7728 
     | 
    
         
            +
                readonly name: "name";
         
     | 
| 
      
 7729 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7730 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7731 
     | 
    
         
            +
                    readonly internalType: "string";
         
     | 
| 
      
 7732 
     | 
    
         
            +
                    readonly type: "string";
         
     | 
| 
      
 7733 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7734 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7735 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7736 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7737 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7738 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7739 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7740 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7741 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7742 
     | 
    
         
            +
                readonly name: "ownerOf";
         
     | 
| 
      
 7743 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7744 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7745 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7746 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7747 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7748 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7749 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7750 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7751 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7752 
     | 
    
         
            +
                readonly name: "proxiableUUID";
         
     | 
| 
      
 7753 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7754 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7755 
     | 
    
         
            +
                    readonly internalType: "bytes32";
         
     | 
| 
      
 7756 
     | 
    
         
            +
                    readonly type: "bytes32";
         
     | 
| 
      
 7757 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7758 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7759 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7760 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7761 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7762 
     | 
    
         
            +
                    readonly name: "from";
         
     | 
| 
      
 7763 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7764 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7765 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7766 
     | 
    
         
            +
                    readonly name: "to";
         
     | 
| 
      
 7767 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7768 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7769 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7770 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7771 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7772 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7773 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7774 
     | 
    
         
            +
                readonly name: "safeTransferFrom";
         
     | 
| 
      
 7775 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7776 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7777 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7778 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7779 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7780 
     | 
    
         
            +
                    readonly name: "from";
         
     | 
| 
      
 7781 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7782 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7783 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7784 
     | 
    
         
            +
                    readonly name: "to";
         
     | 
| 
      
 7785 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7786 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7787 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7788 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7789 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7790 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7791 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7792 
     | 
    
         
            +
                    readonly name: "data";
         
     | 
| 
      
 7793 
     | 
    
         
            +
                    readonly internalType: "bytes";
         
     | 
| 
      
 7794 
     | 
    
         
            +
                    readonly type: "bytes";
         
     | 
| 
      
 7795 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7796 
     | 
    
         
            +
                readonly name: "safeTransferFrom";
         
     | 
| 
      
 7797 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7798 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7799 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7800 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7801 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7802 
     | 
    
         
            +
                    readonly name: "operator";
         
     | 
| 
      
 7803 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7804 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7805 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7806 
     | 
    
         
            +
                    readonly name: "approved";
         
     | 
| 
      
 7807 
     | 
    
         
            +
                    readonly internalType: "bool";
         
     | 
| 
      
 7808 
     | 
    
         
            +
                    readonly type: "bool";
         
     | 
| 
      
 7809 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7810 
     | 
    
         
            +
                readonly name: "setApprovalForAll";
         
     | 
| 
      
 7811 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7812 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7813 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7814 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7815 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7816 
     | 
    
         
            +
                    readonly name: "newDisputeModule";
         
     | 
| 
      
 7817 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7818 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7819 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7820 
     | 
    
         
            +
                readonly name: "setDisputeModule";
         
     | 
| 
      
 7821 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7822 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7823 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7824 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7825 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7826 
     | 
    
         
            +
                    readonly name: "newGovernance";
         
     | 
| 
      
 7827 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7828 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7829 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7830 
     | 
    
         
            +
                readonly name: "setGovernance";
         
     | 
| 
      
 7831 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7832 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7833 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7834 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7835 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7836 
     | 
    
         
            +
                    readonly name: "url";
         
     | 
| 
      
 7837 
     | 
    
         
            +
                    readonly internalType: "string";
         
     | 
| 
      
 7838 
     | 
    
         
            +
                    readonly type: "string";
         
     | 
| 
      
 7839 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7840 
     | 
    
         
            +
                readonly name: "setLicensingImageUrl";
         
     | 
| 
      
 7841 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7842 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7843 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7844 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7845 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7846 
     | 
    
         
            +
                    readonly name: "newLicensingModule";
         
     | 
| 
      
 7847 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7848 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7849 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7850 
     | 
    
         
            +
                readonly name: "setLicensingModule";
         
     | 
| 
      
 7851 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7852 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7853 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7854 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7855 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7856 
     | 
    
         
            +
                    readonly name: "interfaceId";
         
     | 
| 
      
 7857 
     | 
    
         
            +
                    readonly internalType: "bytes4";
         
     | 
| 
      
 7858 
     | 
    
         
            +
                    readonly type: "bytes4";
         
     | 
| 
      
 7859 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7860 
     | 
    
         
            +
                readonly name: "supportsInterface";
         
     | 
| 
      
 7861 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7862 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7863 
     | 
    
         
            +
                    readonly internalType: "bool";
         
     | 
| 
      
 7864 
     | 
    
         
            +
                    readonly type: "bool";
         
     | 
| 
      
 7865 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7866 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7867 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7868 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7869 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7870 
     | 
    
         
            +
                readonly name: "symbol";
         
     | 
| 
      
 7871 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7872 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7873 
     | 
    
         
            +
                    readonly internalType: "string";
         
     | 
| 
      
 7874 
     | 
    
         
            +
                    readonly type: "string";
         
     | 
| 
      
 7875 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7876 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7877 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7878 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7879 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7880 
     | 
    
         
            +
                    readonly name: "index";
         
     | 
| 
      
 7881 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7882 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7883 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7884 
     | 
    
         
            +
                readonly name: "tokenByIndex";
         
     | 
| 
      
 7885 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7886 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7887 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7888 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7889 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7890 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7891 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7892 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7893 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7894 
     | 
    
         
            +
                    readonly name: "owner";
         
     | 
| 
      
 7895 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7896 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7897 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7898 
     | 
    
         
            +
                    readonly name: "index";
         
     | 
| 
      
 7899 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7900 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7901 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7902 
     | 
    
         
            +
                readonly name: "tokenOfOwnerByIndex";
         
     | 
| 
      
 7903 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7904 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7905 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7906 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7907 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7908 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7909 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7910 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7911 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7912 
     | 
    
         
            +
                    readonly name: "id";
         
     | 
| 
      
 7913 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7914 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7915 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7916 
     | 
    
         
            +
                readonly name: "tokenURI";
         
     | 
| 
      
 7917 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7918 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7919 
     | 
    
         
            +
                    readonly internalType: "string";
         
     | 
| 
      
 7920 
     | 
    
         
            +
                    readonly type: "string";
         
     | 
| 
      
 7921 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7922 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7923 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7924 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7925 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7926 
     | 
    
         
            +
                readonly name: "totalMintedTokens";
         
     | 
| 
      
 7927 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7928 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7929 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7930 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7931 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7932 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7933 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7934 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7935 
     | 
    
         
            +
                readonly inputs: readonly [];
         
     | 
| 
      
 7936 
     | 
    
         
            +
                readonly name: "totalSupply";
         
     | 
| 
      
 7937 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7938 
     | 
    
         
            +
                    readonly name: "";
         
     | 
| 
      
 7939 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7940 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7941 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7942 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 7943 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7944 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7945 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7946 
     | 
    
         
            +
                    readonly name: "from";
         
     | 
| 
      
 7947 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7948 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7949 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7950 
     | 
    
         
            +
                    readonly name: "to";
         
     | 
| 
      
 7951 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7952 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7953 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7954 
     | 
    
         
            +
                    readonly name: "tokenId";
         
     | 
| 
      
 7955 
     | 
    
         
            +
                    readonly internalType: "uint256";
         
     | 
| 
      
 7956 
     | 
    
         
            +
                    readonly type: "uint256";
         
     | 
| 
      
 7957 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7958 
     | 
    
         
            +
                readonly name: "transferFrom";
         
     | 
| 
      
 7959 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7960 
     | 
    
         
            +
                readonly stateMutability: "nonpayable";
         
     | 
| 
      
 7961 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7962 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7963 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7964 
     | 
    
         
            +
                    readonly name: "newImplementation";
         
     | 
| 
      
 7965 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7966 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7967 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7968 
     | 
    
         
            +
                    readonly name: "data";
         
     | 
| 
      
 7969 
     | 
    
         
            +
                    readonly internalType: "bytes";
         
     | 
| 
      
 7970 
     | 
    
         
            +
                    readonly type: "bytes";
         
     | 
| 
      
 7971 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7972 
     | 
    
         
            +
                readonly name: "upgradeToAndCall";
         
     | 
| 
      
 7973 
     | 
    
         
            +
                readonly outputs: readonly [];
         
     | 
| 
      
 7974 
     | 
    
         
            +
                readonly stateMutability: "payable";
         
     | 
| 
      
 7975 
     | 
    
         
            +
            }, {
         
     | 
| 
      
 7976 
     | 
    
         
            +
                readonly type: "function";
         
     | 
| 
      
 7977 
     | 
    
         
            +
                readonly inputs: readonly [{
         
     | 
| 
      
 7978 
     | 
    
         
            +
                    readonly name: "childIpId";
         
     | 
| 
      
 7979 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7980 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7981 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7982 
     | 
    
         
            +
                    readonly name: "childIpOwner";
         
     | 
| 
      
 7983 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7984 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7985 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7986 
     | 
    
         
            +
                    readonly name: "tokenIds";
         
     | 
| 
      
 7987 
     | 
    
         
            +
                    readonly internalType: "uint256[]";
         
     | 
| 
      
 7988 
     | 
    
         
            +
                    readonly type: "uint256[]";
         
     | 
| 
      
 7989 
     | 
    
         
            +
                }];
         
     | 
| 
      
 7990 
     | 
    
         
            +
                readonly name: "validateLicenseTokensForDerivative";
         
     | 
| 
      
 7991 
     | 
    
         
            +
                readonly outputs: readonly [{
         
     | 
| 
      
 7992 
     | 
    
         
            +
                    readonly name: "licenseTemplate";
         
     | 
| 
      
 7993 
     | 
    
         
            +
                    readonly internalType: "address";
         
     | 
| 
      
 7994 
     | 
    
         
            +
                    readonly type: "address";
         
     | 
| 
      
 7995 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 7996 
     | 
    
         
            +
                    readonly name: "licensorIpIds";
         
     | 
| 
      
 7997 
     | 
    
         
            +
                    readonly internalType: "address[]";
         
     | 
| 
      
 7998 
     | 
    
         
            +
                    readonly type: "address[]";
         
     | 
| 
      
 7999 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8000 
     | 
    
         
            +
                    readonly name: "licenseTermsIds";
         
     | 
| 
      
 8001 
     | 
    
         
            +
                    readonly internalType: "uint256[]";
         
     | 
| 
      
 8002 
     | 
    
         
            +
                    readonly type: "uint256[]";
         
     | 
| 
      
 8003 
     | 
    
         
            +
                }];
         
     | 
| 
      
 8004 
     | 
    
         
            +
                readonly stateMutability: "view";
         
     | 
| 
      
 8005 
     | 
    
         
            +
            }];
         
     | 
| 
      
 8006 
     | 
    
         
            +
            /**
         
     | 
| 
      
 8007 
     | 
    
         
            +
             *
         
     | 
| 
      
 8008 
     | 
    
         
            +
             */
         
     | 
| 
      
 8009 
     | 
    
         
            +
            export declare const licenseTokenAddress: {
         
     | 
| 
      
 8010 
     | 
    
         
            +
                readonly 1513: "0xD40b7bCA204f96a346021e31c9ad54FF495226e7";
         
     | 
| 
      
 8011 
     | 
    
         
            +
            };
         
     | 
| 
      
 8012 
     | 
    
         
            +
            /**
         
     | 
| 
      
 8013 
     | 
    
         
            +
             *
         
     | 
| 
      
 8014 
     | 
    
         
            +
             */
         
     | 
| 
      
 8015 
     | 
    
         
            +
            export declare const licenseTokenConfig: {
         
     | 
| 
      
 8016 
     | 
    
         
            +
                readonly address: {
         
     | 
| 
      
 8017 
     | 
    
         
            +
                    readonly 1513: "0xD40b7bCA204f96a346021e31c9ad54FF495226e7";
         
     | 
| 
      
 8018 
     | 
    
         
            +
                };
         
     | 
| 
      
 8019 
     | 
    
         
            +
                readonly abi: readonly [{
         
     | 
| 
      
 8020 
     | 
    
         
            +
                    readonly type: "constructor";
         
     | 
| 
      
 8021 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8022 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8023 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8024 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8025 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8026 
     | 
    
         
            +
                        readonly name: "target";
         
     | 
| 
      
 8027 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8028 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8029 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8030 
     | 
    
         
            +
                    readonly name: "AddressEmptyCode";
         
     | 
| 
      
 8031 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8032 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8033 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8034 
     | 
    
         
            +
                        readonly name: "implementation";
         
     | 
| 
      
 8035 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8036 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8037 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8038 
     | 
    
         
            +
                    readonly name: "ERC1967InvalidImplementation";
         
     | 
| 
      
 8039 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8040 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8041 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8042 
     | 
    
         
            +
                    readonly name: "ERC1967NonPayable";
         
     | 
| 
      
 8043 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8044 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8045 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8046 
     | 
    
         
            +
                    readonly name: "ERC721EnumerableForbiddenBatchMint";
         
     | 
| 
      
 8047 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8048 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8049 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8050 
     | 
    
         
            +
                        readonly name: "sender";
         
     | 
| 
      
 8051 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8052 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8053 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8054 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8055 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8056 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8057 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8058 
     | 
    
         
            +
                        readonly name: "owner";
         
     | 
| 
      
 8059 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8060 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8061 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8062 
     | 
    
         
            +
                    readonly name: "ERC721IncorrectOwner";
         
     | 
| 
      
 8063 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8064 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8065 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8066 
     | 
    
         
            +
                        readonly name: "operator";
         
     | 
| 
      
 8067 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8068 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8069 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8070 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8071 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8072 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8073 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8074 
     | 
    
         
            +
                    readonly name: "ERC721InsufficientApproval";
         
     | 
| 
      
 8075 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8076 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8077 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8078 
     | 
    
         
            +
                        readonly name: "approver";
         
     | 
| 
      
 8079 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8080 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8081 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8082 
     | 
    
         
            +
                    readonly name: "ERC721InvalidApprover";
         
     | 
| 
      
 8083 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8084 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8085 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8086 
     | 
    
         
            +
                        readonly name: "operator";
         
     | 
| 
      
 8087 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8088 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8089 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8090 
     | 
    
         
            +
                    readonly name: "ERC721InvalidOperator";
         
     | 
| 
      
 8091 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8092 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8093 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8094 
     | 
    
         
            +
                        readonly name: "owner";
         
     | 
| 
      
 8095 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8096 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8097 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8098 
     | 
    
         
            +
                    readonly name: "ERC721InvalidOwner";
         
     | 
| 
      
 8099 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8100 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8101 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8102 
     | 
    
         
            +
                        readonly name: "receiver";
         
     | 
| 
      
 8103 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8104 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8105 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8106 
     | 
    
         
            +
                    readonly name: "ERC721InvalidReceiver";
         
     | 
| 
      
 8107 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8108 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8109 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8110 
     | 
    
         
            +
                        readonly name: "sender";
         
     | 
| 
      
 8111 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8112 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8113 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8114 
     | 
    
         
            +
                    readonly name: "ERC721InvalidSender";
         
     | 
| 
      
 8115 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8116 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8117 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8118 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8119 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8120 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8121 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8122 
     | 
    
         
            +
                    readonly name: "ERC721NonexistentToken";
         
     | 
| 
      
 8123 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8124 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8125 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8126 
     | 
    
         
            +
                        readonly name: "owner";
         
     | 
| 
      
 8127 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8128 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8129 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8130 
     | 
    
         
            +
                        readonly name: "index";
         
     | 
| 
      
 8131 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8132 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8133 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8134 
     | 
    
         
            +
                    readonly name: "ERC721OutOfBoundsIndex";
         
     | 
| 
      
 8135 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8136 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8137 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8138 
     | 
    
         
            +
                    readonly name: "FailedInnerCall";
         
     | 
| 
      
 8139 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8140 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8141 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8142 
     | 
    
         
            +
                    readonly name: "Governance__InconsistentState";
         
     | 
| 
      
 8143 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8144 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8145 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8146 
     | 
    
         
            +
                    readonly name: "Governance__OnlyProtocolAdmin";
         
     | 
| 
      
 8147 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8148 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8149 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8150 
     | 
    
         
            +
                        readonly name: "interfaceName";
         
     | 
| 
      
 8151 
     | 
    
         
            +
                        readonly internalType: "string";
         
     | 
| 
      
 8152 
     | 
    
         
            +
                        readonly type: "string";
         
     | 
| 
      
 8153 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8154 
     | 
    
         
            +
                    readonly name: "Governance__UnsupportedInterface";
         
     | 
| 
      
 8155 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8156 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8157 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8158 
     | 
    
         
            +
                    readonly name: "Governance__ZeroAddress";
         
     | 
| 
      
 8159 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8160 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8161 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8162 
     | 
    
         
            +
                    readonly name: "InvalidInitialization";
         
     | 
| 
      
 8163 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8164 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8165 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8166 
     | 
    
         
            +
                        readonly name: "licenseTemplate";
         
     | 
| 
      
 8167 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8168 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8169 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8170 
     | 
    
         
            +
                        readonly name: "anotherLicenseTemplate";
         
     | 
| 
      
 8171 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8172 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8173 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8174 
     | 
    
         
            +
                    readonly name: "LicenseToken__AllLicenseTokensMustFromSameLicenseTemplate";
         
     | 
| 
      
 8175 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8176 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8177 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8178 
     | 
    
         
            +
                    readonly name: "LicenseToken__CallerNotLicensingModule";
         
     | 
| 
      
 8179 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8180 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8181 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8182 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8183 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8184 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8185 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8186 
     | 
    
         
            +
                        readonly name: "expiredAt";
         
     | 
| 
      
 8187 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8188 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8189 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8190 
     | 
    
         
            +
                        readonly name: "currentTimestamp";
         
     | 
| 
      
 8191 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8192 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8193 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8194 
     | 
    
         
            +
                    readonly name: "LicenseToken__LicenseTokenExpired";
         
     | 
| 
      
 8195 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8196 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8197 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8198 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8199 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8200 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8201 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8202 
     | 
    
         
            +
                        readonly name: "iPowner";
         
     | 
| 
      
 8203 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8204 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8205 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8206 
     | 
    
         
            +
                        readonly name: "tokenOwner";
         
     | 
| 
      
 8207 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8208 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8209 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8210 
     | 
    
         
            +
                    readonly name: "LicenseToken__NotLicenseTokenOwner";
         
     | 
| 
      
 8211 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8212 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8213 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8214 
     | 
    
         
            +
                    readonly name: "LicenseToken__NotTransferable";
         
     | 
| 
      
 8215 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8216 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8217 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8218 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8219 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8220 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8221 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8222 
     | 
    
         
            +
                    readonly name: "LicenseToken__RevokedLicense";
         
     | 
| 
      
 8223 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8224 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8225 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8226 
     | 
    
         
            +
                    readonly name: "LicenseToken__ZeroDisputeModule";
         
     | 
| 
      
 8227 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8228 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8229 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8230 
     | 
    
         
            +
                    readonly name: "LicenseToken__ZeroLicensingModule";
         
     | 
| 
      
 8231 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8232 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8233 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8234 
     | 
    
         
            +
                    readonly name: "NotInitializing";
         
     | 
| 
      
 8235 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8236 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8237 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8238 
     | 
    
         
            +
                        readonly name: "value";
         
     | 
| 
      
 8239 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8240 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8241 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8242 
     | 
    
         
            +
                        readonly name: "length";
         
     | 
| 
      
 8243 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8244 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8245 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8246 
     | 
    
         
            +
                    readonly name: "StringsInsufficientHexLength";
         
     | 
| 
      
 8247 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8248 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8249 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8250 
     | 
    
         
            +
                    readonly name: "UUPSUnauthorizedCallContext";
         
     | 
| 
      
 8251 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8252 
     | 
    
         
            +
                    readonly type: "error";
         
     | 
| 
      
 8253 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8254 
     | 
    
         
            +
                        readonly name: "slot";
         
     | 
| 
      
 8255 
     | 
    
         
            +
                        readonly internalType: "bytes32";
         
     | 
| 
      
 8256 
     | 
    
         
            +
                        readonly type: "bytes32";
         
     | 
| 
      
 8257 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8258 
     | 
    
         
            +
                    readonly name: "UUPSUnsupportedProxiableUUID";
         
     | 
| 
      
 8259 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8260 
     | 
    
         
            +
                    readonly type: "event";
         
     | 
| 
      
 8261 
     | 
    
         
            +
                    readonly anonymous: false;
         
     | 
| 
      
 8262 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8263 
     | 
    
         
            +
                        readonly name: "owner";
         
     | 
| 
      
 8264 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8265 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8266 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8267 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8268 
     | 
    
         
            +
                        readonly name: "approved";
         
     | 
| 
      
 8269 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8270 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8271 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8272 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8273 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8274 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8275 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8276 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8277 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8278 
     | 
    
         
            +
                    readonly name: "Approval";
         
     | 
| 
      
 8279 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8280 
     | 
    
         
            +
                    readonly type: "event";
         
     | 
| 
      
 8281 
     | 
    
         
            +
                    readonly anonymous: false;
         
     | 
| 
      
 8282 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8283 
     | 
    
         
            +
                        readonly name: "owner";
         
     | 
| 
      
 8284 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8285 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8286 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8287 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8288 
     | 
    
         
            +
                        readonly name: "operator";
         
     | 
| 
      
 8289 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8290 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8291 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8292 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8293 
     | 
    
         
            +
                        readonly name: "approved";
         
     | 
| 
      
 8294 
     | 
    
         
            +
                        readonly internalType: "bool";
         
     | 
| 
      
 8295 
     | 
    
         
            +
                        readonly type: "bool";
         
     | 
| 
      
 8296 
     | 
    
         
            +
                        readonly indexed: false;
         
     | 
| 
      
 8297 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8298 
     | 
    
         
            +
                    readonly name: "ApprovalForAll";
         
     | 
| 
      
 8299 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8300 
     | 
    
         
            +
                    readonly type: "event";
         
     | 
| 
      
 8301 
     | 
    
         
            +
                    readonly anonymous: false;
         
     | 
| 
      
 8302 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8303 
     | 
    
         
            +
                        readonly name: "_fromTokenId";
         
     | 
| 
      
 8304 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8305 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8306 
     | 
    
         
            +
                        readonly indexed: false;
         
     | 
| 
      
 8307 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8308 
     | 
    
         
            +
                        readonly name: "_toTokenId";
         
     | 
| 
      
 8309 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8310 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8311 
     | 
    
         
            +
                        readonly indexed: false;
         
     | 
| 
      
 8312 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8313 
     | 
    
         
            +
                    readonly name: "BatchMetadataUpdate";
         
     | 
| 
      
 8314 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8315 
     | 
    
         
            +
                    readonly type: "event";
         
     | 
| 
      
 8316 
     | 
    
         
            +
                    readonly anonymous: false;
         
     | 
| 
      
 8317 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8318 
     | 
    
         
            +
                        readonly name: "newGovernance";
         
     | 
| 
      
 8319 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8320 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8321 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8322 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8323 
     | 
    
         
            +
                    readonly name: "GovernanceUpdated";
         
     | 
| 
      
 8324 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8325 
     | 
    
         
            +
                    readonly type: "event";
         
     | 
| 
      
 8326 
     | 
    
         
            +
                    readonly anonymous: false;
         
     | 
| 
      
 8327 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8328 
     | 
    
         
            +
                        readonly name: "version";
         
     | 
| 
      
 8329 
     | 
    
         
            +
                        readonly internalType: "uint64";
         
     | 
| 
      
 8330 
     | 
    
         
            +
                        readonly type: "uint64";
         
     | 
| 
      
 8331 
     | 
    
         
            +
                        readonly indexed: false;
         
     | 
| 
      
 8332 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8333 
     | 
    
         
            +
                    readonly name: "Initialized";
         
     | 
| 
      
 8334 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8335 
     | 
    
         
            +
                    readonly type: "event";
         
     | 
| 
      
 8336 
     | 
    
         
            +
                    readonly anonymous: false;
         
     | 
| 
      
 8337 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8338 
     | 
    
         
            +
                        readonly name: "minter";
         
     | 
| 
      
 8339 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8340 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8341 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8342 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8343 
     | 
    
         
            +
                        readonly name: "receiver";
         
     | 
| 
      
 8344 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8345 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8346 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8347 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8348 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8349 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8350 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8351 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8352 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8353 
     | 
    
         
            +
                    readonly name: "LicenseTokenMinted";
         
     | 
| 
      
 8354 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8355 
     | 
    
         
            +
                    readonly type: "event";
         
     | 
| 
      
 8356 
     | 
    
         
            +
                    readonly anonymous: false;
         
     | 
| 
      
 8357 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8358 
     | 
    
         
            +
                        readonly name: "from";
         
     | 
| 
      
 8359 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8360 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8361 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8362 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8363 
     | 
    
         
            +
                        readonly name: "to";
         
     | 
| 
      
 8364 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8365 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8366 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8367 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8368 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8369 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8370 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8371 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8372 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8373 
     | 
    
         
            +
                    readonly name: "Transfer";
         
     | 
| 
      
 8374 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8375 
     | 
    
         
            +
                    readonly type: "event";
         
     | 
| 
      
 8376 
     | 
    
         
            +
                    readonly anonymous: false;
         
     | 
| 
      
 8377 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8378 
     | 
    
         
            +
                        readonly name: "implementation";
         
     | 
| 
      
 8379 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8380 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8381 
     | 
    
         
            +
                        readonly indexed: true;
         
     | 
| 
      
 8382 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8383 
     | 
    
         
            +
                    readonly name: "Upgraded";
         
     | 
| 
      
 8384 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8385 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8386 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8387 
     | 
    
         
            +
                    readonly name: "UPGRADE_INTERFACE_VERSION";
         
     | 
| 
      
 8388 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8389 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8390 
     | 
    
         
            +
                        readonly internalType: "string";
         
     | 
| 
      
 8391 
     | 
    
         
            +
                        readonly type: "string";
         
     | 
| 
      
 8392 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8393 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8394 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8395 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8396 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8397 
     | 
    
         
            +
                        readonly name: "to";
         
     | 
| 
      
 8398 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8399 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8400 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8401 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8402 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8403 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8404 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8405 
     | 
    
         
            +
                    readonly name: "approve";
         
     | 
| 
      
 8406 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8407 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8408 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8409 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8410 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8411 
     | 
    
         
            +
                        readonly name: "owner";
         
     | 
| 
      
 8412 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8413 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8414 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8415 
     | 
    
         
            +
                    readonly name: "balanceOf";
         
     | 
| 
      
 8416 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8417 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8418 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8419 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8420 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8421 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8422 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8423 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8424 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8425 
     | 
    
         
            +
                        readonly name: "holder";
         
     | 
| 
      
 8426 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8427 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8428 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8429 
     | 
    
         
            +
                        readonly name: "tokenIds";
         
     | 
| 
      
 8430 
     | 
    
         
            +
                        readonly internalType: "uint256[]";
         
     | 
| 
      
 8431 
     | 
    
         
            +
                        readonly type: "uint256[]";
         
     | 
| 
      
 8432 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8433 
     | 
    
         
            +
                    readonly name: "burnLicenseTokens";
         
     | 
| 
      
 8434 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8435 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8436 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8437 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8438 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8439 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8440 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8441 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8442 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8443 
     | 
    
         
            +
                    readonly name: "getApproved";
         
     | 
| 
      
 8444 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8445 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8446 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8447 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8448 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8449 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8450 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8451 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8452 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8453 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8454 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8455 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8456 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8457 
     | 
    
         
            +
                    readonly name: "getExpirationTime";
         
     | 
| 
      
 8458 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8459 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8460 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8461 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8462 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8463 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8464 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8465 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8466 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8467 
     | 
    
         
            +
                    readonly name: "getGovernance";
         
     | 
| 
      
 8468 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8469 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8470 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8471 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8472 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8473 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8474 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8475 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8476 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8477 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8478 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8479 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8480 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8481 
     | 
    
         
            +
                    readonly name: "getLicenseTemplate";
         
     | 
| 
      
 8482 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8483 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8484 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8485 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8486 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8487 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8488 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8489 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8490 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8491 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8492 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8493 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8494 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8495 
     | 
    
         
            +
                    readonly name: "getLicenseTermsId";
         
     | 
| 
      
 8496 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8497 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8498 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8499 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8500 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8501 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8502 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8503 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8504 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8505 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8506 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8507 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8508 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8509 
     | 
    
         
            +
                    readonly name: "getLicenseTokenMetadata";
         
     | 
| 
      
 8510 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8511 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8512 
     | 
    
         
            +
                        readonly internalType: "struct ILicenseToken.LicenseTokenMetadata";
         
     | 
| 
      
 8513 
     | 
    
         
            +
                        readonly type: "tuple";
         
     | 
| 
      
 8514 
     | 
    
         
            +
                        readonly components: readonly [{
         
     | 
| 
      
 8515 
     | 
    
         
            +
                            readonly name: "licensorIpId";
         
     | 
| 
      
 8516 
     | 
    
         
            +
                            readonly internalType: "address";
         
     | 
| 
      
 8517 
     | 
    
         
            +
                            readonly type: "address";
         
     | 
| 
      
 8518 
     | 
    
         
            +
                        }, {
         
     | 
| 
      
 8519 
     | 
    
         
            +
                            readonly name: "licenseTemplate";
         
     | 
| 
      
 8520 
     | 
    
         
            +
                            readonly internalType: "address";
         
     | 
| 
      
 8521 
     | 
    
         
            +
                            readonly type: "address";
         
     | 
| 
      
 8522 
     | 
    
         
            +
                        }, {
         
     | 
| 
      
 8523 
     | 
    
         
            +
                            readonly name: "licenseTermsId";
         
     | 
| 
      
 8524 
     | 
    
         
            +
                            readonly internalType: "uint256";
         
     | 
| 
      
 8525 
     | 
    
         
            +
                            readonly type: "uint256";
         
     | 
| 
      
 8526 
     | 
    
         
            +
                        }, {
         
     | 
| 
      
 8527 
     | 
    
         
            +
                            readonly name: "transferable";
         
     | 
| 
      
 8528 
     | 
    
         
            +
                            readonly internalType: "bool";
         
     | 
| 
      
 8529 
     | 
    
         
            +
                            readonly type: "bool";
         
     | 
| 
      
 8530 
     | 
    
         
            +
                        }, {
         
     | 
| 
      
 8531 
     | 
    
         
            +
                            readonly name: "mintedAt";
         
     | 
| 
      
 8532 
     | 
    
         
            +
                            readonly internalType: "uint256";
         
     | 
| 
      
 8533 
     | 
    
         
            +
                            readonly type: "uint256";
         
     | 
| 
      
 8534 
     | 
    
         
            +
                        }, {
         
     | 
| 
      
 8535 
     | 
    
         
            +
                            readonly name: "expiresAt";
         
     | 
| 
      
 8536 
     | 
    
         
            +
                            readonly internalType: "uint256";
         
     | 
| 
      
 8537 
     | 
    
         
            +
                            readonly type: "uint256";
         
     | 
| 
      
 8538 
     | 
    
         
            +
                        }];
         
     | 
| 
      
 8539 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8540 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8541 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8542 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8543 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8544 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8545 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8546 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8547 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8548 
     | 
    
         
            +
                    readonly name: "getLicensorIpId";
         
     | 
| 
      
 8549 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8550 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8551 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8552 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8553 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8554 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8555 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8556 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8557 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8558 
     | 
    
         
            +
                        readonly name: "governance";
         
     | 
| 
      
 8559 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8560 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8561 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8562 
     | 
    
         
            +
                        readonly name: "imageUrl";
         
     | 
| 
      
 8563 
     | 
    
         
            +
                        readonly internalType: "string";
         
     | 
| 
      
 8564 
     | 
    
         
            +
                        readonly type: "string";
         
     | 
| 
      
 8565 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8566 
     | 
    
         
            +
                    readonly name: "initialize";
         
     | 
| 
      
 8567 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8568 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8569 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8570 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8571 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8572 
     | 
    
         
            +
                        readonly name: "owner";
         
     | 
| 
      
 8573 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8574 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8575 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8576 
     | 
    
         
            +
                        readonly name: "operator";
         
     | 
| 
      
 8577 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8578 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8579 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8580 
     | 
    
         
            +
                    readonly name: "isApprovedForAll";
         
     | 
| 
      
 8581 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8582 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8583 
     | 
    
         
            +
                        readonly internalType: "bool";
         
     | 
| 
      
 8584 
     | 
    
         
            +
                        readonly type: "bool";
         
     | 
| 
      
 8585 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8586 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8587 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8588 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8589 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8590 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8591 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8592 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8593 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8594 
     | 
    
         
            +
                    readonly name: "isLicenseTokenRevoked";
         
     | 
| 
      
 8595 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8596 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8597 
     | 
    
         
            +
                        readonly internalType: "bool";
         
     | 
| 
      
 8598 
     | 
    
         
            +
                        readonly type: "bool";
         
     | 
| 
      
 8599 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8600 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8601 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8602 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8603 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8604 
     | 
    
         
            +
                    readonly name: "licensingModule";
         
     | 
| 
      
 8605 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8606 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8607 
     | 
    
         
            +
                        readonly internalType: "contract ILicensingModule";
         
     | 
| 
      
 8608 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8609 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8610 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8611 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8612 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8613 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8614 
     | 
    
         
            +
                        readonly name: "licensorIpId";
         
     | 
| 
      
 8615 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8616 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8617 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8618 
     | 
    
         
            +
                        readonly name: "licenseTemplate";
         
     | 
| 
      
 8619 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8620 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8621 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8622 
     | 
    
         
            +
                        readonly name: "licenseTermsId";
         
     | 
| 
      
 8623 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8624 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8625 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8626 
     | 
    
         
            +
                        readonly name: "amount";
         
     | 
| 
      
 8627 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8628 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8629 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8630 
     | 
    
         
            +
                        readonly name: "minter";
         
     | 
| 
      
 8631 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8632 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8633 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8634 
     | 
    
         
            +
                        readonly name: "receiver";
         
     | 
| 
      
 8635 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8636 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8637 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8638 
     | 
    
         
            +
                    readonly name: "mintLicenseTokens";
         
     | 
| 
      
 8639 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8640 
     | 
    
         
            +
                        readonly name: "startLicenseTokenId";
         
     | 
| 
      
 8641 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8642 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8643 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8644 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8645 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8646 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8647 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8648 
     | 
    
         
            +
                    readonly name: "name";
         
     | 
| 
      
 8649 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8650 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8651 
     | 
    
         
            +
                        readonly internalType: "string";
         
     | 
| 
      
 8652 
     | 
    
         
            +
                        readonly type: "string";
         
     | 
| 
      
 8653 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8654 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8655 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8656 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8657 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8658 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8659 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8660 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8661 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8662 
     | 
    
         
            +
                    readonly name: "ownerOf";
         
     | 
| 
      
 8663 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8664 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8665 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8666 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8667 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8668 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8669 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8670 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8671 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8672 
     | 
    
         
            +
                    readonly name: "proxiableUUID";
         
     | 
| 
      
 8673 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8674 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8675 
     | 
    
         
            +
                        readonly internalType: "bytes32";
         
     | 
| 
      
 8676 
     | 
    
         
            +
                        readonly type: "bytes32";
         
     | 
| 
      
 8677 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8678 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8679 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8680 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8681 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8682 
     | 
    
         
            +
                        readonly name: "from";
         
     | 
| 
      
 8683 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8684 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8685 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8686 
     | 
    
         
            +
                        readonly name: "to";
         
     | 
| 
      
 8687 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8688 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8689 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8690 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8691 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8692 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8693 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8694 
     | 
    
         
            +
                    readonly name: "safeTransferFrom";
         
     | 
| 
      
 8695 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8696 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8697 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8698 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8699 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8700 
     | 
    
         
            +
                        readonly name: "from";
         
     | 
| 
      
 8701 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8702 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8703 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8704 
     | 
    
         
            +
                        readonly name: "to";
         
     | 
| 
      
 8705 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8706 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8707 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8708 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8709 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8710 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8711 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8712 
     | 
    
         
            +
                        readonly name: "data";
         
     | 
| 
      
 8713 
     | 
    
         
            +
                        readonly internalType: "bytes";
         
     | 
| 
      
 8714 
     | 
    
         
            +
                        readonly type: "bytes";
         
     | 
| 
      
 8715 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8716 
     | 
    
         
            +
                    readonly name: "safeTransferFrom";
         
     | 
| 
      
 8717 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8718 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8719 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8720 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8721 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8722 
     | 
    
         
            +
                        readonly name: "operator";
         
     | 
| 
      
 8723 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8724 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8725 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8726 
     | 
    
         
            +
                        readonly name: "approved";
         
     | 
| 
      
 8727 
     | 
    
         
            +
                        readonly internalType: "bool";
         
     | 
| 
      
 8728 
     | 
    
         
            +
                        readonly type: "bool";
         
     | 
| 
      
 8729 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8730 
     | 
    
         
            +
                    readonly name: "setApprovalForAll";
         
     | 
| 
      
 8731 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8732 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8733 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8734 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8735 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8736 
     | 
    
         
            +
                        readonly name: "newDisputeModule";
         
     | 
| 
      
 8737 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8738 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8739 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8740 
     | 
    
         
            +
                    readonly name: "setDisputeModule";
         
     | 
| 
      
 8741 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8742 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8743 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8744 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8745 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8746 
     | 
    
         
            +
                        readonly name: "newGovernance";
         
     | 
| 
      
 8747 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8748 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8749 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8750 
     | 
    
         
            +
                    readonly name: "setGovernance";
         
     | 
| 
      
 8751 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8752 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8753 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8754 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8755 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8756 
     | 
    
         
            +
                        readonly name: "url";
         
     | 
| 
      
 8757 
     | 
    
         
            +
                        readonly internalType: "string";
         
     | 
| 
      
 8758 
     | 
    
         
            +
                        readonly type: "string";
         
     | 
| 
      
 8759 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8760 
     | 
    
         
            +
                    readonly name: "setLicensingImageUrl";
         
     | 
| 
      
 8761 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8762 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8763 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8764 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8765 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8766 
     | 
    
         
            +
                        readonly name: "newLicensingModule";
         
     | 
| 
      
 8767 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8768 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8769 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8770 
     | 
    
         
            +
                    readonly name: "setLicensingModule";
         
     | 
| 
      
 8771 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8772 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8773 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8774 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8775 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8776 
     | 
    
         
            +
                        readonly name: "interfaceId";
         
     | 
| 
      
 8777 
     | 
    
         
            +
                        readonly internalType: "bytes4";
         
     | 
| 
      
 8778 
     | 
    
         
            +
                        readonly type: "bytes4";
         
     | 
| 
      
 8779 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8780 
     | 
    
         
            +
                    readonly name: "supportsInterface";
         
     | 
| 
      
 8781 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8782 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8783 
     | 
    
         
            +
                        readonly internalType: "bool";
         
     | 
| 
      
 8784 
     | 
    
         
            +
                        readonly type: "bool";
         
     | 
| 
      
 8785 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8786 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8787 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8788 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8789 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8790 
     | 
    
         
            +
                    readonly name: "symbol";
         
     | 
| 
      
 8791 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8792 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8793 
     | 
    
         
            +
                        readonly internalType: "string";
         
     | 
| 
      
 8794 
     | 
    
         
            +
                        readonly type: "string";
         
     | 
| 
      
 8795 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8796 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8797 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8798 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8799 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8800 
     | 
    
         
            +
                        readonly name: "index";
         
     | 
| 
      
 8801 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8802 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8803 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8804 
     | 
    
         
            +
                    readonly name: "tokenByIndex";
         
     | 
| 
      
 8805 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8806 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8807 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8808 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8809 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8810 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8811 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8812 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8813 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8814 
     | 
    
         
            +
                        readonly name: "owner";
         
     | 
| 
      
 8815 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8816 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8817 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8818 
     | 
    
         
            +
                        readonly name: "index";
         
     | 
| 
      
 8819 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8820 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8821 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8822 
     | 
    
         
            +
                    readonly name: "tokenOfOwnerByIndex";
         
     | 
| 
      
 8823 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8824 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8825 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8826 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8827 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8828 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8829 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8830 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8831 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8832 
     | 
    
         
            +
                        readonly name: "id";
         
     | 
| 
      
 8833 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8834 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8835 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8836 
     | 
    
         
            +
                    readonly name: "tokenURI";
         
     | 
| 
      
 8837 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8838 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8839 
     | 
    
         
            +
                        readonly internalType: "string";
         
     | 
| 
      
 8840 
     | 
    
         
            +
                        readonly type: "string";
         
     | 
| 
      
 8841 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8842 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8843 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8844 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8845 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8846 
     | 
    
         
            +
                    readonly name: "totalMintedTokens";
         
     | 
| 
      
 8847 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8848 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8849 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8850 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8851 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8852 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8853 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8854 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8855 
     | 
    
         
            +
                    readonly inputs: readonly [];
         
     | 
| 
      
 8856 
     | 
    
         
            +
                    readonly name: "totalSupply";
         
     | 
| 
      
 8857 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8858 
     | 
    
         
            +
                        readonly name: "";
         
     | 
| 
      
 8859 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8860 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8861 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8862 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8863 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8864 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8865 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8866 
     | 
    
         
            +
                        readonly name: "from";
         
     | 
| 
      
 8867 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8868 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8869 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8870 
     | 
    
         
            +
                        readonly name: "to";
         
     | 
| 
      
 8871 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8872 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8873 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8874 
     | 
    
         
            +
                        readonly name: "tokenId";
         
     | 
| 
      
 8875 
     | 
    
         
            +
                        readonly internalType: "uint256";
         
     | 
| 
      
 8876 
     | 
    
         
            +
                        readonly type: "uint256";
         
     | 
| 
      
 8877 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8878 
     | 
    
         
            +
                    readonly name: "transferFrom";
         
     | 
| 
      
 8879 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8880 
     | 
    
         
            +
                    readonly stateMutability: "nonpayable";
         
     | 
| 
      
 8881 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8882 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8883 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8884 
     | 
    
         
            +
                        readonly name: "newImplementation";
         
     | 
| 
      
 8885 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8886 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8887 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8888 
     | 
    
         
            +
                        readonly name: "data";
         
     | 
| 
      
 8889 
     | 
    
         
            +
                        readonly internalType: "bytes";
         
     | 
| 
      
 8890 
     | 
    
         
            +
                        readonly type: "bytes";
         
     | 
| 
      
 8891 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8892 
     | 
    
         
            +
                    readonly name: "upgradeToAndCall";
         
     | 
| 
      
 8893 
     | 
    
         
            +
                    readonly outputs: readonly [];
         
     | 
| 
      
 8894 
     | 
    
         
            +
                    readonly stateMutability: "payable";
         
     | 
| 
      
 8895 
     | 
    
         
            +
                }, {
         
     | 
| 
      
 8896 
     | 
    
         
            +
                    readonly type: "function";
         
     | 
| 
      
 8897 
     | 
    
         
            +
                    readonly inputs: readonly [{
         
     | 
| 
      
 8898 
     | 
    
         
            +
                        readonly name: "childIpId";
         
     | 
| 
      
 8899 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8900 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8901 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8902 
     | 
    
         
            +
                        readonly name: "childIpOwner";
         
     | 
| 
      
 8903 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8904 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8905 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8906 
     | 
    
         
            +
                        readonly name: "tokenIds";
         
     | 
| 
      
 8907 
     | 
    
         
            +
                        readonly internalType: "uint256[]";
         
     | 
| 
      
 8908 
     | 
    
         
            +
                        readonly type: "uint256[]";
         
     | 
| 
      
 8909 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8910 
     | 
    
         
            +
                    readonly name: "validateLicenseTokensForDerivative";
         
     | 
| 
      
 8911 
     | 
    
         
            +
                    readonly outputs: readonly [{
         
     | 
| 
      
 8912 
     | 
    
         
            +
                        readonly name: "licenseTemplate";
         
     | 
| 
      
 8913 
     | 
    
         
            +
                        readonly internalType: "address";
         
     | 
| 
      
 8914 
     | 
    
         
            +
                        readonly type: "address";
         
     | 
| 
      
 8915 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8916 
     | 
    
         
            +
                        readonly name: "licensorIpIds";
         
     | 
| 
      
 8917 
     | 
    
         
            +
                        readonly internalType: "address[]";
         
     | 
| 
      
 8918 
     | 
    
         
            +
                        readonly type: "address[]";
         
     | 
| 
      
 8919 
     | 
    
         
            +
                    }, {
         
     | 
| 
      
 8920 
     | 
    
         
            +
                        readonly name: "licenseTermsIds";
         
     | 
| 
      
 8921 
     | 
    
         
            +
                        readonly internalType: "uint256[]";
         
     | 
| 
      
 8922 
     | 
    
         
            +
                        readonly type: "uint256[]";
         
     | 
| 
      
 8923 
     | 
    
         
            +
                    }];
         
     | 
| 
      
 8924 
     | 
    
         
            +
                    readonly stateMutability: "view";
         
     | 
| 
      
 8925 
     | 
    
         
            +
                }];
         
     | 
| 
      
 8926 
     | 
    
         
            +
            };
         
     | 
| 
       7096 
8927 
     | 
    
         
             
            /**
         
     | 
| 
       7097 
8928 
     | 
    
         
             
             *
         
     | 
| 
       7098 
8929 
     | 
    
         
             
             */
         
     | 
| 
         @@ -12665,6 +14496,18 @@ export declare class IpAssetRegistryClient extends IpAssetRegistryReadOnlyClient 
     | 
|
| 
       12665 
14496 
     | 
    
         
             
                 */
         
     | 
| 
       12666 
14497 
     | 
    
         
             
                register(request: IpAssetRegistryRegisterRequest): Promise<WriteContractReturnType>;
         
     | 
| 
       12667 
14498 
     | 
    
         
             
            }
         
     | 
| 
      
 14499 
     | 
    
         
            +
            /**
         
     | 
| 
      
 14500 
     | 
    
         
            +
             * IpRoyaltyVaultImplRevenueTokenClaimedEvent
         
     | 
| 
      
 14501 
     | 
    
         
            +
             *
         
     | 
| 
      
 14502 
     | 
    
         
            +
             * @param claimer address
         
     | 
| 
      
 14503 
     | 
    
         
            +
             * @param token address
         
     | 
| 
      
 14504 
     | 
    
         
            +
             * @param amount uint256
         
     | 
| 
      
 14505 
     | 
    
         
            +
             */
         
     | 
| 
      
 14506 
     | 
    
         
            +
            export type IpRoyaltyVaultImplRevenueTokenClaimedEvent = {
         
     | 
| 
      
 14507 
     | 
    
         
            +
                claimer: Address;
         
     | 
| 
      
 14508 
     | 
    
         
            +
                token: Address;
         
     | 
| 
      
 14509 
     | 
    
         
            +
                amount: bigint;
         
     | 
| 
      
 14510 
     | 
    
         
            +
            };
         
     | 
| 
       12668 
14511 
     | 
    
         
             
            /**
         
     | 
| 
       12669 
14512 
     | 
    
         
             
             * IpRoyaltyVaultImplRoyaltyTokensCollectedEvent
         
     | 
| 
       12670 
14513 
     | 
    
         
             
             *
         
     | 
| 
         @@ -12736,6 +14579,14 @@ export declare class IpRoyaltyVaultImplEventClient { 
     | 
|
| 
       12736 
14579 
     | 
    
         
             
                protected readonly rpcClient: PublicClient;
         
     | 
| 
       12737 
14580 
     | 
    
         
             
                readonly address: Address;
         
     | 
| 
       12738 
14581 
     | 
    
         
             
                constructor(rpcClient: PublicClient, address?: Address);
         
     | 
| 
      
 14582 
     | 
    
         
            +
                /**
         
     | 
| 
      
 14583 
     | 
    
         
            +
                 * event RevenueTokenClaimed for contract IpRoyaltyVaultImpl
         
     | 
| 
      
 14584 
     | 
    
         
            +
                 */
         
     | 
| 
      
 14585 
     | 
    
         
            +
                watchRevenueTokenClaimedEvent(onLogs: (txHash: Hex, ev: Partial<IpRoyaltyVaultImplRevenueTokenClaimedEvent>) => void): WatchContractEventReturnType;
         
     | 
| 
      
 14586 
     | 
    
         
            +
                /**
         
     | 
| 
      
 14587 
     | 
    
         
            +
                 * parse tx receipt event RevenueTokenClaimed for contract IpRoyaltyVaultImpl
         
     | 
| 
      
 14588 
     | 
    
         
            +
                 */
         
     | 
| 
      
 14589 
     | 
    
         
            +
                parseTxRevenueTokenClaimedEvent(txReceipt: TransactionReceipt): Array<IpRoyaltyVaultImplRevenueTokenClaimedEvent>;
         
     | 
| 
       12739 
14590 
     | 
    
         
             
                /**
         
     | 
| 
       12740 
14591 
     | 
    
         
             
                 * event RoyaltyTokensCollected for contract IpRoyaltyVaultImpl
         
     | 
| 
       12741 
14592 
     | 
    
         
             
                 */
         
     | 
| 
         @@ -13517,6 +15368,30 @@ export declare class LicenseRegistryClient extends LicenseRegistryReadOnlyClient 
     | 
|
| 
       13517 
15368 
     | 
    
         
             
                 */
         
     | 
| 
       13518 
15369 
     | 
    
         
             
                upgradeToAndCall(request: LicenseRegistryUpgradeToAndCallRequest): Promise<WriteContractReturnType>;
         
     | 
| 
       13519 
15370 
     | 
    
         
             
            }
         
     | 
| 
      
 15371 
     | 
    
         
            +
            /**
         
     | 
| 
      
 15372 
     | 
    
         
            +
             * LicenseTokenOwnerOfRequest
         
     | 
| 
      
 15373 
     | 
    
         
            +
             *
         
     | 
| 
      
 15374 
     | 
    
         
            +
             * @param tokenId uint256
         
     | 
| 
      
 15375 
     | 
    
         
            +
             */
         
     | 
| 
      
 15376 
     | 
    
         
            +
            export type LicenseTokenOwnerOfRequest = {
         
     | 
| 
      
 15377 
     | 
    
         
            +
                tokenId: bigint;
         
     | 
| 
      
 15378 
     | 
    
         
            +
            };
         
     | 
| 
      
 15379 
     | 
    
         
            +
            export type LicenseTokenOwnerOfResponse = Address;
         
     | 
| 
      
 15380 
     | 
    
         
            +
            /**
         
     | 
| 
      
 15381 
     | 
    
         
            +
             * contract LicenseToken readonly method
         
     | 
| 
      
 15382 
     | 
    
         
            +
             */
         
     | 
| 
      
 15383 
     | 
    
         
            +
            export declare class LicenseTokenReadOnlyClient {
         
     | 
| 
      
 15384 
     | 
    
         
            +
                protected readonly rpcClient: PublicClient;
         
     | 
| 
      
 15385 
     | 
    
         
            +
                readonly address: Address;
         
     | 
| 
      
 15386 
     | 
    
         
            +
                constructor(rpcClient: PublicClient, address?: Address);
         
     | 
| 
      
 15387 
     | 
    
         
            +
                /**
         
     | 
| 
      
 15388 
     | 
    
         
            +
                 * method ownerOf for contract LicenseToken
         
     | 
| 
      
 15389 
     | 
    
         
            +
                 *
         
     | 
| 
      
 15390 
     | 
    
         
            +
                 * @param request LicenseTokenOwnerOfRequest
         
     | 
| 
      
 15391 
     | 
    
         
            +
                 * @return Promise<LicenseTokenOwnerOfResponse>
         
     | 
| 
      
 15392 
     | 
    
         
            +
                 */
         
     | 
| 
      
 15393 
     | 
    
         
            +
                ownerOf(request: LicenseTokenOwnerOfRequest): Promise<LicenseTokenOwnerOfResponse>;
         
     | 
| 
      
 15394 
     | 
    
         
            +
            }
         
     | 
| 
       13520 
15395 
     | 
    
         
             
            /**
         
     | 
| 
       13521 
15396 
     | 
    
         
             
             * LicensingModuleLicenseTokensMintedEvent
         
     | 
| 
       13522 
15397 
     | 
    
         
             
             *
         
     |