import * as PolkadotApiObjType from '@polkadot/api';
import { ApiPromise } from '@polkadot/api';
export { ApiPromise, SubmittableResult } from '@polkadot/api';
import * as PolkadotKeyringObjType from '@polkadot/keyring';
import * as PolkadotUtilCryptoObjType from '@polkadot/util-crypto';
import * as PolkadotExtensionDappType from '@polkadot/extension-dapp';
import * as EthersType from 'ethers';
import { C as CrossAccountId, a as CrossAccountIdUncapitalized, S as SubAddressObj, E as EthAddressObj, b as SubAddressObjUncapitalized, c as EthAddressObjUncapitalized, I as ISigner, d as CollectionParams, P as PropertiesArray, e as CollectionSponsorship, T as TokenPropertyPermissionObject, U as UniqueCollectionSchemaDecoded, f as UniqueTokenDecoded } from './index-4f47f2dd.js';
export { r as AttributeSchema, A as AttributeType, p as AttributeTypeValues, B as BoxedNumberWithDefault, v as COLLECTION_SCHEMA_NAME, u as CollectionAttributesSchema, C as CrossAccountId, h as CrossAccountIdOrString, a as CrossAccountIdUncapitalized, i as CrossAccountIdUncapitalizedOrString, D as DecodedAttributes, y as DecodedInfixOrUrlOrCidAndHash, z as DecodingImageLinkOptions, s as EncodedTokenAttributeValue, t as EncodedTokenAttributes, E as EthAddressObj, c as EthAddressObjUncapitalized, H as HumanizedNftToken, I as ISigner, j as InfixOrUrlOrCid, k as InfixOrUrlOrCidAndHash, n as IntegerAttributeTypes, q as LocalizedStringOrBoxedNumberWithDefault, L as LocalizedStringWithDefault, N as NumberAttributeTypes, P as PropertiesArray, g as SchemaTools, o as StringAttributeTypes, S as SubAddressObj, b as SubAddressObjUncapitalized, l as URL_TEMPLATE_INFIX, U as UniqueCollectionSchemaDecoded, w as UniqueCollectionSchemaToCreate, f as UniqueTokenDecoded, x as UniqueTokenToCreate, m as UrlTemplateString } from './index-4f47f2dd.js';
import basex from 'base-x';
import { keccak_256 } from '@noble/hashes/sha3';
import { blake2b } from '@noble/hashes/blake2b';
import { ISubmittableResult } from '@polkadot/types/types';
export { DefinitionRpc, DefinitionRpcSub, ISubmittableResult } from '@polkadot/types/types';
import { GenericEventData } from '@polkadot/types/generic/Event';
export { GenericEventData } from '@polkadot/types/generic/Event';
import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
export { SubmittableExtrinsic } from '@polkadot/api/promise/types';
import * as _polkadot_extension_inject_types from '@polkadot/extension-inject/types';
export { InjectedAccountWithMeta } from '@polkadot/extension-inject/types';
import * as _polkadot_keyring_types from '@polkadot/keyring/types';
import { KeyringOptions } from '@polkadot/keyring/types';
export { KeyringOptions, KeyringPair } from '@polkadot/keyring/types';
import { KeypairType, Prefix } from '@polkadot/util-crypto/types';
export { Keypair, KeypairType, Prefix, Seedpair } from '@polkadot/util-crypto/types';
import * as _polkadot_types_codec_types from '@polkadot/types-codec/types';
import * as _unique_nft_unique_mainnet_types_default_types from '@unique-nft/unique-mainnet-types/default/types';
import * as _polkadot_types from '@polkadot/types';
import * as _unique_nft_unique_mainnet_types_default from '@unique-nft/unique-mainnet-types/default';
export { UpDataStructsTokenData } from '@unique-nft/unique-mainnet-types/default';
export { EventRecord } from '@polkadot/types/interfaces/system/types';
export { HexString } from '@polkadot/util/types';

