@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.1

package/dist/esm/functions/getProfile.js

@@ -0,0 +1,265 @@
+import { formatsByName } from '@ensdomains/address-encoder';
+import { ethers } from 'ethers';
+import { decodeContenthash } from '../utils/contentHash';
+import { hexEncodeName } from '../utils/hexEncodedName';
+import { parseInputType } from '../utils/validation';
+const makeMulticallData = async ({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
+    let calls = [];
+    options.texts &&
+        (calls = [
+            ...calls,
+            ...(await Promise.all(options.texts.map(async (x) => ({
+                key: x,
+                data: await _getText.raw(name, x),
+                type: 'text',
+            })))),
+        ]);
+    options.coinTypes &&
+        (calls = [
+            ...calls,
+            ...(await Promise.all(options.coinTypes.map(async (x) => ({
+                key: x,
+                data: await _getAddr.raw(name, x, true),
+                type: 'addr',
+            })))),
+        ]);
+    if (typeof options.contentHash === 'boolean' && options.contentHash) {
+        calls.push({
+            key: 'contentHash',
+            data: await _getContentHash.raw(name),
+            type: 'contenthash',
+        });
+    }
+    if (!calls.find((x) => x.key === '60')) {
+        calls.push({
+            key: '60',
+            data: await _getAddr.raw(name, '60', true),
+            type: 'addr',
+        });
+    }
+    const prRawData = await resolverMulticallWrapper.raw(calls.map((x) => x.data));
+    return { data: prRawData.data, calls };
+};
+const makeHashIndexes = (data, name) => [...data.matchAll(ethers.utils.namehash(name).substring(2))].map((x) => x.index / 2 - 1);
+const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    const { data, calls } = await makeMulticallData({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper }, name, options);
+    let resolver;
+    try {
+        resolver = await universalResolver?.resolve(hexEncodeName(name), data);
+    }
+    catch {
+        return;
+    }
+    const [recordData] = await resolverMulticallWrapper.decode(resolver['0']);
+    const matchAddress = recordData[calls.findIndex((x) => x.key === '60')];
+    return {
+        address: matchAddress && (await _getAddr.decode(matchAddress)),
+        records: await formatRecords({ _getAddr, _getContentHash, _getText }, recordData, calls, options),
+        resolverAddress: resolver['1'],
+    };
+};
+const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, calls, options) => {
+    let returnedRecords = (await Promise.all(data.map(async (item, i) => {
+        let decodedFromAbi;
+        let itemRet = {
+            key: calls[i].key,
+            type: calls[i].type,
+        };
+        if (itemRet.type === 'addr' || itemRet.type === 'contenthash') {
+            decodedFromAbi = ethers.utils.defaultAbiCoder.decode(['bytes'], item)[0];
+            if (ethers.utils.hexStripZeros(decodedFromAbi) === '0x') {
+                return;
+            }
+        }
+        switch (calls[i].type) {
+            case 'text':
+                itemRet = {
+                    ...itemRet,
+                    value: await _getText.decode(item),
+                };
+                if (itemRet.value === '' || itemRet.value === undefined)
+                    return;
+                break;
+            case 'addr':
+                try {
+                    const addr = await _getAddr.decode(item, '', calls[i].key);
+                    if (addr) {
+                        itemRet = {
+                            ...itemRet,
+                            ...addr,
+                        };
+                        break;
+                    }
+                    else {
+                        return;
+                    }
+                }
+                catch {
+                    return;
+                }
+            case 'contenthash':
+                try {
+                    itemRet = {
+                        ...itemRet,
+                        value: await _getContentHash.decode(item),
+                    };
+                }
+                catch {
+                    return;
+                }
+        }
+        return itemRet;
+    })))
+        .filter((x) => {
+        return typeof x === 'object';
+    })
+        .filter((x) => x);
+    let returnedResponse = {};
+    if (typeof options.contentHash === 'string' ||
+        typeof options.contentHash === 'object') {
+        if (typeof options.contentHash === 'string' &&
+            ethers.utils.hexStripZeros(options.contentHash) === '0x') {
+            returnedResponse.contentHash = null;
+        }
+        else if (ethers.utils.isBytesLike(options.contentHash.decoded) &&
+            ethers.utils.hexStripZeros(options.contentHash.decoded) === '0x') {
+            returnedResponse.contentHash = null;
+        }
+        else {
+            returnedResponse.contentHash = options.contentHash;
+        }
+    }
+    else if (options.contentHash) {
+        const foundRecord = returnedRecords.find((item) => item.type === 'contenthash');
+        returnedResponse.contentHash = foundRecord ? foundRecord.value : null;
+    }
+    if (options.texts) {
+        returnedResponse.texts = returnedRecords.filter((x) => x.type === 'text');
+    }
+    if (options.coinTypes) {
+        returnedResponse.coinTypes = returnedRecords.filter((x) => x.type === 'addr');
+    }
+    return returnedResponse;
+};
+const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
+    const query = gqlInstance.gql `
+    query getRecords($name: String!) {
+      domains(where: { name: $name }) {
+        isMigrated
+        createdAt
+        resolver {
+          texts
+          coinTypes
+          contentHash
+          addr {
+            id
+          }
+        }
+      }
+    }
+  `;
+    const client = gqlInstance.client;
+    const { domains } = await client.request(query, { name });
+    if (!domains || domains.length === 0)
+        return;
+    const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains;
+    let returnedRecords = {};
+    if (!wantedRecords)
+        return { isMigrated, createdAt };
+    Object.keys(wantedRecords).forEach((key) => {
+        const data = wantedRecords[key];
+        if (typeof data === 'boolean' && data) {
+            if (key === 'contentHash') {
+                returnedRecords[key] = decodeContenthash(resolverResponse.contentHash);
+            }
+            else {
+                returnedRecords[key] = resolverResponse[key];
+            }
+        }
+    });
+    return { ...returnedRecords, isMigrated, createdAt };
+};
+const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
+    const usingOptions = !options || options?.texts === true || options?.coinTypes === true
+        ? options || { contentHash: true, texts: true, coinTypes: true }
+        : undefined;
+    const graphResult = await graphFetch({ gqlInstance }, name, usingOptions);
+    if (!graphResult)
+        return;
+    const { isMigrated, createdAt, ...wantedRecords } = graphResult;
+    const result = await getDataForName({
+        contracts,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+    }, name, usingOptions ? wantedRecords : options);
+    if (!result)
+        return { isMigrated, createdAt, message: "Records fetch didn't complete" };
+    return { ...result, isMigrated, createdAt, message: undefined };
+};
+const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, address, options) => {
+    let name;
+    try {
+        name = await getName(address);
+    }
+    catch (e) {
+        return;
+    }
+    if (!name || !name.name || name.name === '')
+        return;
+    if (!name.match)
+        return { ...name, isMigrated: null, createdAt: null };
+    const result = await getProfileFromName({
+        contracts,
+        gqlInstance,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+    }, name.name, options);
+    if (!result || result.message)
+        return;
+    delete result.address;
+    return {
+        ...result,
+        ...name,
+        message: undefined,
+    };
+};
+export default async function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, nameOrAddress, options) {
+    if (options && options.coinTypes && typeof options.coinTypes !== 'boolean') {
+        options.coinTypes = options.coinTypes.map((coin) => {
+            if (!isNaN(parseInt(coin))) {
+                return coin;
+            }
+            else {
+                return `${formatsByName[coin.toUpperCase()].coinType}`;
+            }
+        });
+    }
+    const inputType = parseInputType(nameOrAddress);
+    if (inputType.type === 'unknown' || inputType.info === 'unsupported') {
+        throw new Error('Invalid input type');
+    }
+    if (inputType.type === 'address') {
+        return getProfileFromAddress({
+            contracts,
+            gqlInstance,
+            getName,
+            _getAddr,
+            _getContentHash,
+            _getText,
+            resolverMulticallWrapper,
+        }, nameOrAddress, options);
+    }
+    return getProfileFromName({
+        contracts,
+        gqlInstance,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+    }, nameOrAddress, options);
+}

package/dist/esm/functions/getRecords.d.ts

@@ -0,0 +1,32 @@
+import { ENSArgs } from '..';
+declare type ProfileOptions = {
+    contentHash?: boolean;
+    texts?: boolean | string[];
+    coinTypes?: boolean | string[];
+};
+export default function ({ getProfile }: ENSArgs<'getProfile'>, name: string, options?: ProfileOptions): 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: "addr" | "text" | "contentHash";
+            coin?: string | undefined;
+            value: string;
+        }[] | undefined;
+        coinTypes?: {
+            key: string | number;
+            type: "addr" | "text" | "contentHash";
+            coin?: string | undefined;
+            value: string;
+        }[] | undefined;
+    } | undefined;
+    resolverAddress?: string | undefined;
+    reverseResolverAddress?: string | undefined;
+} | undefined>;
+export {};

package/dist/esm/functions/getRecords.js

@@ -0,0 +1,8 @@
+import { parseInputType } from '../utils/validation';
+export default async function ({ getProfile }, name, options) {
+    const inputType = parseInputType(name);
+    if (inputType.type !== 'name' && inputType.type !== 'label') {
+        throw new Error('Input must be an ENS name');
+    }
+    return await getProfile(name, options);
+}

package/dist/esm/functions/getResolver.d.ts

@@ -0,0 +1,9 @@
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
+};
+export default _default;

package/dist/esm/functions/getResolver.js

@@ -0,0 +1,22 @@
+import { ethers } from 'ethers';
+import { hexEncodeName } from '../utils/hexEncodedName';
+const raw = async ({ contracts }, name) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    return {
+        to: universalResolver.address,
+        data: universalResolver.interface.encodeFunctionData('findResolver', [
+            hexEncodeName(name),
+        ]),
+    };
+};
+const decode = async ({ contracts }, data) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    const response = universalResolver.interface.decodeFunctionResult('findResolver', data);
+    if (!response ||
+        !response[0] ||
+        ethers.utils.hexStripZeros(response[0]) === '0x') {
+        return;
+    }
+    return response[0];
+};
+export default { raw, decode };

package/dist/esm/functions/getSpecificRecord.d.ts

@@ -0,0 +1,73 @@
+import { ENSArgs } from '..';
+export declare const _getContentHash: {
+    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>;
+};
+export declare const getContentHash: {
+    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>;
+};
+export declare const _getText: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, key: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+};
+export declare const getText: {
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, key: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<any>;
+};
+export declare const _getAddr: {
+    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>;
+};
+export declare const getAddr: {
+    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>;
+};

package/dist/esm/functions/getSpecificRecord.js

