@ensdomains/ensjs 3.0.0-alpha.4 → 3.0.0-alpha.41

package/dist/types/index.d.ts

@@ -0,0 +1,553 @@
+import { ContractTransaction, PopulatedTransaction } from '@ethersproject/contracts';
+import type { JsonRpcProvider, JsonRpcSigner, Provider } from '@ethersproject/providers';
+import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
+import ContractManager from './contracts/index';
+import { SupportedNetworkId } from './contracts/types';
+import GqlManager from './GqlManager';
+export type { Fuse, FuseArrayPossibilities, FuseObj, NamedFusesToBurn, UnnamedFuseType, UnnamedFuseValues, } from './utils/fuses';
+declare type ENSOptions = {
+    graphURI?: string | null;
+    getContractAddress?: typeof _getContractAddress;
+};
+export declare type InternalENS = {
+    options?: ENSOptions;
+    provider?: Provider;
+    signer: JsonRpcSigner;
+    graphURI?: string | null;
+} & ENS;
+export declare type ENSArgs<K extends keyof InternalENS> = {
+    [P in K]: InternalENS[P];
+};
+declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
+declare type OmitFirstTwoArgs<F> = F extends (x: any, y: any, ...args: infer P) => infer R ? (...args: P) => R : never;
+declare type FirstArg<F> = F extends (x: infer A, ...args: any[]) => any ? A : never;
+declare type FunctionDeps<F> = Extract<keyof FirstArg<F>, string>[];
+declare type WriteOptions = {
+    addressOrIndex?: string | number;
+    signer?: JsonRpcSigner;
+};
+declare type OptionalWriteOptions<F> = F extends (x: any, arg_0: infer Z, options?: infer P) => infer R ? (name: Z, options?: P & WriteOptions) => R : F extends (x: any, arg_0: infer Z, options: infer P) => infer R ? (name: Z, options: P & WriteOptions) => R : never;
+interface WriteFunction<F extends (...args: any) => any> extends Function {
+    (...args: Parameters<OptionalWriteOptions<F>>): Promise<ContractTransaction & {
+        customData?: Record<string, any>;
+    }>;
+    populateTransaction: (...args: Parameters<OptionalWriteOptions<F>>) => Promise<PopulatedTransaction>;
+}
+export declare const graphURIEndpoints: Record<string, string>;
+export declare type RawFunction = {
+    raw: (...args: any[]) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: (...args: any[]) => Promise<any>;
+};
+export declare type BatchFunctionResult<F extends RawFunction> = {
+    args: Parameters<OmitFirstArg<F['raw']>>;
+    raw: F['raw'];
+    decode: F['decode'];
+};
+declare type BatchFunction<F extends RawFunction> = (...args: Parameters<OmitFirstArg<F['raw']>>) => BatchFunctionResult<F>;
+export declare type RawFunctionWithBatch = {
+    batch: BatchFunction<any>;
+} & RawFunction;
+interface GeneratedRawFunction<F extends RawFunction> extends Function, RawFunction {
+    (...args: Parameters<OmitFirstArg<F['raw']>>): ReturnType<OmitFirstTwoArgs<F['decode']>>;
+    batch: BatchFunction<F>;
+}
+export interface GenericGeneratedRawFunction extends Function, RawFunctionWithBatch {
+}
+interface GeneratedBatchFunction<F extends RawFunction> extends Function, RawFunction {
+    <I extends BatchFunctionResult<RawFunction>[]>(...args: I): Promise<{
+        [N in keyof I]: I[N] extends BatchFunctionResult<infer U> ? Awaited<ReturnType<U['decode']>> : never;
+    } | undefined>;
+    batch: BatchFunction<F>;
+}
+export declare type FunctionSubtype = 'raw' | 'decode' | 'combine' | 'batch' | 'write' | 'populateTransaction';
+export declare class ENS {
+    [x: string]: any;
+    protected options?: ENSOptions;
+    protected provider?: JsonRpcProvider;
+    protected graphURI?: string | null;
+    protected initialProvider?: JsonRpcProvider;
+    contracts?: ContractManager;
+    getContractAddress: (networkId: SupportedNetworkId) => import("./contracts/getContractAddress").ContractAddressFetch;
+    gqlInstance: GqlManager;
+    constructor(options?: ENSOptions);
+    /**
+     * Checks for an initial provider and if it exists, sets it as the provider
+     * @returns {Promise<void>} - A promise that resolves when the provider is checked, and set if needed
+     */
+    private checkInitialProvider;
+    /**
+     * Creates an object of ENS properties from an array
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @returns {Object} - An object of ENS properties
+     */
+    protected forwardDependenciesFromArray: <F>(dependencies: FunctionDeps<F>) => object;
+    protected getModule: (path: string, exportName: string) => Promise<any>;
+    protected getFunction: (subFunc: FunctionSubtype | undefined, writeable: boolean | undefined, exportName: string, mod: any, _path: string) => any;
+    /**
+     * Creates a wrapper for a function to be dynamically imported, with the correct dependencies passed in
+     * @param {string} path - The path of the exported function
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @param {string} exportName - The export name of the target function
+     * @param {string} subFunc - The type of function being imported
+     * @returns {Function} - The generated wrapped function
+     */
+    private importGenerator;
+    /**
+     * Generates a normal wrapped function
+     * @param {string} path - The path of the exported function
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @param {string} exportName - The export name of the target function
+     * @returns {OmitFirstArg} - The generated wrapped function
+     */
+    private generateFunction;
+    /**
+     * Generates a write wrapped function
+     * @param {string} path - The path of the exported function
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @param {string} exportName - The export name of the target function
+     * @returns {OmitFirstArg} - The generated wrapped function
+     */
+    private generateWriteFunction;
+    /**
+     * Generates a wrapped function from raw and decode exports
+     * @param {string} path - The path of the exported function
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @param {string} exportName - The export name of the target function
+     * @returns {GeneratedRawFunction} - The generated wrapped function
+     */
+    private generateRawFunction;
+    /**
+     * Sets the provider for the ENS class
+     * @param {JsonRpcProvider} provider - The provider to set
+     * @returns {Promise<void>} - A promise that resolves when the provider is set
+     */
+    setProvider: (provider: JsonRpcProvider) => Promise<void>;
+    /**
+     * Creates a new ENS instance with a different provider, ideally should be used individually with any given function
+     * @param {JsonRpcProvider} provider - The provider to use
+     * @returns {ENS} - A new ENS instance with the given provider
+     */
+    withProvider: (provider: JsonRpcProvider) => ENS;
+    batch: GeneratedBatchFunction<{
+        raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
+    }>;
+    getProfile: (nameOrAddress: string, options?: ({
+        contentHash?: boolean | undefined;
+        texts?: boolean | string[] | undefined;
+        coinTypes?: boolean | string[] | undefined;
+    } & {
+        resolverAddress?: string | undefined;
+        fallback?: {
+            contentHash?: boolean | undefined;
+            texts?: string[] | undefined;
+            coinTypes?: string[] | undefined;
+        } | undefined;
+    }) | undefined) => Promise<{
+        isMigrated: boolean | null;
+        createdAt: string | null;
+        address?: string | undefined;
+        name?: string | null | undefined;
+        match?: boolean | undefined;
+        message?: string | undefined;
+        records?: {
+            contentHash?: string | import("./utils/contentHash").DecodedContentHash | null | undefined;
+            texts?: {
+                key: string | number;
+                type: "text" | "addr" | "contentHash";
+                coin?: string | undefined;
+                value: string;
+            }[] | undefined;
+            coinTypes?: {
+                key: string | number;
+                type: "text" | "addr" | "contentHash";
+                coin?: string | undefined;
+                value: string;
+            }[] | undefined;
+        } | undefined;
+        resolverAddress?: string | undefined;
+        isInvalidResolverAddress?: boolean | undefined;
+        reverseResolverAddress?: string | undefined;
+    } | undefined>;
+    getRecords: (name: string, options?: {
+        contentHash?: boolean | undefined;
+        texts?: boolean | string[] | undefined;
+        coinTypes?: boolean | string[] | undefined;
+        resolverAddress?: string | undefined;
+    } | undefined) => Promise<{
+        isMigrated: boolean | null;
+        createdAt: string | null;
+        address?: string | undefined;
+        name?: string | null | undefined;
+        match?: boolean | undefined;
+        message?: string | undefined;
+        records?: {
+            contentHash?: string | import("./utils/contentHash").DecodedContentHash | null | undefined;
+            texts?: {
+                key: string | number;
+                type: "text" | "addr" | "contentHash";
+                coin?: string | undefined;
+                value: string;
+            }[] | undefined;
+            coinTypes?: {
+                key: string | number;
+                type: "text" | "addr" | "contentHash";
+                coin?: string | undefined;
+                value: string;
+            }[] | undefined;
+        } | undefined;
+        resolverAddress?: string | undefined;
+        isInvalidResolverAddress?: boolean | undefined;
+        reverseResolverAddress?: string | undefined;
+    } | undefined>;
+    getName: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, address: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string, address: string) => Promise<{
+            name: any;
+            match: boolean;
+            reverseResolverAddress: any;
+            resolverAddress: any;
+        } | {
+            name: undefined;
+            match?: undefined;
+            reverseResolverAddress?: undefined;
+            resolverAddress?: undefined;
+        } | undefined>;
+    }>;
+    getResolver: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
+    }>;
+    getWrapperData: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+            fuseObj: import("./utils/fuses").CurrentFuses;
+            expiryDate: Date;
+            rawFuses: import("ethers").BigNumber;
+            owner: any;
+        } | undefined>;
+    }>;
+    getHistory: (name: string) => Promise<{
+        domain: {
+            type: "Transfer" | "NewOwner" | "NewResolver" | "NewTTL" | "FusesSet" | "NameUnwrapped" | "NameWrapped" | "WrappedTransfer";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
+        }[];
+        registration: {
+            type: "NameRegistered" | "NameRenewed" | "NameTransferred";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
+        }[];
+        resolver: {
+            type: "AddrChanged" | "ContenthashChanged" | "InterfaceChanged" | "NameChanged" | "PubkeyChanged" | "TextChanged" | "VersionChanged" | "MulticoinAddrChanged" | "AbiChanged" | "AuthorisationChanged";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
+        }[];
+    } | undefined>;
+    getContentHash: GeneratedRawFunction<{
+        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<{
+            protocolType?: undefined;
+            decoded?: undefined;
+            error?: undefined;
+        } | {
+            protocolType: null;
+            decoded: any;
+            error?: undefined;
+        } | {
+            protocolType: string | undefined;
+            decoded: any;
+            error: any;
+        } | undefined>;
+    }>;
+    _getContentHash: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+            protocolType?: undefined;
+            decoded?: undefined;
+            error?: undefined;
+        } | {
+            protocolType: null;
+            decoded: any;
+            error?: undefined;
+        } | {
+            protocolType: string | undefined;
+            decoded: any;
+            error: any;
+        } | undefined>;
+    }>;
+    getAddr: GeneratedRawFunction<{
+        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string, coinType?: string | number | undefined) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+            coin: string;
+            addr: string;
+        } | undefined>;
+    }>;
+    _getAddr: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string, coinType?: string | number | undefined, bypassFormat?: boolean | undefined) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+            coin: string;
+            addr: string;
+        } | undefined>;
+    }>;
+    getText: GeneratedRawFunction<{
+        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string, key: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<string | undefined>;
+    }>;
+    _getText: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string, key: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<string | undefined>;
+    }>;
+    getABI: GeneratedRawFunction<{
+        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<{
+            contentType: number;
+            decoded: boolean;
+            abi: string | object;
+        } | undefined>;
+    }>;
+    _getABI: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+            contentType: number;
+            decoded: boolean;
+            abi: string | object;
+        } | undefined>;
+    }>;
+    getOwner: GeneratedRawFunction<{
+        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts, multicallWrapper, gqlInstance, }: ENSArgs<"contracts" | "gqlInstance" | "multicallWrapper">, data: string, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
+            registrant?: string | undefined;
+            owner?: string | undefined;
+            ownershipLevel: "nameWrapper" | "registrar" | "registry";
+        } | undefined>;
+    }>;
+    getExpiry: GeneratedRawFunction<{
+        raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
+            expiry: Date;
+            gracePeriod: null;
+        } | {
+            expiry: Date | null;
+            gracePeriod: number;
+        } | undefined>;
+    }>;
+    getSubnames: (functionArgs: {
+        name: string;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        orderDirection?: "asc" | "desc" | undefined;
+        orderBy?: "labelName" | "createdAt" | undefined;
+        lastSubnames?: any[] | undefined;
+        search?: string | undefined;
+    }) => Promise<{
+        subnames: {
+            id: string;
+            labelName: string | null;
+            truncatedName?: string | undefined;
+            labelhash: string;
+            isMigrated: boolean;
+            name: string;
+            owner: {
+                id: string;
+            };
+        }[];
+        subnameCount: number;
+    }>;
+    getNames: (args_0: {
+        address: string;
+        type: "owner" | "wrappedOwner" | "registrant" | "all";
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        orderDirection?: "asc" | "desc" | undefined;
+    } & ({
+        type: "registrant";
+        orderBy?: "expiryDate" | "registrationDate" | "labelName" | undefined;
+    } | {
+        type: "owner";
+        orderBy?: "labelName" | "createdAt" | undefined;
+    } | {
+        type: "wrappedOwner";
+        orderBy?: "expiryDate" | "labelName" | undefined;
+    } | {
+        type: "all";
+        orderBy?: "labelName" | "creationDate" | undefined;
+        page?: undefined;
+        pageSize?: undefined;
+    })) => Promise<import("./functions/getNames").Name[]>;
+    getPrice: GeneratedRawFunction<{
+        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, nameOrNames: string | string[], duration: number, legacy?: boolean | undefined) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _nameOrNames: string | string[], _duration: number, legacy?: boolean | undefined) => Promise<{
+            base: import("ethers").BigNumber;
+            premium: import("ethers").BigNumber;
+        } | undefined>;
+    }>;
+    getDNSOwner: (dnsName: string) => Promise<any>;
+    supportsTLD: (name: string) => Promise<boolean>;
+    getAvailable: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<boolean | undefined>;
+    }>;
+    universalWrapper: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string, data: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+            data: any;
+            resolver: any;
+        } | undefined>;
+    }>;
+    resolverMulticallWrapper: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, data: {
+            to: string;
+            data: string;
+        }[]) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<import("@ethersproject/abi").Result | undefined>;
+    }>;
+    multicallWrapper: GeneratedRawFunction<{
+        raw({ contracts }: ENSArgs<"contracts">, transactions: import("@ethersproject/abstract-provider").TransactionRequest[], requireSuccess?: boolean): Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode({ contracts, provider }: ENSArgs<"provider" | "contracts">, data: string, transactions: import("@ethersproject/abstract-provider").TransactionRequest[]): Promise<{
+            success: boolean;
+            returnData: string;
+            0: boolean;
+            1: string;
+            length: 2;
+            toString(): string;
+            toLocaleString(): string;
+            pop(): string | boolean | undefined;
+            push(...items: (string | boolean)[]): number;
+            concat(...items: ConcatArray<string | boolean>[]): (string | boolean)[];
+            concat(...items: (string | boolean | ConcatArray<string | boolean>)[]): (string | boolean)[];
+            join(separator?: string | undefined): string;
+            reverse(): (string | boolean)[];
+            shift(): string | boolean | undefined;
+            slice(start?: number | undefined, end?: number | undefined): (string | boolean)[];
+            sort(compareFn?: ((a: string | boolean, b: string | boolean) => number) | undefined): [boolean, string];
+            splice(start: number, deleteCount?: number | undefined): (string | boolean)[];
+            splice(start: number, deleteCount: number, ...items: (string | boolean)[]): (string | boolean)[];
+            unshift(...items: (string | boolean)[]): number;
+            indexOf(searchElement: string | boolean, fromIndex?: number | undefined): number;
+            lastIndexOf(searchElement: string | boolean, fromIndex?: number | undefined): number;
+            every<S extends string | boolean>(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => value is S, thisArg?: any): this is S[];
+            every(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): boolean;
+            some(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): boolean;
+            forEach(callbackfn: (value: string | boolean, index: number, array: (string | boolean)[]) => void, thisArg?: any): void;
+            map<U>(callbackfn: (value: string | boolean, index: number, array: (string | boolean)[]) => U, thisArg?: any): U[];
+            filter<S_1 extends string | boolean>(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => value is S_1, thisArg?: any): S_1[];
+            filter(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): (string | boolean)[];
+            reduce(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean): string | boolean;
+            reduce(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean, initialValue: string | boolean): string | boolean;
+            reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => U_1, initialValue: U_1): U_1;
+            reduceRight(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean): string | boolean;
+            reduceRight(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean, initialValue: string | boolean): string | boolean;
+            reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => U_2, initialValue: U_2): U_2;
+            find<S_2 extends string | boolean>(predicate: (this: void, value: string | boolean, index: number, obj: (string | boolean)[]) => value is S_2, thisArg?: any): S_2 | undefined;
+            find(predicate: (value: string | boolean, index: number, obj: (string | boolean)[]) => unknown, thisArg?: any): string | boolean | undefined;
+            findIndex(predicate: (value: string | boolean, index: number, obj: (string | boolean)[]) => unknown, thisArg?: any): number;
+            fill(value: string | boolean, start?: number | undefined, end?: number | undefined): [boolean, string];
+            copyWithin(target: number, start: number, end?: number | undefined): [boolean, string];
+            entries(): IterableIterator<[number, string | boolean]>;
+            keys(): IterableIterator<number>;
+            values(): IterableIterator<string | boolean>;
+            includes(searchElement: string | boolean, fromIndex?: number | undefined): boolean;
+            flatMap<U_3, This = undefined>(callback: (this: This, value: string | boolean, index: number, array: (string | boolean)[]) => U_3 | readonly U_3[], thisArg?: This | undefined): U_3[];
+            flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+            [Symbol.iterator](): IterableIterator<string | boolean>;
+            [Symbol.unscopables](): {
+                copyWithin: boolean;
+                entries: boolean;
+                fill: boolean;
+                find: boolean;
+                findIndex: boolean;
+                keys: boolean;
+                values: boolean;
+            };
+            at(index: number): string | boolean | undefined;
+        }[] | undefined>;
+    }>;
+    setName: WriteFunction<typeof import("./functions/setName").default>;
+    setRecords: WriteFunction<typeof import("./functions/setRecords").default>;
+    setRecord: WriteFunction<typeof import("./functions/setRecord").default>;
+    setResolver: WriteFunction<typeof import("./functions/setResolver").default>;
+    transferName: WriteFunction<typeof import("./functions/transferName").default>;
+    transferController: WriteFunction<typeof import("./functions/transferController").default>;
+    wrapName: WriteFunction<typeof import("./functions/wrapName").default>;
+    unwrapName: WriteFunction<typeof import("./functions/unwrapName").default>;
+    burnFuses: WriteFunction<typeof import("./functions/burnFuses").default>;
+    importDNSSECName: WriteFunction<typeof import("./functions/importDNSSECName").default>;
+    createSubname: WriteFunction<typeof import("./functions/createSubname").default>;
+    deleteSubname: WriteFunction<typeof import("./functions/deleteSubname").default>;
+    transferSubname: WriteFunction<typeof import("./functions/transferSubname").default>;
+    commitName: WriteFunction<typeof import("./functions/commitName").default>;
+    registerName: WriteFunction<typeof import("./functions/registerName").default>;
+    renewNames: WriteFunction<typeof import("./functions/renewNames").default>;
+    renewNameWithData: WriteFunction<typeof import("./functions/renewNames").renewNameWithData>;
+}

package/dist/types/static.d.ts

@@ -0,0 +1,26 @@
+import type { StaticJsonRpcProvider } from '@ethersproject/providers/lib/url-json-rpc-provider';
+import { gql, GraphQLClient } from 'graphql-request';
+import { ENS, FunctionSubtype } from './index';
+import type Factories from './contracts/factories';
+import type FunctionTypes from './functions/types';
+declare type Options = ConstructorParameters<typeof ENS>[0] & {
+    functions: Partial<FunctionTypes>;
+    contracts: Partial<Factories>;
+};
+declare class StaticENS extends ENS {
+    private functions;
+    private contractsObject;
+    gqlInstance: {
+        client: GraphQLClient | {
+            request: () => Promise<null>;
+        };
+        setUrl: () => Promise<void>;
+        gql: typeof gql | ((query: TemplateStringsArray) => string);
+    };
+    constructor(provider: StaticJsonRpcProvider, { functions, contracts, ...options }: Options);
+    setStaticProvider: (provider: StaticJsonRpcProvider) => void;
+    setProvider: (provider: StaticJsonRpcProvider) => Promise<void>;
+    protected getModule: () => Promise<Partial<FunctionTypes>>;
+    protected getFunction: (subFunc: FunctionSubtype | undefined, _writeable: boolean | undefined, exportName: string, mod: any, path: string) => any;
+}
+export default StaticENS;

