televerse-dao-typechain-types 1.0.5 → 1.0.6-alpha.2

package/typechain-types/factories/@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata__factory.d.ts

@@ -0,0 +1,261 @@
+import { type ContractRunner } from "ethers";
+import type { IERC721Metadata, IERC721MetadataInterface } from "../../../../../../@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata";
+export declare class IERC721Metadata__factory {
+    static readonly abi: readonly [{
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "approved";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "uint256";
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }];
+        readonly name: "Approval";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "operator";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "bool";
+            readonly name: "approved";
+            readonly type: "bool";
+        }];
+        readonly name: "ApprovalForAll";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "uint256";
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }];
+        readonly name: "Transfer";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }];
+        readonly name: "approve";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }];
+        readonly name: "balanceOf";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "balance";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }];
+        readonly name: "getApproved";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "operator";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "operator";
+            readonly type: "address";
+        }];
+        readonly name: "isApprovedForAll";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "name";
+        readonly outputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "";
+            readonly type: "string";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }];
+        readonly name: "ownerOf";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }];
+        readonly name: "safeTransferFrom";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly name: "safeTransferFrom";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "operator";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "approved";
+            readonly type: "bool";
+        }];
+        readonly name: "setApprovalForAll";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "interfaceId";
+            readonly type: "bytes4";
+        }];
+        readonly name: "supportsInterface";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "symbol";
+        readonly outputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "";
+            readonly type: "string";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }];
+        readonly name: "tokenURI";
+        readonly outputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "";
+            readonly type: "string";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }];
+        readonly name: "transferFrom";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }];
+    static createInterface(): IERC721MetadataInterface;
+    static connect(address: string, runner?: ContractRunner | null): IERC721Metadata;
+}

package/typechain-types/factories/@openzeppelin/contracts/token/ERC721/extensions/index.d.ts

@@ -0,0 +1,6 @@
+export { ERC721Burnable__factory } from "./ERC721Burnable__factory";
+export { ERC721Enumerable__factory } from "./ERC721Enumerable__factory";
+export { ERC721Pausable__factory } from "./ERC721Pausable__factory";
+export { ERC721URIStorage__factory } from "./ERC721URIStorage__factory";
+export { IERC721Enumerable__factory } from "./IERC721Enumerable__factory";
+export { IERC721Metadata__factory } from "./IERC721Metadata__factory";

package/typechain-types/factories/@openzeppelin/contracts/token/ERC721/index.d.ts

@@ -0,0 +1,5 @@
+export * as extensions from "./extensions";
+export * as utils from "./utils";
+export { ERC721__factory } from "./ERC721__factory";
+export { IERC721__factory } from "./IERC721__factory";
+export { IERC721Receiver__factory } from "./IERC721Receiver__factory";

package/typechain-types/factories/@openzeppelin/contracts/token/ERC721/utils/ERC721Holder__factory.d.ts

@@ -0,0 +1,33 @@
+import { type ContractRunner } from "ethers";
+import type { ERC721Holder, ERC721HolderInterface } from "../../../../../../@openzeppelin/contracts/token/ERC721/utils/ERC721Holder";
+export declare class ERC721Holder__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "";
+            readonly type: "bytes";
+        }];
+        readonly name: "onERC721Received";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "";
+            readonly type: "bytes4";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }];
+    static createInterface(): ERC721HolderInterface;
+    static connect(address: string, runner?: ContractRunner | null): ERC721Holder;
+}

package/typechain-types/factories/@openzeppelin/contracts/token/ERC721/utils/index.d.ts

@@ -0,0 +1 @@
+export { ERC721Holder__factory } from "./ERC721Holder__factory";

package/typechain-types/factories/@openzeppelin/contracts/token/index.d.ts

@@ -0,0 +1,3 @@
+export * as erc1155 from "./ERC1155";
+export * as erc20 from "./ERC20";
+export * as erc721 from "./ERC721";

package/typechain-types/factories/@openzeppelin/contracts/utils/Address__factory.d.ts

@@ -0,0 +1,42 @@
+import { ContractFactory, ContractTransactionResponse } from "ethers";
+import type { Signer, ContractDeployTransaction, ContractRunner } from "ethers";
+import type { NonPayableOverrides } from "../../../../common";
+import type { Address, AddressInterface } from "../../../../@openzeppelin/contracts/utils/Address";
+type AddressConstructorParams = [signer?: Signer] | ConstructorParameters<typeof ContractFactory>;
+export declare class Address__factory extends ContractFactory {
+    constructor(...args: AddressConstructorParams);
+    getDeployTransaction(overrides?: NonPayableOverrides & {
+        from?: string;
+    }): Promise<ContractDeployTransaction>;
+    deploy(overrides?: NonPayableOverrides & {
+        from?: string;
+    }): Promise<Address & {
+        deploymentTransaction(): ContractTransactionResponse;
+    }>;
+    connect(runner: ContractRunner | null): Address__factory;
+    static readonly bytecode = "0x60808060405234601757603a9081601d823930815050f35b600080fdfe600080fdfea2646970667358221220b456ea1dd0696c499ee97184ece1f3b9257372aa154e356e85b471d0613ddb6b64736f6c63430008140033";
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }];
+        readonly name: "AddressEmptyCode";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "AddressInsufficientBalance";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "FailedInnerCall";
+        readonly type: "error";
+    }];
+    static createInterface(): AddressInterface;
+    static connect(address: string, runner?: ContractRunner | null): Address;
+}
+export {};

package/typechain-types/factories/@openzeppelin/contracts/utils/Nonces__factory.d.ts

@@ -0,0 +1,33 @@
+import { type ContractRunner } from "ethers";
+import type { Nonces, NoncesInterface } from "../../../../@openzeppelin/contracts/utils/Nonces";
+export declare class Nonces__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "currentNonce";
+            readonly type: "uint256";
+        }];
+        readonly name: "InvalidAccountNonce";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }];
+        readonly name: "nonces";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    static createInterface(): NoncesInterface;
+    static connect(address: string, runner?: ContractRunner | null): Nonces;
+}

package/typechain-types/factories/@openzeppelin/contracts/utils/Pausable__factory.d.ts

@@ -0,0 +1,45 @@
+import { type ContractRunner } from "ethers";
+import type { Pausable, PausableInterface } from "../../../../@openzeppelin/contracts/utils/Pausable";
+export declare class Pausable__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [];
+        readonly name: "EnforcedPause";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "ExpectedPause";
+        readonly type: "error";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: false;
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "Paused";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: false;
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "Unpaused";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "paused";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    static createInterface(): PausableInterface;
+    static connect(address: string, runner?: ContractRunner | null): Pausable;
+}

package/typechain-types/factories/@openzeppelin/contracts/utils/ReentrancyGuard__factory.d.ts

@@ -0,0 +1,11 @@
+import { type ContractRunner } from "ethers";
+import type { ReentrancyGuard, ReentrancyGuardInterface } from "../../../../@openzeppelin/contracts/utils/ReentrancyGuard";
+export declare class ReentrancyGuard__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [];
+        readonly name: "ReentrancyGuardReentrantCall";
+        readonly type: "error";
+    }];
+    static createInterface(): ReentrancyGuardInterface;
+    static connect(address: string, runner?: ContractRunner | null): ReentrancyGuard;
+}

package/typechain-types/factories/@openzeppelin/contracts/utils/ShortStrings__factory.d.ts

@@ -0,0 +1,34 @@
+import { ContractFactory, ContractTransactionResponse } from "ethers";
+import type { Signer, ContractDeployTransaction, ContractRunner } from "ethers";
+import type { NonPayableOverrides } from "../../../../common";
+import type { ShortStrings, ShortStringsInterface } from "../../../../@openzeppelin/contracts/utils/ShortStrings";
+type ShortStringsConstructorParams = [signer?: Signer] | ConstructorParameters<typeof ContractFactory>;
+export declare class ShortStrings__factory extends ContractFactory {
+    constructor(...args: ShortStringsConstructorParams);
+    getDeployTransaction(overrides?: NonPayableOverrides & {
+        from?: string;
+    }): Promise<ContractDeployTransaction>;
+    deploy(overrides?: NonPayableOverrides & {
+        from?: string;
+    }): Promise<ShortStrings & {
+        deploymentTransaction(): ContractTransactionResponse;
+    }>;
+    connect(runner: ContractRunner | null): ShortStrings__factory;
+    static readonly bytecode = "0x60808060405234601757603a9081601d823930815050f35b600080fdfe600080fdfea26469706673582212204142a79a183a5e2235ce28d53b0416d794ece90937565826428ee8fff8d53fab64736f6c63430008140033";
+    static readonly abi: readonly [{
+        readonly inputs: readonly [];
+        readonly name: "InvalidShortString";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "str";
+            readonly type: "string";
+        }];
+        readonly name: "StringTooLong";
+        readonly type: "error";
+    }];
+    static createInterface(): ShortStringsInterface;
+    static connect(address: string, runner?: ContractRunner | null): ShortStrings;
+}
+export {};

package/typechain-types/factories/@openzeppelin/contracts/utils/Strings__factory.d.ts

@@ -0,0 +1,34 @@
+import { ContractFactory, ContractTransactionResponse } from "ethers";
+import type { Signer, ContractDeployTransaction, ContractRunner } from "ethers";
+import type { NonPayableOverrides } from "../../../../common";
+import type { Strings, StringsInterface } from "../../../../@openzeppelin/contracts/utils/Strings";
+type StringsConstructorParams = [signer?: Signer] | ConstructorParameters<typeof ContractFactory>;
+export declare class Strings__factory extends ContractFactory {
+    constructor(...args: StringsConstructorParams);
+    getDeployTransaction(overrides?: NonPayableOverrides & {
+        from?: string;
+    }): Promise<ContractDeployTransaction>;
+    deploy(overrides?: NonPayableOverrides & {
+        from?: string;
+    }): Promise<Strings & {
+        deploymentTransaction(): ContractTransactionResponse;
+    }>;
+    connect(runner: ContractRunner | null): Strings__factory;
+    static readonly bytecode = "0x60808060405234601757603a9081601d823930815050f35b600080fdfe600080fdfea2646970667358221220c8bdbc4a255ae0f53c6a5944e7525adbce75a57e972e2459d67903feae388e2e64736f6c63430008140033";
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "length";
+            readonly type: "uint256";
+        }];
+        readonly name: "StringsInsufficientHexLength";
+        readonly type: "error";
+    }];
+    static createInterface(): StringsInterface;
+    static connect(address: string, runner?: ContractRunner | null): Strings;
+}
+export {};

