@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.10

package/dist/cjs/generated/DefaultReverseResolver.d.ts

@@ -0,0 +1,66 @@
+import type { BaseContract, BigNumber, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export interface DefaultReverseResolverInterface extends utils.Interface {
+    functions: {
+        "ens()": FunctionFragment;
+        "name(bytes32)": FunctionFragment;
+        "setName(bytes32,string)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "ens" | "name" | "setName"): FunctionFragment;
+    encodeFunctionData(functionFragment: "ens", values?: undefined): string;
+    encodeFunctionData(functionFragment: "name", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "setName", values: [BytesLike, string]): string;
+    decodeFunctionResult(functionFragment: "ens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setName", data: BytesLike): Result;
+    events: {};
+}
+export interface DefaultReverseResolver extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: DefaultReverseResolverInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        ens(overrides?: CallOverrides): Promise<[string]>;
+        name(arg0: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        setName(node: BytesLike, _name: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+    };
+    ens(overrides?: CallOverrides): Promise<string>;
+    name(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+    setName(node: BytesLike, _name: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        ens(overrides?: CallOverrides): Promise<string>;
+        name(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+        setName(node: BytesLike, _name: string, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        ens(overrides?: CallOverrides): Promise<BigNumber>;
+        name(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        setName(node: BytesLike, _name: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        ens(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        name(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setName(node: BytesLike, _name: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/cjs/generated/DefaultReverseResolver.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/generated/DoNotCallOnChainUniversalResolverProxy.d.ts

@@ -0,0 +1,144 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export declare namespace DoNotCallOnChainUniversalResolverProxy {
+    type ReverseCallStruct = {
+        target: string;
+        data: BytesLike;
+        dataType: BigNumberish;
+        locations: BigNumberish[];
+    };
+    type ReverseCallStructOutput = [
+        string,
+        string,
+        number,
+        BigNumber[]
+    ] & {
+        target: string;
+        data: string;
+        dataType: number;
+        locations: BigNumber[];
+    };
+}
+export interface DoNotCallOnChainUniversalResolverProxyInterface extends utils.Interface {
+    functions: {
+        "isOwner(address)": FunctionFragment;
+        "owner()": FunctionFragment;
+        "reverse(bytes,(address,bytes,uint8,uint256[])[])": FunctionFragment;
+        "setUniversalResolver(address)": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+        "universalResolver()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "isOwner" | "owner" | "reverse" | "setUniversalResolver" | "transferOwnership" | "universalResolver"): FunctionFragment;
+    encodeFunctionData(functionFragment: "isOwner", values: [string]): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "reverse", values: [
+        BytesLike,
+        DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[]
+    ]): string;
+    encodeFunctionData(functionFragment: "setUniversalResolver", values: [string]): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
+    encodeFunctionData(functionFragment: "universalResolver", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "isOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "reverse", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setUniversalResolver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "universalResolver", data: BytesLike): Result;
+    events: {
+        "OwnershipTransferred(address,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+}
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export declare type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export declare type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface DoNotCallOnChainUniversalResolverProxy extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: DoNotCallOnChainUniversalResolverProxyInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        isOwner(addr: string, overrides?: CallOverrides): Promise<[boolean]>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<[string, string[]] & {
+            name: string;
+            returnData: string[];
+        }>;
+        setUniversalResolver(newUniversalResolver: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        universalResolver(overrides?: CallOverrides): Promise<[string]>;
+    };
+    isOwner(addr: string, overrides?: CallOverrides): Promise<boolean>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<[string, string[]] & {
+        name: string;
+        returnData: string[];
+    }>;
+    setUniversalResolver(newUniversalResolver: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    transferOwnership(newOwner: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    universalResolver(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        isOwner(addr: string, overrides?: CallOverrides): Promise<boolean>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<[string, string[]] & {
+            name: string;
+            returnData: string[];
+        }>;
+        setUniversalResolver(newUniversalResolver: string, overrides?: CallOverrides): Promise<void>;
+        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
+        universalResolver(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
+    };
+    estimateGas: {
+        isOwner(addr: string, overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<BigNumber>;
+        setUniversalResolver(newUniversalResolver: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        universalResolver(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        isOwner(addr: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setUniversalResolver(newUniversalResolver: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        universalResolver(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/cjs/generated/DoNotCallOnChainUniversalResolverProxy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/generated/ENSRegistry.d.ts

@@ -0,0 +1,259 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export interface ENSRegistryInterface extends utils.Interface {
+    functions: {
+        "isApprovedForAll(address,address)": FunctionFragment;
+        "old()": FunctionFragment;
+        "owner(bytes32)": FunctionFragment;
+        "recordExists(bytes32)": FunctionFragment;
+        "resolver(bytes32)": FunctionFragment;
+        "setApprovalForAll(address,bool)": FunctionFragment;
+        "setOwner(bytes32,address)": FunctionFragment;
+        "setRecord(bytes32,address,address,uint64)": FunctionFragment;
+        "setResolver(bytes32,address)": FunctionFragment;
+        "setSubnodeOwner(bytes32,bytes32,address)": FunctionFragment;
+        "setSubnodeRecord(bytes32,bytes32,address,address,uint64)": FunctionFragment;
+        "setTTL(bytes32,uint64)": FunctionFragment;
+        "ttl(bytes32)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "isApprovedForAll" | "old" | "owner" | "recordExists" | "resolver" | "setApprovalForAll" | "setOwner" | "setRecord" | "setResolver" | "setSubnodeOwner" | "setSubnodeRecord" | "setTTL" | "ttl"): FunctionFragment;
+    encodeFunctionData(functionFragment: "isApprovedForAll", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "old", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "recordExists", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "resolver", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "setApprovalForAll", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "setOwner", values: [BytesLike, string]): string;
+    encodeFunctionData(functionFragment: "setRecord", values: [BytesLike, string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setResolver", values: [BytesLike, string]): string;
+    encodeFunctionData(functionFragment: "setSubnodeOwner", values: [BytesLike, BytesLike, string]): string;
+    encodeFunctionData(functionFragment: "setSubnodeRecord", values: [BytesLike, BytesLike, string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setTTL", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "ttl", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "isApprovedForAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "old", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recordExists", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resolver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setApprovalForAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setRecord", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setResolver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setSubnodeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setSubnodeRecord", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTTL", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ttl", data: BytesLike): Result;
+    events: {
+        "ApprovalForAll(address,address,bool)": EventFragment;
+        "NewOwner(bytes32,bytes32,address)": EventFragment;
+        "NewResolver(bytes32,address)": EventFragment;
+        "NewTTL(bytes32,uint64)": EventFragment;
+        "Transfer(bytes32,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "NewOwner"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "NewResolver"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "NewTTL"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+}
+export interface ApprovalForAllEventObject {
+    owner: string;
+    operator: string;
+    approved: boolean;
+}
+export declare type ApprovalForAllEvent = TypedEvent<[
+    string,
+    string,
+    boolean
+], ApprovalForAllEventObject>;
+export declare type ApprovalForAllEventFilter = TypedEventFilter<ApprovalForAllEvent>;
+export interface NewOwnerEventObject {
+    node: string;
+    label: string;
+    owner: string;
+}
+export declare type NewOwnerEvent = TypedEvent<[
+    string,
+    string,
+    string
+], NewOwnerEventObject>;
+export declare type NewOwnerEventFilter = TypedEventFilter<NewOwnerEvent>;
+export interface NewResolverEventObject {
+    node: string;
+    resolver: string;
+}
+export declare type NewResolverEvent = TypedEvent<[
+    string,
+    string
+], NewResolverEventObject>;
+export declare type NewResolverEventFilter = TypedEventFilter<NewResolverEvent>;
+export interface NewTTLEventObject {
+    node: string;
+    ttl: BigNumber;
+}
+export declare type NewTTLEvent = TypedEvent<[string, BigNumber], NewTTLEventObject>;
+export declare type NewTTLEventFilter = TypedEventFilter<NewTTLEvent>;
+export interface TransferEventObject {
+    node: string;
+    owner: string;
+}
+export declare type TransferEvent = TypedEvent<[string, string], TransferEventObject>;
+export declare type TransferEventFilter = TypedEventFilter<TransferEvent>;
+export interface ENSRegistry extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: ENSRegistryInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        isApprovedForAll(owner: string, operator: string, overrides?: CallOverrides): Promise<[boolean]>;
+        old(overrides?: CallOverrides): Promise<[string]>;
+        owner(node: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        recordExists(node: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;
+        resolver(node: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        setOwner(node: BytesLike, owner: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        setRecord(node: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        setResolver(node: BytesLike, resolver: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        setSubnodeOwner(node: BytesLike, label: BytesLike, owner: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        setSubnodeRecord(node: BytesLike, label: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        setTTL(node: BytesLike, ttl: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        ttl(node: BytesLike, overrides?: CallOverrides): Promise<[BigNumber]>;
+    };
+    isApprovedForAll(owner: string, operator: string, overrides?: CallOverrides): Promise<boolean>;
+    old(overrides?: CallOverrides): Promise<string>;
+    owner(node: BytesLike, overrides?: CallOverrides): Promise<string>;
+    recordExists(node: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+    resolver(node: BytesLike, overrides?: CallOverrides): Promise<string>;
+    setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    setOwner(node: BytesLike, owner: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    setRecord(node: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    setResolver(node: BytesLike, resolver: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    setSubnodeOwner(node: BytesLike, label: BytesLike, owner: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    setSubnodeRecord(node: BytesLike, label: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    setTTL(node: BytesLike, ttl: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    ttl(node: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+    callStatic: {
+        isApprovedForAll(owner: string, operator: string, overrides?: CallOverrides): Promise<boolean>;
+        old(overrides?: CallOverrides): Promise<string>;
+        owner(node: BytesLike, overrides?: CallOverrides): Promise<string>;
+        recordExists(node: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+        resolver(node: BytesLike, overrides?: CallOverrides): Promise<string>;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: CallOverrides): Promise<void>;
+        setOwner(node: BytesLike, owner: string, overrides?: CallOverrides): Promise<void>;
+        setRecord(node: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        setResolver(node: BytesLike, resolver: string, overrides?: CallOverrides): Promise<void>;
+        setSubnodeOwner(node: BytesLike, label: BytesLike, owner: string, overrides?: CallOverrides): Promise<string>;
+        setSubnodeRecord(node: BytesLike, label: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        setTTL(node: BytesLike, ttl: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        ttl(node: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {
+        "ApprovalForAll(address,address,bool)"(owner?: string | null, operator?: string | null, approved?: null): ApprovalForAllEventFilter;
+        ApprovalForAll(owner?: string | null, operator?: string | null, approved?: null): ApprovalForAllEventFilter;
+        "NewOwner(bytes32,bytes32,address)"(node?: BytesLike | null, label?: BytesLike | null, owner?: null): NewOwnerEventFilter;
+        NewOwner(node?: BytesLike | null, label?: BytesLike | null, owner?: null): NewOwnerEventFilter;
+        "NewResolver(bytes32,address)"(node?: BytesLike | null, resolver?: null): NewResolverEventFilter;
+        NewResolver(node?: BytesLike | null, resolver?: null): NewResolverEventFilter;
+        "NewTTL(bytes32,uint64)"(node?: BytesLike | null, ttl?: null): NewTTLEventFilter;
+        NewTTL(node?: BytesLike | null, ttl?: null): NewTTLEventFilter;
+        "Transfer(bytes32,address)"(node?: BytesLike | null, owner?: null): TransferEventFilter;
+        Transfer(node?: BytesLike | null, owner?: null): TransferEventFilter;
+    };
+    estimateGas: {
+        isApprovedForAll(owner: string, operator: string, overrides?: CallOverrides): Promise<BigNumber>;
+        old(overrides?: CallOverrides): Promise<BigNumber>;
+        owner(node: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        recordExists(node: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        resolver(node: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        setOwner(node: BytesLike, owner: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        setRecord(node: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        setResolver(node: BytesLike, resolver: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        setSubnodeOwner(node: BytesLike, label: BytesLike, owner: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        setSubnodeRecord(node: BytesLike, label: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        setTTL(node: BytesLike, ttl: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        ttl(node: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        isApprovedForAll(owner: string, operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        old(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(node: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recordExists(node: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        resolver(node: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        setOwner(node: BytesLike, owner: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        setRecord(node: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        setResolver(node: BytesLike, resolver: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        setSubnodeOwner(node: BytesLike, label: BytesLike, owner: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        setSubnodeRecord(node: BytesLike, label: BytesLike, owner: string, resolver: string, ttl: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        setTTL(node: BytesLike, ttl: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        ttl(node: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/cjs/generated/ENSRegistry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });