import { Context, ControllerTransferParams, Entity, ModifyPrimaryIssuanceAgentParams, ModifyTokenParams, RedeemTokenParams, TransferTokenOwnershipParams } from "../../../internal";
import { EventIdentifier, HistoricAgentOperation, ProcedureMethod, SubCallback, TokenIdentifier, UnsubCallback } from "../../../types";
import { Checkpoints } from './Checkpoints';
import { Compliance } from './Compliance';
import { CorporateActions } from './CorporateActions';
import { Documents } from './Documents';
import { Issuance } from './Issuance';
import { Offerings } from './Offerings';
import { Permissions } from './Permissions';
import { Settlements } from './Settlements';
import { TokenHolders } from './TokenHolders';
import { TransferRestrictions } from './TransferRestrictions';
import { SecurityTokenDetails } from './types';
/**
 * Properties that uniquely identify a Security Token
 */
export interface UniqueIdentifiers {
    /**
     * ticker of the security token
     */
    ticker: string;
}
/**
 * Class used to manage all the Security Token functionality
 */
export declare class SecurityToken extends Entity<UniqueIdentifiers, string> {
    /**
     * @hidden
     * Check if a value is of type [[UniqueIdentifiers]]
     */
    static isUniqueIdentifiers(identifier: unknown): identifier is UniqueIdentifiers;
    /**
     * identity id of the Security Token
     */
    did: string;
    /**
     * ticker of the Security Token
     */
    ticker: string;
    documents: Documents;
    settlements: Settlements;
    tokenHolders: TokenHolders;
    issuance: Issuance;
    compliance: Compliance;
    transferRestrictions: TransferRestrictions;
    offerings: Offerings;
    checkpoints: Checkpoints;
    corporateActions: CorporateActions;
    permissions: Permissions;
    /**
     * @hidden
     */
    constructor(identifiers: UniqueIdentifiers, context: Context);
    /**
     * Transfer ownership of the Security Token to another Identity. This generates an authorization request that must be accepted
     *   by the destinatary
     *
     * @note this will create [[AuthorizationRequest | Authorization Requests]] which have to be accepted by
     *   the corresponding [[Account | Accounts]] and/or [[Identity | Identities]]. An Account or Identity can
     *   fetch its pending Authorization Requests by calling `authorizations.getReceived`
     */
    transferOwnership: ProcedureMethod<TransferTokenOwnershipParams, SecurityToken>;
    /**
     * Modify some properties of the Security Token
     *
     * @throws if the passed values result in no changes being made to the token
     */
    modify: ProcedureMethod<ModifyTokenParams, SecurityToken>;
    /**
     * Retrieve the Security Token's data
     *
     * @note can be subscribed to
     */
    details(): Promise<SecurityTokenDetails>;
    details(callback: SubCallback<SecurityTokenDetails>): Promise<UnsubCallback>;
    /**
     * Retrieve the Security Token's funding round
     *
     * @note can be subscribed to
     */
    currentFundingRound(): Promise<string>;
    currentFundingRound(callback: SubCallback<string>): Promise<UnsubCallback>;
    /**
     * Retrieve the Security Token's asset identifiers list
     *
     * @note can be subscribed to
     */
    getIdentifiers(): Promise<TokenIdentifier[]>;
    getIdentifiers(callback?: SubCallback<TokenIdentifier[]>): Promise<UnsubCallback>;
    /**
     * Retrieve the identifier data (block number, date and event index) of the event that was emitted when the token was created
     *
     * @note uses the middleware
     * @note there is a possibility that the data is not ready by the time it is requested. In that case, `null` is returned
     */
    createdAt(): Promise<EventIdentifier | null>;
    /**
     * Freezes transfers and minting of the Security Token
     */
    freeze: ProcedureMethod<void, SecurityToken>;
    /**
     * Unfreeze transfers and minting of the Security Token
     */
    unfreeze: ProcedureMethod<void, SecurityToken>;
    /**
     * Check whether transfers are frozen for the Security Token
     *
     * @note can be subscribed to
     */
    isFrozen(): Promise<boolean>;
    isFrozen(callback: SubCallback<boolean>): Promise<UnsubCallback>;
    /**
     * Assign a new primary issuance agent for the Security Token
     *
     * @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`
     *
     * @deprecated in favor of `inviteAgent`
     */
    modifyPrimaryIssuanceAgent: ProcedureMethod<ModifyPrimaryIssuanceAgentParams, void>;
    /**
     * Remove the primary issuance agent of the Security Token
     *
     * @note if primary issuance agent is not set, Security Token owner would be used by default
     *
     * @deprecated
     */
    removePrimaryIssuanceAgent: ProcedureMethod<void, void>;
    /**
     * Redeem (burn) an amount of this Security Token
     *
     * @note Tokens are removed from the caller's Default Portfolio.
     */
    redeem: ProcedureMethod<RedeemTokenParams, void>;
    /**
     * Retrieve the amount of unique investors that hold this Security Token
     *
     * @note this takes into account the Scope ID of Investor Uniqueness Claims. If an investor holds balances
     *   of this token in two or more different Identities, but they all have Investor Uniqueness Claims with the same
     *   Scope ID, then they will only be counted once for the purposes of this result
     *
     * @note can be subscribed to
     */
    investorCount(): Promise<number>;
    investorCount(callback: SubCallback<number>): Promise<UnsubCallback>;
    /**
     * Force a transfer from a given Portfolio to the caller’s default Portfolio
     */
    controllerTransfer: ProcedureMethod<ControllerTransferParams, void>;
    /**
     * Retrieve this Security Token's Operation History
     *
     * @note Operations are grouped by the Agent Identity who performed them
     *
     * @note uses the middleware
     */
    getOperationHistory(): Promise<HistoricAgentOperation[]>;
    /**
     * Determine whether this Security Token exists on chain
     */
    exists(): Promise<boolean>;
    /**
     * Return the Token's ticker
     */
    toJson(): string;
}
//# sourceMappingURL=index.d.ts.map