import { ApiPromise } from '@polkadot/api';
import { Sdk } from '@unique-nft/sdk';
import { QueryMethod, MutationMethodWrap } from '@unique-nft/sdk/extrinsics';
import { CollectionSchemaVersion, CollectionFields, Address, TokenPropertyPermissions, TransferCollectionArguments, UnsignedTxPayload, BurnCollectionArguments, TokenInfo, CreateTokenArguments, TokenPayload } from '@unique-nft/sdk/types';
import { INamespace } from 'protobufjs';
import { UpDataStructsTokenData } from '@unique-nft/unique-mainnet-types';
import { Registry } from '@polkadot/types/types';
import { UpDataStructsCreateCollectionData, UpDataStructsRpcCollection } from '@unique-nft/unique-mainnet-types/default';

interface CollectionLimits {
    accountTokenOwnershipLimit?: number | null;
    sponsoredDataSize?: number | null;
    sponsoredDataRateLimit?: number | null;
    tokenLimit?: number | null;
    sponsorTransferTimeout?: number | null;
    sponsorApproveTimeout?: number | null;
    ownerCanTransfer?: boolean | null;
    ownerCanDestroy?: boolean | null;
    transfersEnabled?: boolean | null;
}
interface SetCollectionLimitsArguments {
    limits: CollectionLimits;
    address: string;
    collectionId: number;
}
interface SetCollectionLimitsResult {
    collectionId: number;
    limits: CollectionLimits;
}

declare enum CollectionMode {
    Nft = "Nft",
    Fungible = "Fungible",
    ReFungible = "ReFungible"
}
declare enum MetaUpdatePermission {
    ItemOwner = "ItemOwner",
    Admin = "Admin",
    None = "None"
}
declare enum CollectionAccess {
    Normal = "Normal",
    AllowList = "AllowList"
}
interface CollectionNestingPermissions {
    tokenOwner: boolean;
    collectionAdmin: boolean;
}
interface CollectionPermissions {
    access?: CollectionAccess | `${CollectionAccess}`;
    mintMode?: boolean;
    nesting?: CollectionNestingPermissions;
}
interface CollectionProperties {
    offchainSchema?: string;
    schemaVersion?: CollectionSchemaVersion | `${CollectionSchemaVersion}`;
    variableOnChainSchema?: string | null;
    constOnChainSchema?: INamespace | null;
    fields?: CollectionFields;
}
declare enum CollectionPropertiesKeys {
    offchainSchema = "_old_offchainSchema",
    schemaVersion = "_old_schemaVersion",
    variableOnChainSchema = "_old_variableOnChainSchema",
    constOnChainSchema = "_old_constOnChainSchema"
}
interface CollectionSponsorship {
    address: Address;
    isConfirmed: boolean;
}
interface TokenPropertiesPermissions {
    constData?: TokenPropertyPermissions;
}
interface CollectionInfoBase {
    mode?: CollectionMode | `${CollectionMode}`;
    name: string;
    description: string;
    tokenPrefix: string;
    sponsorship?: CollectionSponsorship | null;
    limits?: CollectionLimits;
    metaUpdatePermission?: MetaUpdatePermission | `${MetaUpdatePermission}`;
    properties: CollectionProperties;
    permissions?: CollectionPermissions;
    tokenPropertyPermissions?: TokenPropertiesPermissions;
}
interface CreateCollectionArguments extends CollectionInfoBase {
    address: Address;
}

interface GetCollectionLimitsResult {
    collectionId: number;
    limits: CollectionLimits;
}

interface CollectionIdArguments {
    collectionId: number;
}
interface CollectionInfo extends CollectionInfoBase {
    id: number;
    owner: string;
}

declare type NestTokenParentArguments = {
    collectionId: number;
    tokenId: number;
};
declare type NestTokenNestedArguments = {
    collectionId: number;
    tokenId: number;
};
declare type NestTokenArguments = {
    parent: NestTokenParentArguments;
    nested: NestTokenNestedArguments;
    address: Address;
};
declare type NestTokenResult = {
    collectionId: number;
    tokenId: number;
};

declare type UnnestTokenParentArguments = {
    collectionId: number;
    tokenId: number;
};
declare type UnnestTokenNestedArguments = {
    collectionId: number;
    tokenId: number;
};
declare type UnnestTokenArguments = {
    parent: UnnestTokenParentArguments;
    nested: UnnestTokenNestedArguments;
    address: Address;
};
declare type UnnestTokenResult = {
    collectionId: number;
    tokenId: number;
};