package/typechain-types/factories/@openzeppelin/contracts/utils/cryptography/ECDSA__factory.d.ts

@@ -0,0 +1,42 @@
+import { ContractFactory, ContractTransactionResponse } from "ethers";
+import type { Signer, ContractDeployTransaction, ContractRunner } from "ethers";
+import type { NonPayableOverrides } from "../../../../../common";
+import type { ECDSA, ECDSAInterface } from "../../../../../@openzeppelin/contracts/utils/cryptography/ECDSA";
+type ECDSAConstructorParams = [signer?: Signer] | ConstructorParameters<typeof ContractFactory>;
+export declare class ECDSA__factory extends ContractFactory {
+    constructor(...args: ECDSAConstructorParams);
+    getDeployTransaction(overrides?: NonPayableOverrides & {
+        from?: string;
+    }): Promise<ContractDeployTransaction>;
+    deploy(overrides?: NonPayableOverrides & {
+        from?: string;
+    }): Promise<ECDSA & {
+        deploymentTransaction(): ContractTransactionResponse;
+    }>;
+    connect(runner: ContractRunner | null): ECDSA__factory;
+    static readonly bytecode = "0x60808060405234601757603a9081601d823930815050f35b600080fdfe600080fdfea264697066735822122080bf14de2fa251a8ec728f0c343fd248a1e7999a4bd5b67a8cccf52ab65b382764736f6c63430008140033";
+    static readonly abi: readonly [{
+        readonly inputs: readonly [];
+        readonly name: "ECDSAInvalidSignature";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "length";
+            readonly type: "uint256";
+        }];
+        readonly name: "ECDSAInvalidSignatureLength";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "s";
+            readonly type: "bytes32";
+        }];
+        readonly name: "ECDSAInvalidSignatureS";
+        readonly type: "error";
+    }];
+    static createInterface(): ECDSAInterface;
+    static connect(address: string, runner?: ContractRunner | null): ECDSA;
+}
+export {};

package/typechain-types/factories/@openzeppelin/contracts/utils/cryptography/EIP712__factory.d.ts

@@ -0,0 +1,58 @@
+import { type ContractRunner } from "ethers";
+import type { EIP712, EIP712Interface } from "../../../../../@openzeppelin/contracts/utils/cryptography/EIP712";
+export declare class EIP712__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [];
+        readonly name: "InvalidShortString";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "str";
+            readonly type: "string";
+        }];
+        readonly name: "StringTooLong";
+        readonly type: "error";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [];
+        readonly name: "EIP712DomainChanged";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "eip712Domain";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes1";
+            readonly name: "fields";
+            readonly type: "bytes1";
+        }, {
+            readonly internalType: "string";
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly internalType: "string";
+            readonly name: "version";
+            readonly type: "string";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "verifyingContract";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "salt";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "extensions";
+            readonly type: "uint256[]";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    static createInterface(): EIP712Interface;
+    static connect(address: string, runner?: ContractRunner | null): EIP712;
+}

package/typechain-types/factories/@openzeppelin/contracts/utils/cryptography/index.d.ts

@@ -0,0 +1,2 @@
+export { ECDSA__factory } from "./ECDSA__factory";
+export { EIP712__factory } from "./EIP712__factory";

package/typechain-types/factories/@openzeppelin/contracts/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * as cryptography from "./cryptography";
+export * as introspection from "./introspection";
+export * as math from "./math";
+export * as structs from "./structs";
+export { Address__factory } from "./Address__factory";
+export { Nonces__factory } from "./Nonces__factory";
+export { Pausable__factory } from "./Pausable__factory";
+export { ReentrancyGuard__factory } from "./ReentrancyGuard__factory";
+export { ShortStrings__factory } from "./ShortStrings__factory";
+export { Strings__factory } from "./Strings__factory";

package/typechain-types/factories/@openzeppelin/contracts/utils/introspection/ERC165__factory.d.ts

@@ -0,0 +1,21 @@
+import { type ContractRunner } from "ethers";
+import type { ERC165, ERC165Interface } from "../../../../../@openzeppelin/contracts/utils/introspection/ERC165";
+export declare class ERC165__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "interfaceId";
+            readonly type: "bytes4";
+        }];
+        readonly name: "supportsInterface";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    static createInterface(): ERC165Interface;
+    static connect(address: string, runner?: ContractRunner | null): ERC165;
+}