import { BigNumber } from 'bignumber.js';
import { Account, Context, CreateVenueParams, Entity, Instruction, InviteAccountParams, ModifySignerPermissionsParams, RemoveSecondaryKeysParams, SecurityToken, Venue } from "../../../internal";
import { DistributionWithDetails, GroupedInstructions, Order, ProcedureMethod, ResultSet, Role, SecondaryKey, Signer, SubCallback, UnsubCallback } from "../../../types";
import { IdentityAuthorizations } from './IdentityAuthorizations';
import { Portfolios } from './Portfolios';
import { TokenPermissions } from './TokenPermissions';
/**
 * Properties that uniquely identify an Identity
 */
export interface UniqueIdentifiers {
    did: string;
}
/**
 * Represents an Identity in the Polymesh blockchain
 */
export declare class Identity extends Entity<UniqueIdentifiers, string> {
    /**
     * @hidden
     * Checks if a value is of type [[UniqueIdentifiers]]
     */
    static isUniqueIdentifiers(identifier: unknown): identifier is UniqueIdentifiers;
    /**
     * identity ID as stored in the blockchain
     */
    did: string;
    authorizations: IdentityAuthorizations;
    portfolios: Portfolios;
    tokenPermissions: TokenPermissions;
    /**
     * Create an Identity entity
     */
    constructor(identifiers: UniqueIdentifiers, context: Context);
    /**
     * Remove a list of secondary keys associated with the Identity
     */
    removeSecondaryKeys: ProcedureMethod<RemoveSecondaryKeysParams, void>;
    /**
     * Revoke all permissions of a list of secondary keys associated with the Identity
     */
    revokePermissions: ProcedureMethod<{
        secondaryKeys: Signer[];
    }, void>;
    /**
     * Modify all permissions of a list of secondary keys associated with the Identity
     */
    modifyPermissions: ProcedureMethod<ModifySignerPermissionsParams, void>;
    /**
     * Send an invitation to an Account to join this Identity
     *
     * @note this may create AuthorizationRequest which have to be accepted by
     *   the corresponding Account. An Account or Identity can
     *   fetch its pending Authorization Requests by calling `authorizations.getReceived`
     */
    inviteAccount: ProcedureMethod<InviteAccountParams, void>;
    /**
     * Create a Venue
     */
    createVenue: ProcedureMethod<CreateVenueParams, Venue>;
    /**
     * Freeze all the secondary keys in this Identity. This means revoking their permission to perform any operation on the blockchain and freezing their funds until the keys are unfrozen via [[unfreezeSecondaryKeys]]
     */
    freezeSecondaryKeys: ProcedureMethod<void, void>;
    /**
     * Unfreeze all the secondary keys in this Identity. This will restore their permissions as they were before being frozen
     */
    unfreezeSecondaryKeys: ProcedureMethod<void, void>;
    /**
     * Check whether this Identity possesses the specified Role
     */
    hasRole(role: Role): Promise<boolean>;
    /**
     * Retrieve the balance of a particular Security Token
     *
     * @note can be subscribed to
     */
    getTokenBalance(args: {
        ticker: string;
    }): Promise<BigNumber>;
    getTokenBalance(args: {
        ticker: string;
    }, callback: SubCallback<BigNumber>): Promise<UnsubCallback>;
    /**
     * Check whether this Identity has a valid CDD claim
     */
    hasValidCdd(): Promise<boolean>;
    /**
     * Check whether this Identity is Governance Committee member
     */
    isGcMember(): Promise<boolean>;
    /**
     * Check whether this Identity is a CDD provider
     */
    isCddProvider(): Promise<boolean>;
    /**
     * Retrieve the primary key associated with the Identity
     *
     * @note can be subscribed to
     */
    getPrimaryKey(): Promise<Account>;
    getPrimaryKey(callback: SubCallback<Account>): Promise<UnsubCallback>;
    /**
     * Retrieve a list of all tokens which were held at one point by this Identity
     *
     * @note uses the middleware
     * @note supports pagination
     */
    getHeldTokens(opts?: {
        order?: Order;
        size?: number;
        start?: number;
    }): Promise<ResultSet<SecurityToken>>;
    /**
     * Check whether this Identity possesses all specified roles
     */
    hasRoles(roles: Role[]): Promise<boolean>;
    /**
     * Get the list of tokens for which this Identity is a trusted claim issuer
     *
     * @note uses the middleware
     */
    getTrustingTokens(args?: {
        order: Order;
    }): Promise<SecurityToken[]>;
    /**
     * Retrieve all Venues created by this Identity
     *
     * @note can be subscribed to
     */
    getVenues(): Promise<Venue[]>;
    getVenues(callback: SubCallback<Venue[]>): Promise<UnsubCallback>;
    /**
     * Retrieve the Scope ID associated to this Identity's Investor Uniqueness Claim for a specific Security Token
     *
     * @note more on Investor Uniqueness: https://developers.polymesh.live/confidential_identity
     */
    getScopeId(args: {
        token: SecurityToken | string;
    }): Promise<string>;
    /**
     * Retrieve all Instructions where this Identity is a participant,
     *   grouped by status
     */
    getInstructions(): Promise<GroupedInstructions>;
    /**
     * Retrieve all pending Instructions involving this Identity
     *
     * @deprecated in favor of `getInstructions`
     */
    getPendingInstructions(): Promise<Instruction[]>;
    /**
     * Check whether secondary keys are frozen
     *
     * @note can be subscribed to
     */
    areSecondaryKeysFrozen(): Promise<boolean>;
    areSecondaryKeysFrozen(callback: SubCallback<boolean>): Promise<UnsubCallback>;
    /**
     * Retrieve every Dividend Distribution for which this Identity is eligible and hasn't been paid
     *
     * @note uses the middleware
     * @note this query can be potentially **SLOW** depending on which Tokens this Identity has held
     */
    getPendingDistributions(): Promise<DistributionWithDetails[]>;
    /**
     * Get the list of secondary keys related to the Identity
     *
     * @note can be subscribed to
     */
    getSecondaryKeys(): Promise<SecondaryKey[]>;
    getSecondaryKeys(callback: SubCallback<SecondaryKey[]>): Promise<UnsubCallback>;
    /**
     * Determine whether this Identity exists on chain
     */
    exists(): Promise<boolean>;
    /**
     * Return the Identity's DID
     */
    toJson(): string;
}
//# sourceMappingURL=index.d.ts.map