package/dist/types/utils/ccip.d.ts

@@ -0,0 +1,3 @@
+import type { BaseProvider, TransactionRequest } from '@ethersproject/providers';
+declare const ccipLookup: (provider: BaseProvider, transaction: TransactionRequest, result: string) => Promise<string | undefined>;
+export default ccipLookup;

package/dist/types/utils/consts.d.ts

@@ -0,0 +1 @@
+export declare const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";

package/dist/types/utils/fuses.d.ts

@@ -0,0 +1,61 @@
+import { BigNumberish } from '@ethersproject/bignumber/lib/bignumber';
+export declare const fuseEnum: {
+    readonly CANNOT_UNWRAP: 1;
+    readonly CANNOT_BURN_FUSES: 2;
+    readonly CANNOT_TRANSFER: 4;
+    readonly CANNOT_SET_RESOLVER: 8;
+    readonly CANNOT_SET_TTL: 16;
+    readonly CANNOT_CREATE_SUBDOMAIN: 32;
+    readonly PARENT_CANNOT_CONTROL: 64;
+};
+export declare type FuseOptions = {
+    -readonly [K in keyof typeof fuseEnum]?: boolean;
+};
+export declare const unnamedFuses: readonly [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296];
+declare const fullFuseEnum: {
+    CAN_DO_EVERYTHING: number;
+    CANNOT_UNWRAP: 1;
+    CANNOT_BURN_FUSES: 2;
+    CANNOT_TRANSFER: 4;
+    CANNOT_SET_RESOLVER: 8;
+    CANNOT_SET_TTL: 16;
+    CANNOT_CREATE_SUBDOMAIN: 32;
+    PARENT_CANNOT_CONTROL: 64;
+};
+export declare type FuseObj = typeof fuseEnum;
+export declare type CurrentFuses = {
+    [f in keyof FuseObj]: boolean;
+} & {
+    CAN_DO_EVERYTHING: boolean;
+};
+export declare type UnnamedFuseType = typeof unnamedFuses;
+export declare type Fuse = keyof FuseObj;
+export declare type UnnamedFuseValues = UnnamedFuseType[number];
+export declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
+/**
+ * This type creates a type error if there are any duplicate fuses.
+ * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
+ *
+ * @template A The array to check for duplicates.
+ * @template B The union of all checked existing types.
+ */
+declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities ? A extends [infer Head, ...infer Tail] ? Head extends B ? [
+] : [
+    Head,
+    ...FusesWithoutDuplicates<Tail, Head | B>
+] : A : [
+];
+export declare type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>;
+export declare type FusePropsNamedArray = {
+    namedFusesToBurn: NamedFusesToBurn;
+};
+export declare type FusePropsUnnamedArray = {
+    unnamedFusesToBurn: UnnamedFuseValues[];
+};
+export declare type FusePropsNumber = {
+    fuseNumberToBurn: number;
+};
+export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export declare const validateFuses: (fuses: FuseProps) => number;
+export declare const decodeFuses: (fuses: BigNumberish) => CurrentFuses;
+export default fullFuseEnum;

package/dist/{cjs → types}/utils/generateFuseInput.d.ts

@@ -1,3 +1,3 @@
-import { FuseOptions } from '../@types/FuseOptions';
+import { FuseOptions } from './fuses';
 declare const _default: (fuseOptions: FuseOptions) => string;
 export default _default;