import BigNumber from 'bignumber.js';
import { Context, Entity, Identity } from "../../internal";
import { Authorization, ProcedureMethod, Signer, SignerValue } from "../../types";
import { HumanReadableType } from "../../types/utils";
export interface UniqueIdentifiers {
    authId: BigNumber;
}
interface HumanReadable {
    issuer: HumanReadableType<Identity>;
    expiry: string | null;
    target: SignerValue;
    data: HumanReadableType<Authorization>;
    id: string;
}
export interface Params {
    target: Signer;
    issuer: Identity;
    expiry: Date | null;
    data: Authorization;
}
/**
 * Represents a request made by an Identity to another Identity (or account) for some sort of authorization. This has multiple uses. For example, if Alice
 *   wants to transfer ownership of her asset ALICETOKEN to Bob, an authorization request gets emitted to Bob,
 *   who then has to accept it in order for the ownership transfer to be complete
 */
export declare class AuthorizationRequest extends Entity<UniqueIdentifiers, HumanReadable> {
    /**
     * @hidden
     * Check if a value is of type [[UniqueIdentifiers]]
     */
    static isUniqueIdentifiers(identifier: unknown): identifier is UniqueIdentifiers;
    /**
     * Identity or Account to which the request was emitted
     */
    target: Signer;
    /**
     * Identity that emitted the request
     */
    issuer: Identity;
    /**
     * authorization request data corresponding to type of authorization
     *
     * | Type                        | Data                            |
     * |-----------------------------|---------------------------------|
     * | Add Relayer Paying Key      | Beneficiary, Relayer, Allowance |
     * | Become Agent                | Permission Group
     * | Attest Primary Key Rotation | DID                             |
     * | Rotate Primary Key          | DID                             |
     * | Transfer Ticker             | Ticker                          |
     * | Add MultiSig Signer         | Account                         |
     * | Transfer Token Ownership    | Ticker                          |
     * | Join Identity               | DID                             |
     * | Portfolio Custody           | Portfolio                       |
     */
    data: Authorization;
    /**
     * date at which the authorization request expires and can no longer be accepted.
     *   At this point, a new authorization request must be emitted. Null if the request never expires
     */
    expiry: Date | null;
    /**
     * internal identifier for the request (used to accept/reject/cancel)
     */
    authId: BigNumber;
    /**
     * @hidden
     */
    constructor(args: UniqueIdentifiers & Params, context: Context);
    /**
     * Accept the authorization request. You must be the target of the request to be able to accept it
     */
    accept: ProcedureMethod<void, void>;
    /**
     * Remove the authorization request
     *
     * - If you are the request issuer, this will cancel the authorization
     * - If you are the request target, this will reject the authorization
     */
    remove: ProcedureMethod<void, void>;
    /**
     * Returns whether the Authorization Request has expired
     */
    isExpired(): boolean;
    /**
     * Determine whether this Authorization Request exists on chain
     */
    exists(): Promise<boolean>;
    /**
     * Return the Authorization's static data
     */
    toJson(): HumanReadable;
}
export {};
//# sourceMappingURL=AuthorizationRequest.d.ts.map