import BigNumber from 'bignumber.js';
import { HumanReadable as CorporateActionHumanReadable, Params as CorporateActionParams, UniqueIdentifiers } from "../CorporateAction";
import { Checkpoint, CheckpointSchedule, Context, CorporateActionBase, DefaultPortfolio, Identity, ModifyCaCheckpointParams, NumberedPortfolio, PayDividendsParams } from "../../../internal";
import { CorporateActionKind, DistributionPayment, DividendDistributionDetails, InputCaCheckpoint, NoArgsProcedureMethod, ProcedureMethod, ResultSet } from "../../../types";
import { HumanReadableType, Modify } from "../../../types/utils";
import { DistributionParticipant } from './types';
interface HumanReadable extends CorporateActionHumanReadable {
    origin: HumanReadableType<DefaultPortfolio | NumberedPortfolio>;
    currency: string;
    perShare: string;
    maxAmount: string;
    expiryDate: string | null;
    paymentDate: string;
}
export interface DividendDistributionParams {
    origin: DefaultPortfolio | NumberedPortfolio;
    currency: string;
    perShare: BigNumber;
    maxAmount: BigNumber;
    expiryDate: null | Date;
    paymentDate: Date;
}
export declare type Params = CorporateActionParams & DividendDistributionParams;
/**
 * Represents a Corporate Action via which an Asset issuer wishes to distribute dividends
 *   between a subset of the Asset Holders (targets)
 */
export declare class DividendDistribution extends CorporateActionBase {
    /**
     * Portfolio from which the dividends will be distributed
     */
    origin: DefaultPortfolio | NumberedPortfolio;
    /**
     * ticker of the currency in which dividends are being distributed
     */
    currency: string;
    /**
     * amount of `currency` to pay for each share held by the Asset Holders
     */
    perShare: BigNumber;
    /**
     * maximum amount of `currency` to be distributed. Distributions are "first come, first served", so funds can be depleted before
     *   every Asset Holder receives their corresponding amount
     */
    maxAmount: BigNumber;
    /**
     * date after which dividends can no longer be paid/reclaimed. A null value means the distribution never expires
     */
    expiryDate: null | Date;
    /**
     * date starting from which dividends can be paid/reclaimed
     */
    paymentDate: Date;
    /**
     * type of dividend distribution being represented. The chain enforces it to be either PredictableBenefit or UnpredictableBenefit
     */
    protected kind: CorporateActionKind.UnpredictableBenefit | CorporateActionKind.PredictableBenefit;
    /**
     * @hidden
     */
    constructor(args: UniqueIdentifiers & Params, context: Context);
    /**
     * Claim the Dividends corresponding to the current Identity
     *
     * @note if `currency` is indivisible, the Identity's share will be rounded down to the nearest integer (after taxes are withheld)
     */
    claim: NoArgsProcedureMethod<void>;
    /**
     * Modify the Distribution's Checkpoint
     */
    modifyCheckpoint: ProcedureMethod<Modify<ModifyCaCheckpointParams, {
        checkpoint: InputCaCheckpoint;
    }>, void>;
    /**
     * Transfer the corresponding share of the dividends to a list of Identities
     *
     * @note due to performance issues, we do not validate that the distribution has enough remaining funds to pay the corresponding amount to the supplied Identities
     * @note if `currency` is indivisible, the Identity's share will be rounded down to the nearest integer (after taxes are withheld)
     */
    pay: ProcedureMethod<PayDividendsParams, void>;
    /**
     * Reclaim any remaining funds back to the origin Portfolio. This can only be done after the Distribution has expired
     *
     * @note withheld taxes are also reclaimed in the same transaction
     *
     * @note required roles:
     *   - Origin Portfolio Custodian
     */
    reclaimFunds: NoArgsProcedureMethod<void>;
    /**
     * Retrieve the Checkpoint associated with this Dividend Distribution. If the Checkpoint is scheduled and has not been created yet,
     *   the corresponding CheckpointSchedule is returned instead
     */
    checkpoint(): Promise<Checkpoint | CheckpointSchedule>;
    /**
     * Retrieve whether the Distribution exists
     */
    exists(): Promise<boolean>;
    /**
     * Retrieve details associated with this Dividend Distribution
     */
    details(): Promise<DividendDistributionDetails>;
    /**
     * Retrieve a comprehensive list of all Identities that are entitled to dividends in this Distribution (participants),
     *   the amount they are entitled to and whether they have been paid or not
     *
     * @note this request can take a lot of time with large amounts of Asset Holders
     * @note if the Distribution Checkpoint hasn't been created yet, the result will be an empty array.
     *   This is because the Distribution participants cannot be determined without a Checkpoint
     */
    getParticipants(): Promise<DistributionParticipant[]>;
    /**
     * Retrieve an Identity that is entitled to dividends in this Distribution (participant),
     *   the amount it is entitled to and whether it has been paid or not
     *
     * @param args.identity - defaults to the current Identity
     *
     * @note if the Distribution Checkpoint hasn't been created yet, the result will be null.
     *   This is because the Distribution participant's corresponding payment cannot be determined without a Checkpoint
     */
    getParticipant(args?: {
        identity: string | Identity;
    }): Promise<DistributionParticipant | null>;
    /**
     * @hidden
     */
    private fetchDistribution;
    /**
     * Retrieve the amount of taxes that have been withheld up to this point in this Distribution
     *
     * @note uses the middleware
     */
    getWithheldTax(): Promise<BigNumber>;
    /**
     * Retrieve the payment history for this Distribution
     *
     * @note uses the middleware
     * @note supports pagination
     */
    getPaymentHistory(opts?: {
        size?: number;
        start?: number;
    }): Promise<ResultSet<DistributionPayment>>;
    /**
     * @hidden
     */
    private getParticipantStatuses;
    /**
     * Return the Dividend Distribution's static data
     */
    toJson(): HumanReadable;
}
export {};
//# sourceMappingURL=index.d.ts.map