declare type PolkadotApi = typeof PolkadotApiObjType;
declare type PolkadotKeyring = typeof PolkadotKeyringObjType;
declare type PolkadotUtilCrypto = typeof PolkadotUtilCryptoObjType;
declare type PolkadotExtensionDapp = typeof PolkadotExtensionDappType;
declare type Ethers = typeof EthersType;
declare const rpcDefinitions: {
    opal: {
        adminlist: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        allowlist: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        accountTokens: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionTokens: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        lastTokenId: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        totalSupply: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        accountBalance: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        balance: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        allowance: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenOwner: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        topmostTokenOwner: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenChildren: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        constMetadata: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        variableMetadata: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionProperties: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenProperties: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        propertyPermissions: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenData: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenExists: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionById: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionStats: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        allowed: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        nextSponsored: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        effectiveCollectionLimits: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
    };
    quartz: {
        adminlist: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        allowlist: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        accountTokens: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionTokens: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        lastTokenId: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        totalSupply: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        accountBalance: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        balance: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        allowance: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenOwner: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        topmostTokenOwner: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenChildren: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        constMetadata: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        variableMetadata: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionProperties: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenProperties: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        propertyPermissions: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenData: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenExists: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionById: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionStats: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        allowed: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        nextSponsored: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        effectiveCollectionLimits: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
    };
    unique: {
        adminlist: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        allowlist: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        accountTokens: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionTokens: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        lastTokenId: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        totalSupply: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        accountBalance: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        balance: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        allowance: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenOwner: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        topmostTokenOwner: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenChildren: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        constMetadata: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        variableMetadata: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionProperties: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenProperties: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        propertyPermissions: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenData: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        tokenExists: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionById: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        collectionStats: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        allowed: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        nextSponsored: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
        effectiveCollectionLimits: {
            description: string;
            params: ({
                name: string;
                type: string;
                isOptional?: true | undefined;
            } | {
                name: string;
                type: string;
                isOptional: boolean;
            })[];
            type: string;
        };
    };
};
interface Libs {
    ethers: Ethers | null;
    api: PolkadotApi | null;
    keyring: PolkadotKeyring | null;
    utilCrypto: PolkadotUtilCrypto | null;
    extensionDapp: PolkadotExtensionDapp | null;
}
interface InitOptions {
    initLibs?: {
        [k in keyof Omit<Libs, 'ethers'>]: boolean;
    };
    connectToPolkadotExtensionsAs?: string;
}
declare function init$1(options?: InitOptions): Promise<void>;
declare function getPolkadotApi(): typeof PolkadotApiObjType;
declare function getEthers(): Ethers;
declare function getPolkadotKeyring(): typeof PolkadotKeyringObjType;
declare function getPolkadotUtilCrypto(): typeof PolkadotUtilCryptoObjType;
declare function getPolkadotExtensionDapp(): typeof PolkadotExtensionDappType;

declare const libs_rpcDefinitions: typeof rpcDefinitions;
type libs_InitOptions = InitOptions;
declare const libs_getPolkadotApi: typeof getPolkadotApi;
declare const libs_getEthers: typeof getEthers;
declare const libs_getPolkadotKeyring: typeof getPolkadotKeyring;
declare const libs_getPolkadotUtilCrypto: typeof getPolkadotUtilCrypto;
declare const libs_getPolkadotExtensionDapp: typeof getPolkadotExtensionDapp;
declare namespace libs {
  export {
    libs_rpcDefinitions as rpcDefinitions,
    libs_InitOptions as InitOptions,
    init$1 as init,
    libs_getPolkadotApi as getPolkadotApi,
    libs_getEthers as getEthers,
    libs_getPolkadotKeyring as getPolkadotKeyring,
    libs_getPolkadotUtilCrypto as getPolkadotUtilCrypto,
    libs_getPolkadotExtensionDapp as getPolkadotExtensionDapp,
  };
}

declare const NESTING_PREFIX$1 = "0xf8238ccfff8ed887463fd5e0";
declare const COLLECTION_ADDRESS_PREFIX$1 = "0x17c4e6453cc49aaaaeaca894e6d9683e";
declare const WS_RPC: {
    unique: string;
    quartz: string;
    uniqueRC: string;
    opal: string;
    polkadot: string;
    kusama: string;
};

declare const constants$1_WS_RPC: typeof WS_RPC;
declare namespace constants$1 {
  export {
    NESTING_PREFIX$1 as NESTING_PREFIX,
    COLLECTION_ADDRESS_PREFIX$1 as COLLECTION_ADDRESS_PREFIX,
    constants$1_WS_RPC as WS_RPC,
  };
}

declare function encodeSubstrateAddress(key: Uint8Array | string | bigint, ss58Format?: number): string;
declare function decodeSubstrateAddress(address: string, ignoreChecksum?: boolean, ss58Format?: number): DecodeSubstrateAddressResult;

declare const vec2str: (arr: Array<number | string>) => string;
declare const str2vec: (str: string) => number[];
declare const strToU8a: (str: string) => Uint8Array;
declare const hexToU8a: (hexString: string) => Uint8Array;
declare const u8aToHex: (bytes: number[] | Uint8Array) => string;
declare const hexStringToString: (hexString: string) => string;
declare const safeJsonParseStringOrHexString: <T = any>(stringOrHexString: string) => string | T;
declare const parseAndCheckTheNumberIsDWORD: (n: number | string) => number;
declare const DWORDHexString: {
    fromNumber: (n: number) => string;
    toNumber: (s: string) => number;
};

declare const StringUtils_vec2str: typeof vec2str;
declare const StringUtils_str2vec: typeof str2vec;
declare const StringUtils_strToU8a: typeof strToU8a;
declare const StringUtils_hexToU8a: typeof hexToU8a;
declare const StringUtils_u8aToHex: typeof u8aToHex;
declare const StringUtils_hexStringToString: typeof hexStringToString;
declare const StringUtils_safeJsonParseStringOrHexString: typeof safeJsonParseStringOrHexString;
declare const StringUtils_parseAndCheckTheNumberIsDWORD: typeof parseAndCheckTheNumberIsDWORD;
declare const StringUtils_DWORDHexString: typeof DWORDHexString;
declare namespace StringUtils {
  export {
    StringUtils_vec2str as vec2str,
    StringUtils_str2vec as str2vec,
    StringUtils_strToU8a as strToU8a,
    StringUtils_hexToU8a as hexToU8a,
    StringUtils_u8aToHex as u8aToHex,
    StringUtils_hexStringToString as hexStringToString,
    StringUtils_safeJsonParseStringOrHexString as safeJsonParseStringOrHexString,
    StringUtils_parseAndCheckTheNumberIsDWORD as parseAndCheckTheNumberIsDWORD,
    StringUtils_DWORDHexString as DWORDHexString,
  };
}

declare const base58: basex.BaseConverter;
declare const base64: basex.BaseConverter;

declare const algorithms_keccak_256: typeof keccak_256;
declare const algorithms_blake2b: typeof blake2b;
declare const algorithms_base58: typeof base58;
declare const algorithms_base64: typeof base64;
declare const algorithms_basex: typeof basex;
declare namespace algorithms {
  export {
    algorithms_keccak_256 as keccak_256,
    algorithms_blake2b as blake2b,
    algorithms_base58 as base58,
    algorithms_base64 as base64,
    algorithms_basex as basex,
  };
}

declare const STATIC_ADDRESSES: {
    readonly contractHelpers: "0x842899ECF380553E8a4de75bF534cdf6fBF64049";
    readonly collectionHelpers: "0x6C4E9fE1AE37a41E93CEE429e8E1881aBdcbb54F";
};
declare const NESTING_PREFIX: "0xf8238ccfff8ed887463fd5e0";
declare const COLLECTION_ADDRESS_PREFIX: "0x17c4e6453cc49aaaaeaca894e6d9683e";

declare const constants_STATIC_ADDRESSES: typeof STATIC_ADDRESSES;
declare const constants_NESTING_PREFIX: typeof NESTING_PREFIX;
declare const constants_COLLECTION_ADDRESS_PREFIX: typeof COLLECTION_ADDRESS_PREFIX;
declare namespace constants {
  export {
    constants_STATIC_ADDRESSES as STATIC_ADDRESSES,
    constants_NESTING_PREFIX as NESTING_PREFIX,
    constants_COLLECTION_ADDRESS_PREFIX as COLLECTION_ADDRESS_PREFIX,
  };
}

declare type DecodeSubstrateAddressResult = {
    u8a: Uint8Array;
    hex: string;
    bigint: bigint;
};
declare const validate: {
    substrateAddress: (address: string) => boolean;
    ethereumAddress: (address: string) => boolean;
    collectionAddress: (address: string) => boolean;
    nestingAddress: (address: string) => boolean;
    collectionId: (collectionId: number) => boolean;
    tokenId: (tokenId: number) => boolean;
};
declare const is: {
    substrateAddress: (address: string) => boolean;
    ethereumAddress: (address: string) => boolean;
    collectionAddress: (address: string) => boolean;
    nestingAddress: (address: string) => boolean;
    collectionId: (collectionId: number) => boolean;
    tokenId: (tokenId: number) => boolean;
    crossAccountId(obj: any): obj is CrossAccountId;
    crossAccountIdUncapitalized(obj: any): obj is CrossAccountIdUncapitalized;
    substrateAddressObject(obj: any): obj is SubAddressObj;
    ethereumAddressObject(obj: any): obj is EthAddressObj;
    substrateAddressObjectUncapitalized(obj: any): obj is SubAddressObjUncapitalized;
    ethereumAddressObjectUncapitalized(obj: any): obj is EthAddressObjUncapitalized;
};
declare const collection: {
    idToAddress: (collectionId: number) => string | null;
    addressToId: (address: string) => number | null;
};
declare const nesting: {
    idsToAddress: (collectionId: number, tokenId: number) => string;
    addressToIds: (address: string) => {
        collectionId: number;
        tokenId: number;
    };
};
declare const to: {
    crossAccountId: (address: string) => CrossAccountId;
    crossAccountIdNormalized: (address: string) => CrossAccountId;
    substrateNormalizedOrMirrorIfEthereum: (address: string) => string;
};
declare const extract: {
    normalizedAddressFromObject: (address: string | object) => string;
    normalizedAddressFromObjectSafe: (address: string | object) => string | null;
    crossAccountIdFromObject: (obj: any) => CrossAccountId;
    crossAccountIdFromObjectNormalized: (obj: any) => CrossAccountId;
};
declare const mirror: {
    substrateToEthereum: (address: string, ignoreChecksum?: boolean | undefined) => string;
    ethereumToSubstrate: (evmAddress: string, ss58Format?: number) => string;
};
declare const normalize: {
    substrateAddress: (address: string, prefix?: number) => string;
    ethereumAddress: (address: string) => string;
};
declare const compare: {
    substrateAddresses: (address1: string | object | {
        Substrate: string;
    }, address2: string | object | {
        Substrate: string;
    }) => boolean;
    ethereumAddresses: (address1: string | object | {
        Ethereum: string;
    }, address2: string | object | {
        Ethereum: string;
    }) => boolean;
};
declare const substrate: {
    encode: typeof encodeSubstrateAddress;
    decode: typeof decodeSubstrateAddress;
    compare: (address1: string | object | {
        Substrate: string;
    }, address2: string | object | {
        Substrate: string;
    }) => boolean;
};
declare const Address: {
    constants: typeof constants;
    is: {
        substrateAddress: (address: string) => boolean;
        ethereumAddress: (address: string) => boolean;
        collectionAddress: (address: string) => boolean;
        nestingAddress: (address: string) => boolean;
        collectionId: (collectionId: number) => boolean;
        tokenId: (tokenId: number) => boolean;
        crossAccountId(obj: any): obj is CrossAccountId;
        crossAccountIdUncapitalized(obj: any): obj is CrossAccountIdUncapitalized;
        substrateAddressObject(obj: any): obj is SubAddressObj;
        ethereumAddressObject(obj: any): obj is EthAddressObj;
        substrateAddressObjectUncapitalized(obj: any): obj is SubAddressObjUncapitalized;
        ethereumAddressObjectUncapitalized(obj: any): obj is EthAddressObjUncapitalized;
    };
    validate: {
        substrateAddress: (address: string) => boolean;
        ethereumAddress: (address: string) => boolean;
        collectionAddress: (address: string) => boolean;
        nestingAddress: (address: string) => boolean;
        collectionId: (collectionId: number) => boolean;
        tokenId: (tokenId: number) => boolean;
    };
    collection: {
        idToAddress: (collectionId: number) => string | null;
        addressToId: (address: string) => number | null;
    };
    nesting: {
        idsToAddress: (collectionId: number, tokenId: number) => string;
        addressToIds: (address: string) => {
            collectionId: number;
            tokenId: number;
        };
    };
    to: {
        crossAccountId: (address: string) => CrossAccountId;
        crossAccountIdNormalized: (address: string) => CrossAccountId;
        substrateNormalizedOrMirrorIfEthereum: (address: string) => string;
    };
    extract: {
        normalizedAddressFromObject: (address: string | object) => string;
        normalizedAddressFromObjectSafe: (address: string | object) => string | null;
        crossAccountIdFromObject: (obj: any) => CrossAccountId;
        crossAccountIdFromObjectNormalized: (obj: any) => CrossAccountId;
    };
    mirror: {
        substrateToEthereum: (address: string, ignoreChecksum?: boolean | undefined) => string;
        ethereumToSubstrate: (evmAddress: string, ss58Format?: number) => string;
    };
    normalize: {
        substrateAddress: (address: string, prefix?: number) => string;
        ethereumAddress: (address: string) => string;
    };
    compare: {
        substrateAddresses: (address1: string | object | {
            Substrate: string;
        }, address2: string | object | {
            Substrate: string;
        }) => boolean;
        ethereumAddresses: (address1: string | object | {
            Ethereum: string;
        }, address2: string | object | {
            Ethereum: string;
        }) => boolean;
    };
    substrate: {
        encode: typeof encodeSubstrateAddress;
        decode: typeof decodeSubstrateAddress;
        compare: (address1: string | object | {
            Substrate: string;
        }, address2: string | object | {
            Substrate: string;
        }) => boolean;
    };
    algorithms: typeof algorithms;
    StringUtils: typeof StringUtils;
};

declare const Address$1_constants: typeof constants;
declare const Address$1_algorithms: typeof algorithms;
declare const Address$1_StringUtils: typeof StringUtils;
type Address$1_DecodeSubstrateAddressResult = DecodeSubstrateAddressResult;
declare const Address$1_validate: typeof validate;
declare const Address$1_is: typeof is;
declare const Address$1_collection: typeof collection;
declare const Address$1_nesting: typeof nesting;
declare const Address$1_to: typeof to;
declare const Address$1_extract: typeof extract;
declare const Address$1_mirror: typeof mirror;
declare const Address$1_normalize: typeof normalize;
declare const Address$1_compare: typeof compare;
declare const Address$1_substrate: typeof substrate;
declare const Address$1_Address: typeof Address;
declare namespace Address$1 {
  export {
    Address$1_constants as constants,
    Address$1_algorithms as algorithms,
    Address$1_StringUtils as StringUtils,
    Address$1_DecodeSubstrateAddressResult as DecodeSubstrateAddressResult,
    Address$1_validate as validate,
    Address$1_is as is,
    Address$1_collection as collection,
    Address$1_nesting as nesting,
    Address$1_to as to,
    Address$1_extract as extract,
    Address$1_mirror as mirror,
    Address$1_normalize as normalize,
    Address$1_compare as compare,
    Address$1_substrate as substrate,
    Address$1_Address as Address,
  };
}

declare const UniqueUtils: {
    Browser: {
        checkEnvironmentIsBrowser: (safe?: boolean) => boolean;
    };
    StringUtils: typeof StringUtils;
    Address: typeof Address$1;
};

declare const requestAccounts: () => Promise<Array<string>>;
interface ISafeGetAccountsResult {
    extensionFound: boolean;
    accounts: string[];
}
declare const safeGetAccounts: () => Promise<ISafeGetAccountsResult>;

declare const extensionTools$1_requestAccounts: typeof requestAccounts;
declare const extensionTools$1_safeGetAccounts: typeof safeGetAccounts;
declare namespace extensionTools$1 {
  export {
    extensionTools$1_requestAccounts as requestAccounts,
    extensionTools$1_safeGetAccounts as safeGetAccounts,
  };
}