declare type TokenChildrenArguments = {
    collectionId: number;
    tokenId: number;
};
declare type TokenChildrenResult = TokenChildrenArguments[];

declare type TokenParentArguments = {
    collectionId: number;
    tokenId: number;
};
declare type TokenParentResult = {
    collectionId: number;
    tokenId: number;
    address: Address;
};

declare type TopmostTokenOwnerArguments = {
    collectionId: number;
    tokenId: number;
    blockHashAt?: string;
};
declare type TopmostTokenOwnerResult = Address;

interface TokenIdArguments extends CollectionIdArguments {
    tokenId: number;
}
interface BurnTokenArguments extends TokenIdArguments {
    address: string;
}
interface TransferTokenArguments extends TokenIdArguments {
    from: string;
    to: string;
}

declare class SdkCollections {
    readonly sdk: Sdk;
    constructor(sdk: Sdk);
    get: QueryMethod<CollectionIdArguments, CollectionInfo>;
    creation: MutationMethodWrap<CreateCollectionArguments, CollectionIdArguments>;
    getLimits: QueryMethod<CollectionIdArguments, GetCollectionLimitsResult>;
    setLimits: MutationMethodWrap<SetCollectionLimitsArguments, SetCollectionLimitsResult>;
    transfer(args: TransferCollectionArguments): Promise<UnsignedTxPayload>;
    burn(args: BurnCollectionArguments): Promise<UnsignedTxPayload>;
}

declare class SdkTokens {
    readonly sdk: Sdk;
    constructor(sdk: Sdk);
    nest: MutationMethodWrap<NestTokenArguments, NestTokenResult>;
    unnest: MutationMethodWrap<UnnestTokenArguments, UnnestTokenResult>;
    children: QueryMethod<TokenChildrenArguments, TokenChildrenResult>;
    parent: QueryMethod<TokenParentArguments, TokenParentResult>;
    topmostOwner: QueryMethod<TopmostTokenOwnerArguments, TopmostTokenOwnerResult>;
    get({ collectionId, tokenId, }: TokenIdArguments): Promise<TokenInfo | null>;
    create(args: CreateTokenArguments): Promise<UnsignedTxPayload>;
    transfer({ from, to, collectionId, tokenId, }: TransferTokenArguments): Promise<UnsignedTxPayload>;
    burn({ address, collectionId, tokenId, }: BurnTokenArguments): Promise<UnsignedTxPayload>;
}

declare module '@unique-nft/sdk' {
    interface Sdk {
        api: ApiPromise;
        readonly collections: SdkCollections;
        readonly tokens: SdkTokens;
    }
}

declare const encodeToken: (constData?: Record<string, any> | undefined, constOnChainSchema?: INamespace | null | undefined) => TokenPayload;

declare const decodeToken: (collection: CollectionInfo, tokenId: number, tokenData: UpDataStructsTokenData) => TokenInfo;

declare const encodeCollection: (registry: Registry, collectionInfo: Partial<CollectionInfo>) => UpDataStructsCreateCollectionData;

declare const decodeCollection: (collection: UpDataStructsRpcCollection) => CollectionInfoBase;

declare function getNestingTokenAddress(collectionId: number, tokenId: number): string;
declare function isNestingAddress(address: Address): boolean;
declare function getCollectionIdFromNestingAddress(address: Address): number;
declare function getTokenIdFromNestingAddress(address: Address): number;

export { BurnTokenArguments, CollectionAccess, CollectionIdArguments, CollectionInfo, CollectionInfoBase, CollectionLimits, CollectionMode, CollectionNestingPermissions, CollectionPermissions, CollectionProperties, CollectionPropertiesKeys, CollectionSponsorship, CreateCollectionArguments, MetaUpdatePermission, NestTokenArguments, NestTokenNestedArguments, NestTokenParentArguments, NestTokenResult, SdkCollections, SdkTokens, SetCollectionLimitsArguments, SetCollectionLimitsResult, TokenChildrenArguments, TokenChildrenResult, TokenIdArguments, TokenParentArguments, TokenParentResult, TokenPropertiesPermissions, TopmostTokenOwnerArguments, TopmostTokenOwnerResult, TransferTokenArguments, UnnestTokenArguments, UnnestTokenNestedArguments, UnnestTokenParentArguments, UnnestTokenResult, decodeCollection, decodeToken, encodeCollection, encodeToken, getCollectionIdFromNestingAddress, getNestingTokenAddress, getTokenIdFromNestingAddress, isNestingAddress };