@@ -0,0 +1,248 @@
+import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder';
+import { ethers } from 'ethers';
+import { decodeContenthash } from '../utils/contentHash';
+export const _getContentHash = {
+    raw: async ({ contracts }, name) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        return {
+            to: '0x0000000000000000000000000000000000000000',
+            data: publicResolver.interface.encodeFunctionData('contenthash', [
+                ethers.utils.namehash(name),
+            ]),
+        };
+    },
+    decode: async ({ contracts }, data) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        const [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
+        if (!response) {
+            return;
+        }
+        const decodedContent = decodeContenthash(response);
+        if (!decodedContent ||
+            (ethers.utils.isBytesLike(decodedContent.decoded) &&
+                ethers.utils.hexStripZeros(decodedContent.decoded) === '0x') ||
+            Object.keys(decodedContent).length === 0) {
+            return;
+        }
+        return decodedContent;
+    },
+};
+export const getContentHash = {
+    raw: async ({ contracts, universalWrapper }, name) => {
+        const prData = await _getContentHash.raw({ contracts }, name);
+        return await universalWrapper.raw(name, prData.data);
+    },
+    decode: async ({ contracts, universalWrapper }, data) => {
+        const urData = await universalWrapper.decode(data);
+        if (!urData)
+            return;
+        return await _getContentHash.decode({ contracts }, urData.data);
+    },
+};
+export const _getText = {
+    raw: async ({ contracts }, name, key) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        return {
+            to: '0x0000000000000000000000000000000000000000',
+            data: publicResolver.interface.encodeFunctionData('text', [
+                ethers.utils.namehash(name),
+                key,
+            ]),
+        };
+    },
+    decode: async ({ contracts }, data) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        const [response] = publicResolver.interface.decodeFunctionResult('text', data);
+        if (!response) {
+            return;
+        }
+        return response;
+    },
+};
+export const getText = {
+    raw: async ({ contracts, universalWrapper }, name, key) => {
+        const prData = await _getText.raw({ contracts }, name, key);
+        return await universalWrapper.raw(name, prData.data);
+    },
+    decode: async ({ contracts, universalWrapper }, data) => {
+        const urData = await universalWrapper.decode(data);
+        if (!urData)
+            return;
+        return await _getText.decode({ contracts }, urData.data);
+    },
+};
+export const _getAddr = {
+    raw: async ({ contracts }, name, coinType, bypassFormat) => {
+        if (!coinType) {
+            coinType = 60;
+        }
+        const publicResolver = await contracts?.getPublicResolver();
+        if (bypassFormat) {
+            return {
+                to: '0x0000000000000000000000000000000000000000',
+                data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [ethers.utils.namehash(name), coinType]),
+            };
+        }
+        const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
+            ? formatsByName[coinType]
+            : formatsByCoinType[typeof coinType === 'number' ? coinType : parseInt(coinType)];
+        if (!formatter) {
+            throw new Error(`No formatter found for coin: ${coinType}`);
+        }
+        return {
+            to: '0x0000000000000000000000000000000000000000',
+            data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [ethers.utils.namehash(name), formatter.coinType]),
+        };
+    },
+    decode: async ({ contracts }, data, _name, coinType) => {
+        let returnCoinType = true;
+        if (!coinType) {
+            coinType = 60;
+            returnCoinType = false;
+        }
+        const publicResolver = await contracts?.getPublicResolver();
+        const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
+            ? formatsByName[coinType]
+            : formatsByCoinType[typeof coinType === 'number' ? coinType : parseInt(coinType)];
+        const [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32,uint256)', data);
+        if (!response)
+            return;
+        if (ethers.utils.hexStripZeros(response) === '0x') {
+            return;
+        }
+        const decodedAddr = formatter.encoder(Buffer.from(response.slice(2), 'hex'));
+        if (!decodedAddr) {
+            return;
+        }
+        if (!returnCoinType) {
+            return decodedAddr;
+        }
+        return { coin: formatter.name, addr: decodedAddr };
+    },
+};
+export const getAddr = {
+    raw: async ({ contracts, universalWrapper }, name, coinType) => {
+        const prData = await _getAddr.raw({ contracts }, name, coinType);
+        return await universalWrapper.raw(name, prData.data);
+    },
+    decode: async ({ contracts, universalWrapper }, data, _name, coinType) => {
+        const urData = await universalWrapper.decode(data);
+        if (!urData)
+            return;
+        return await _getAddr.decode({ contracts }, urData.data, _name, coinType);
+    },
+};
+// export async function getAddr(
+//   { contracts }: ENSArgs<'contracts'>,
+//   name: string,
+//   coinType?: string | number,
+// ) {
+//   if (!coinType) {
+//     coinType = 60
+//   }
+//   const universalResolver = await contracts?.getUniversalResolver()
+//   const publicResolver = await contracts?.getPublicResolver()
+//   const formatter =
+//     typeof coinType === 'string'
+//       ? formatsByName[coinType]
+//       : formatsByCoinType[coinType]
+//   if (!formatter) {
+//     throw new Error(`Coin type ${coinType} is not supported`)
+//   }
+//   const data = publicResolver?.interface.encodeFunctionData(
+//     'addr(bytes32,uint256)',
+//     [ethers.utils.namehash(name), formatter.coinType],
+//   )
+//   const result = await universalResolver?.resolve(hexEncodeName(name), data)
+//   const [encodedAddr] = ethers.utils.defaultAbiCoder.decode(
+//     ['bytes'],
+//     result['0'],
+//   )
+//   if (ethers.utils.hexStripZeros(encodedAddr) === '0x') {
+//     return
+//   }
+//   const decodedAddr = formatter.encoder(
+//     Buffer.from(encodedAddr.slice(2), 'hex'),
+//   )
+//   if (!decodedAddr) {
+//     return
+//   }
+//   return decodedAddr
+// }
+// export const getContentHash = {
+//   raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const prData = publicResolver.interface.encodeFunctionData(
+//       'contenthash(bytes32)',
+//       [ethers.utils.namehash(name)],
+//     )
+//     const urData = universalResolver.interface.encodeFunctionData(
+//       'resolve(bytes,bytes)',
+//       [hexEncodeName(name), prData],
+//     )
+//     return {
+//       to: universalResolver.address,
+//       data: urData,
+//     }
+//   },
+//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const response = universalResolver.interface.decodeFunctionResult(
+//       'resolve(bytes,bytes)',
+//       data,
+//     )
+//     if (!response || !response[1]) {
+//       return
+//     }
+//     const [encodedContentHash] = publicResolver.interface.decodeFunctionResult(
+//       'contenthash(bytes32)',
+//       response[0],
+//     )
+//     if (ethers.utils.hexStripZeros(encodedContentHash) === '0x') {
+//       return
+//     }
+//     return decodeContenthash(encodedContentHash)
+//   },
+// }
+// const getText = {
+//   raw: async (
+//     { contracts }: ENSArgs<'contracts'>,
+//     name: string,
+//     key: string,
+//   ) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const data = publicResolver.interface.encodeFunctionData(
+//       'text(bytes32,string)',
+//       [ethers.utils.namehash(name), key],
+//     )
+//     return {
+//       to: universalResolver.address,
+//       data: universalResolver.interface.encodeFunctionData(
+//         'resolve(bytes,bytes)',
+//         [hexEncodeName(name), data],
+//       ),
+//     }
+//   },
+//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const response = universalResolver.interface.decodeFunctionResult(
+//       'resolve(bytes,bytes)',
+//       data,
+//     )
+//     if (!response || !response[1]) {
+//       return
+//     }
+//     const [decodedText] = publicResolver.interface.decodeFunctionResult(
+//       'text(bytes32,string)',
+//       response[0],
+//     )
+//     if (decodedText === '') {
+//       return
+//     }
+//     return decodedText
+//   },
+// }

package/dist/esm/functions/getSubnames.d.ts

@@ -0,0 +1,26 @@
+import { ENSArgs } from '..';
+declare type Subname = {
+    id: string;
+    labelName: string | null;
+    truncatedName?: string;
+    labelhash: string;
+    isMigrated: boolean;
+    name: string;
+    owner: {
+        id: string;
+    };
+};
+declare type Params = {
+    name: string;
+    page?: number;
+    pageSize?: number;
+    orderDirection?: 'asc' | 'desc';
+    orderBy?: 'createdAt' | 'labelName';
+    lastSubnames: Array<any>;
+    isLargeQuery?: boolean;
+};
+declare const getSubnames: (injected: ENSArgs<'gqlInstance'>, functionArgs: Params) => Promise<{
+    subnames: Subname[];
+    subnameCount: number;
+}>;
+export default getSubnames;