declare const Ethereum: {
    extension: typeof extensionTools$1;
};

declare const findEventDataBySectionAndMethod: (txResult: ISubmittableResult, section: string, method: string) => GenericEventData | undefined;
declare const findManyEventsDataBySectionAndMethod: (txResult: ISubmittableResult, section: string, method: string) => Array<GenericEventData>;
declare const signTransaction: <T extends SubmittableExtrinsic>(tx: T, signer: ISigner, label?: string) => Promise<T>;
declare const sendTransaction: <T extends SubmittableExtrinsic>(tx: T, label?: string) => Promise<ISubmittableResult>;
declare const signAndSendTransaction: <T extends SubmittableExtrinsic>(tx: T, signer: ISigner, label?: string) => Promise<ISubmittableResult>;

declare const extrinsicTools_findEventDataBySectionAndMethod: typeof findEventDataBySectionAndMethod;
declare const extrinsicTools_findManyEventsDataBySectionAndMethod: typeof findManyEventsDataBySectionAndMethod;
declare const extrinsicTools_signTransaction: typeof signTransaction;
declare const extrinsicTools_sendTransaction: typeof sendTransaction;
declare const extrinsicTools_signAndSendTransaction: typeof signAndSendTransaction;
declare namespace extrinsicTools {
  export {
    extrinsicTools_findEventDataBySectionAndMethod as findEventDataBySectionAndMethod,
    extrinsicTools_findManyEventsDataBySectionAndMethod as findManyEventsDataBySectionAndMethod,
    extrinsicTools_signTransaction as signTransaction,
    extrinsicTools_sendTransaction as sendTransaction,
    extrinsicTools_signAndSendTransaction as signAndSendTransaction,
  };
}

declare const connectAs: (appName: string) => Promise<void>;
declare const getAllAccounts: () => Promise<_polkadot_extension_inject_types.InjectedAccountWithMeta[]>;

declare const extensionTools_connectAs: typeof connectAs;
declare const extensionTools_getAllAccounts: typeof getAllAccounts;
declare namespace extensionTools {
  export {
    extensionTools_connectAs as connectAs,
    extensionTools_getAllAccounts as getAllAccounts,
  };
}

declare const keyringFromSeed: (seed: string, keypairType?: KeypairType, ss58Format?: Prefix) => _polkadot_keyring_types.KeyringPair;
declare const createKeyring: (options?: KeyringOptions) => PolkadotKeyringObjType.default;

declare const signerTools_KeypairType: typeof KeypairType;
declare const signerTools_keyringFromSeed: typeof keyringFromSeed;
declare const signerTools_createKeyring: typeof createKeyring;
declare namespace signerTools {
  export {
    signerTools_KeypairType as KeypairType,
    signerTools_keyringFromSeed as keyringFromSeed,
    signerTools_createKeyring as createKeyring,
  };
}

interface ExtrinsicInfo {
    blockHash: string;
    blockNumber?: number;
    txIndex?: number;
    txHash: string;
}
interface ExtrinsicResult {
    txResult: ISubmittableResult;
    extrinsicInfo: ExtrinsicInfo;
}
interface ExtrinsicOptions {
}
interface ExtrinsicSendOptions {
    getBlockNumber?: boolean;
}
declare abstract class AbstractExtrinsic<P, R extends ExtrinsicResult = ExtrinsicResult> {
    protected readonly api: ApiPromise;
    protected tx: SubmittableExtrinsic;
    protected readonly params: P;
    constructor(api: ApiPromise, tx: SubmittableExtrinsic, params: P);
    get isSigned(): boolean;
    verifySignature(): void;
    getRawTx(): SubmittableExtrinsic;
    sign(signer: ISigner): Promise<this>;
    send(options?: ExtrinsicSendOptions): Promise<R>;
    signAndSend(signer: ISigner, options?: ExtrinsicSendOptions): Promise<R>;
    getPaymentInfo(fromAddress: string): Promise<bigint>;
    protected getBaseResult(txResult: ISubmittableResult, options?: ExtrinsicSendOptions): Promise<ExtrinsicResult>;
    protected processResult(txResult: ISubmittableResult, options?: ExtrinsicSendOptions): Promise<R>;
}
declare class TransactionFromRawTx extends AbstractExtrinsic<SubmittableExtrinsic | string> {
    constructor(api: ApiPromise, tx: SubmittableExtrinsic | string, options?: ExtrinsicOptions);
}

interface ExtrinsicTransferCoinsParams {
    toAddress: string;
    amountInWei: bigint;
}
interface ExtrinsicTransferCoinsOptions extends ExtrinsicOptions {
    dontKeepAccountAlive?: boolean;
}
interface ExtrinsicTransferCoinsResult extends ExtrinsicResult {
    isSuccess: boolean;
}
declare class ExtrinsicTransferCoins extends AbstractExtrinsic<ExtrinsicTransferCoinsParams, ExtrinsicTransferCoinsResult> {
    constructor(api: ApiPromise, params: ExtrinsicTransferCoinsParams, options?: ExtrinsicTransferCoinsOptions);
    protected processResult(txResult: ISubmittableResult, options?: ExtrinsicSendOptions): Promise<{
        isSuccess: boolean;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface CoinOptions {
    decimals: number;
    symbol: string;
    weiSymbol: string;
}
declare class Coin {
    readonly decimals: number;
    readonly symbol: string;
    readonly weiSymbol: string;
    readonly oneCoinInWei: bigint;
    readonly hwei: bigint;
    constructor(options: CoinOptions);
    static createUnknown18DecimalsCoin(): Coin;
    getOptions(): {
        symbol: string;
        decimals: number;
        weiSymbol: string;
    };
    getFractionalPart(wei: bigint | string): bigint;
    getIntegerPart(wei: bigint | string): bigint;
    bigintFromWei(wei: string | bigint): bigint;
    format(wei: string | bigint, decimalPoints?: number): string;
    formatFullLength(wei: string | bigint): string;
    formatWithoutCurrency(wei: string | bigint, decimalPoints?: number): string;
    dangerouslyCoinsToWei(coins: number): bigint;
    coinsToWei(coins: string): bigint;
}

declare const quartz: Coin;
declare const unique: Coin;
declare const opal: Coin;

type index_Coin = Coin;
declare const index_Coin: typeof Coin;
declare const index_quartz: typeof quartz;
declare const index_unique: typeof unique;
declare const index_opal: typeof opal;
declare namespace index {
  export {
    index_Coin as Coin,
    index_quartz as quartz,
    index_unique as unique,
    index_opal as opal,
  };
}

interface ConnectToSubstrateOptions {
    dontAwaitApiIsReady?: boolean;
    uniqueRpcDefinitionsName?: 'unique' | 'quartz' | 'opal';
}
declare class SubstrateCommon {
    protected _api: ApiPromise | undefined;
    protected _ss58Prefix: number;
    protected _coin: Coin;
    protected get api(): ApiPromise;
    get ss58Prefix(): number;
    get coin(): Coin;
    connect(wsEndpoint: string, options?: ConnectToSubstrateOptions): Promise<this>;
    disconnect(): Promise<this>;
    getApi(): ApiPromise | undefined;
    get isConnected(): boolean;
    transferCoins(params: ExtrinsicTransferCoinsParams, options?: ExtrinsicTransferCoinsOptions): ExtrinsicTransferCoins;
    createTransactionFromRawTx(tx: SubmittableExtrinsic, options?: ExtrinsicOptions): TransactionFromRawTx;
    getBalance(address: string): Promise<bigint>;
    getChainProperties(): Promise<Record<string, _polkadot_types_codec_types.AnyJson>>;
}

interface ExtrinsicCreateCollectionParams {
    collection: CollectionParams;
}
interface ExtrinsicCreateCollectionResult extends ExtrinsicResult {
    collectionId: number;
}
declare class ExtrinsicCreateCollection extends AbstractExtrinsic<ExtrinsicCreateCollectionParams, ExtrinsicCreateCollectionResult> {
    constructor(api: ApiPromise, params: ExtrinsicCreateCollectionParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        collectionId: number;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface ExtrinsicAddCollectionAdminParams {
    collectionId: number;
    newAdminAddress: string;
}
interface ExtrinsicAddCollectionAdminResult extends ExtrinsicResult {
    isSuccess: boolean;
}
declare class ExtrinsicAddCollectionAdmin extends AbstractExtrinsic<ExtrinsicAddCollectionAdminParams, ExtrinsicAddCollectionAdminResult> {
    constructor(api: ApiPromise, params: ExtrinsicAddCollectionAdminParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        isSuccess: boolean;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface ExtrinsicRemoveCollectionAdminParams {
    collectionId: number;
    adminAddress: string;
}
interface ExtrinsicRemoveCollectionAdminResult extends ExtrinsicResult {
    isSuccess: boolean;
}
declare class ExtrinsicRemoveCollectionAdmin extends AbstractExtrinsic<ExtrinsicRemoveCollectionAdminParams, ExtrinsicRemoveCollectionAdminResult> {
    constructor(api: ApiPromise, params: ExtrinsicRemoveCollectionAdminParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        isSuccess: boolean;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface ExtrinsicSetCollectionSponsorParams {
    collectionId: number;
    newSponsorAddress: string;
}
interface ExtrinsicSetCollectionSponsorResult extends ExtrinsicResult {
    isSuccess: boolean;
}
declare class ExtrinsicSetCollectionSponsor extends AbstractExtrinsic<ExtrinsicSetCollectionSponsorParams, ExtrinsicSetCollectionSponsorResult> {
    constructor(api: ApiPromise, params: ExtrinsicSetCollectionSponsorParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        isSuccess: boolean;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface ExtrinsicConfirmSponsorshipParams {
    collectionId: number;
}
interface ExtrinsicConfirmSponsorshipResult extends ExtrinsicResult {
    isSuccess: boolean;
}
declare class ExtrinsicConfirmSponsorship extends AbstractExtrinsic<ExtrinsicConfirmSponsorshipParams, ExtrinsicConfirmSponsorshipResult> {
    constructor(api: ApiPromise, params: ExtrinsicConfirmSponsorshipParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        isSuccess: boolean;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface ExtrinsicChangeCollectionOwnerParams {
    collectionId: number;
    newOwnerAddress: string;
}
interface ExtrinsicChangeCollectionOwnerResult extends ExtrinsicResult {
    isSuccess: boolean;
}
declare class ExtrinsicChangeCollectionOwner extends AbstractExtrinsic<ExtrinsicChangeCollectionOwnerParams, ExtrinsicChangeCollectionOwnerResult> {
    constructor(api: ApiPromise, params: ExtrinsicChangeCollectionOwnerParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        isSuccess: boolean;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface ExtrinsicRemoveCollectionSponsorParams {
    collectionId: number;
}
interface ExtrinsicRemoveCollectionSponsorResult extends ExtrinsicResult {
    isSuccess: boolean;
}
declare class ExtrinsicRemoveCollectionSponsor extends AbstractExtrinsic<ExtrinsicRemoveCollectionSponsorParams, ExtrinsicRemoveCollectionSponsorResult> {
    constructor(api: ApiPromise, params: ExtrinsicRemoveCollectionSponsorParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        isSuccess: boolean;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface ExtrinsicRemoveFromAllowListParams {
    collectionId: number;
    address: string;
}
interface ExtrinsicRemoveFromAllowListResult extends ExtrinsicResult {
    isSuccess: boolean;
}
declare class ExtrinsicRemoveFromAllowList extends AbstractExtrinsic<ExtrinsicRemoveFromAllowListParams, ExtrinsicRemoveFromAllowListResult> {
    constructor(api: ApiPromise, params: ExtrinsicRemoveFromAllowListParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        isSuccess: boolean;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface ExtrinsicAddToAllowListParams {
    collectionId: number;
    address: string;
}
interface ExtrinsicAddToAllowListResult extends ExtrinsicResult {
    isSuccess: boolean;
}
declare class ExtrinsicAddToAllowList extends AbstractExtrinsic<ExtrinsicAddToAllowListParams, ExtrinsicAddToAllowListResult> {
    constructor(api: ApiPromise, params: ExtrinsicAddToAllowListParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        isSuccess: boolean;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

declare type TokenToMint = {
    owner: CrossAccountId;
    properties: PropertiesArray;
};

interface ExtrinsicCreateNftTokenParams {
    collectionId: number;
    token: TokenToMint;
}
interface ExtrinsicCreateNftTokenResult extends ExtrinsicResult {
    collectionId: number;
    tokenId: number;
    owner: CrossAccountId;
}
declare class ExtrinsicCreateNftToken extends AbstractExtrinsic<ExtrinsicCreateNftTokenParams, ExtrinsicCreateNftTokenResult> {
    constructor(api: ApiPromise, params: ExtrinsicCreateNftTokenParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        collectionId: number;
        tokenId: number;
        owner: CrossAccountId;
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

interface ExtrinsicCreateMultipleNftTokensParams {
    collectionId: number;
    tokens: Array<TokenToMint>;
}
interface ExtrinsicCreateMultipleNftTokensResult extends ExtrinsicResult {
    tokens: Array<{
        tokenId: number;
        owner: CrossAccountId;
    }>;
}
declare class ExtrinsicCreateMultipleNftTokens extends AbstractExtrinsic<ExtrinsicCreateMultipleNftTokensParams, ExtrinsicCreateMultipleNftTokensResult> {
    constructor(api: ApiPromise, params: ExtrinsicCreateMultipleNftTokensParams, options?: ExtrinsicOptions);
    protected processResult(txResult: ISubmittableResult, options: ExtrinsicSendOptions): Promise<{
        tokens: {
            tokenId: number;
            owner: CrossAccountId;
        }[];
        txResult: ISubmittableResult;
        extrinsicInfo: ExtrinsicInfo;
    }>;
}

declare class ValidationError extends TypeError {
    constructor(message: string);
}

interface IGetCollectionOptions {
    fetchAll?: boolean;
    fetchEffectiveLimits?: boolean;
    fetchAdmins?: boolean;
    fetchNextTokenId?: boolean;
}
interface IGetTokenOptions {
    uniqueSchema?: UniqueCollectionSchemaDecoded | null;
}
declare class SubstrateUnique extends SubstrateCommon {
    getBalance(address: string): Promise<bigint>;
    getCollection(collectionId: number, options?: IGetCollectionOptions): Promise<{
        id: number;
        collectionId: number;
        owner: string;
        ownerNormalized: string;
        mode: string;
        name: string;
        description: string;
        tokenPrefix: string;
        sponsorship: CollectionSponsorship;
        limits: {
            accountTokenOwnershipLimit?: number | null | undefined;
            ownerCanDestroy?: boolean | null | undefined;
            ownerCanTransfer?: boolean | null | undefined;
            sponsorApproveTimeout?: number | null | undefined;
            sponsorTransferTimeout?: number | null | undefined;
            sponsoredDataRateLimit?: number | null | undefined;
            sponsoredDataSize?: number | null | undefined;
            tokenLimit?: number | null | undefined;
            transfersEnabled?: boolean | null | undefined;
        };
        permissions: Required<{
            access?: "Normal" | "AllowList" | undefined;
            mintMode?: boolean | undefined;
            nesting?: {
                tokenOwner: boolean;
                collectionAdmin: boolean;
                restricted: number[];
            } | undefined;
        }>;
        tokenPropertyPermissions: TokenPropertyPermissionObject[];
        properties: PropertiesArray;
        readOnly: boolean;
        effectiveLimits: {
            accountTokenOwnershipLimit?: number | null | undefined;
            ownerCanDestroy?: boolean | null | undefined;
            ownerCanTransfer?: boolean | null | undefined;
            sponsorApproveTimeout?: number | null | undefined;
            sponsorTransferTimeout?: number | null | undefined;
            sponsoredDataRateLimit?: number | null | undefined;
            sponsoredDataSize?: number | null | undefined;
            tokenLimit?: number | null | undefined;
            transfersEnabled?: boolean | null | undefined;
        } | null;
        adminList: CrossAccountId[];
        lastTokenId: number | null;
        uniqueSchema: UniqueCollectionSchemaDecoded | null;
        uniqueSchemaDecodingError: ValidationError | null;
        readonly raw: _polkadot_types.Option<_unique_nft_unique_mainnet_types_default.UpDataStructsRpcCollection>;
        readonly human: _polkadot_types_codec_types.AnyJson;
    } | null>;
    getToken(collectionId: number, tokenId: number, options?: IGetTokenOptions): Promise<{
        collectionId: number;
        tokenId: number;
        owner: CrossAccountId;
        ownerNormalized: CrossAccountId;
        properties: PropertiesArray;
        uniqueToken: UniqueTokenDecoded | null;
        uniqueTokenDecodingError: Error | null;
        readonly raw: _unique_nft_unique_mainnet_types_default_types.UpDataStructsTokenData;
        readonly human: Record<string, _polkadot_types_codec_types.AnyJson>;
    } | null>;
    transferCoins(params: ExtrinsicTransferCoinsParams, options?: ExtrinsicTransferCoinsOptions): ExtrinsicTransferCoins;
    createCollection(params: ExtrinsicCreateCollectionParams, options?: ExtrinsicOptions): ExtrinsicCreateCollection;
    addCollectionAdmin(params: ExtrinsicAddCollectionAdminParams, options?: ExtrinsicOptions): ExtrinsicAddCollectionAdmin;
    removeCollectionAdmin(params: ExtrinsicRemoveCollectionAdminParams, options?: ExtrinsicOptions): ExtrinsicRemoveCollectionAdmin;
    setCollectionSponsor(params: ExtrinsicSetCollectionSponsorParams, options?: ExtrinsicOptions): ExtrinsicSetCollectionSponsor;
    confirmSponsorship(params: ExtrinsicConfirmSponsorshipParams, options?: ExtrinsicOptions): ExtrinsicConfirmSponsorship;
    changeCollectionOwner(params: ExtrinsicChangeCollectionOwnerParams, options?: ExtrinsicOptions): ExtrinsicChangeCollectionOwner;
    removeCollectionSponsor(params: ExtrinsicRemoveCollectionSponsorParams, options?: ExtrinsicOptions): ExtrinsicRemoveCollectionSponsor;
    addToAllowList(params: ExtrinsicAddToAllowListParams, options?: ExtrinsicOptions): ExtrinsicAddToAllowList;
    removeFromAllowList(params: ExtrinsicRemoveFromAllowListParams, options?: ExtrinsicOptions): ExtrinsicRemoveFromAllowList;
    createNftToken(params: ExtrinsicCreateNftTokenParams, options?: ExtrinsicOptions): ExtrinsicCreateNftToken;
    createMultipleNftTokens(params: ExtrinsicCreateMultipleNftTokensParams, options?: ExtrinsicOptions): ExtrinsicCreateMultipleNftTokens;
}

declare const Substrate: {
    Common: typeof SubstrateCommon;
    Unique: typeof SubstrateUnique;
    signer: typeof signerTools;
    extension: typeof extensionTools;
    tools: {
        extrinsic: typeof extrinsicTools;
    };
};

declare namespace SubstrateMethodsParams {
    type TransferCoins = ExtrinsicTransferCoinsParams;
    type CreateCollection = ExtrinsicCreateCollectionParams;
    type AddCollectionAdmin = ExtrinsicAddCollectionAdminParams;
    type RemoveCollectionAdmin = ExtrinsicRemoveCollectionAdminParams;
    type SetCollectionSponsor = ExtrinsicSetCollectionSponsorParams;
    type ConfirmCollectionSponsor = ExtrinsicConfirmSponsorshipParams;
    type AddToAllowList = ExtrinsicAddToAllowListParams;
    type ChangeCollectionOwner = ExtrinsicChangeCollectionOwnerParams;
    type RemoveCollectionSponsor = ExtrinsicRemoveCollectionSponsorParams;
    type RemoveFromAllowList = ExtrinsicRemoveFromAllowListParams;
    type CreateNftToken = ExtrinsicCreateNftToken;
    type CreateMultipleNftTokens = ExtrinsicCreateMultipleNftTokensParams;
}

declare const init: typeof init$1;

export { Coin, Ethereum, Substrate, SubstrateCommon, SubstrateMethodsParams, SubstrateUnique, UniqueUtils, WS_RPC, index as coins, constants$1 as constants, init, libs };