import { HexEncodedString } from '../utils';
import { AccountId, AnchorId, NftId } from './id';
/**
 * An address prepended by its network type.
 */
type Bech32Address = string;
/**
 * Address type variants.
 */
declare enum AddressType {
    /** An Ed25519 address. */
    Ed25519 = 0,
    /** An Account address. */
    Account = 8,
    /** An NFT address. */
    Nft = 16,
    /** An Anchor address. */
    Anchor = 24,
    /** An implicit account creation address. */
    ImplicitAccountCreation = 32,
    /** A Multi address. */
    Multi = 40,
    /** An address with restricted capabilities. */
    Restricted = 48
}
/**
 * The base class for addresses.
 */
declare abstract class Address {
    /**
     * The type of address.
     */
    readonly type: AddressType;
    /**
     * @param type The type of the address.
     */
    constructor(type: AddressType);
    abstract toString(): string;
    /**
     * Parse an address from a JSON string.
     */
    static parse(data: any): Address;
}
/**
 * An Ed25519 Address.
 */
declare class Ed25519Address extends Address {
    /**
     * The public key hash.
     */
    readonly pubKeyHash: HexEncodedString;
    /**
     * @param pubKeyHash BLAKE2b-256 hash of an Ed25519 public key as hex-encoded string.
     */
    constructor(pubKeyHash: HexEncodedString);
    toString(): string;
}
/**
 * An Account address.
 */
declare class AccountAddress extends Address {
    /**
     * The account ID.
     */
    readonly accountId: AccountId;
    /**
     * @param address An account address as account ID.
     */
    constructor(address: AccountId);
    toString(): string;
}
/**
 * An NFT address.
 */
declare class NftAddress extends Address {
    /**
     * The NFT ID.
     */
    readonly nftId: NftId;
    /**
     * @param address An NFT address as NFT ID.
     */
    constructor(address: NftId);
    toString(): string;
}
/**
 * An Anchor address.
 */
declare class AnchorAddress extends Address {
    /**
     * The anchor ID.
     */
    readonly anchorId: AnchorId;
    /**
     * @param address An anchor address as anchor ID.
     */
    constructor(address: AnchorId);
    toString(): string;
}
/**
 * An implicit account creation address that can be used to convert a Basic Output to an Account Output.
 */
declare class ImplicitAccountCreationAddress extends Address {
    private pubKeyHash;
    /**
     * @param pubKeyHash BLAKE2b-256 hash of an Ed25519 public key as hex-encoded string.
     */
    constructor(pubKeyHash: HexEncodedString);
    address(): Ed25519Address;
    toString(): string;
}
/**
 * An address with restricted capabilities.
 */
declare class RestrictedAddress extends Address {
    /**
     * The inner address.
     */
    readonly address: Address;
    /**
     * The allowed capabilities bitflags.
     */
    private allowedCapabilities?;
    /**
     * @param address An address.
     */
    constructor(address: Address);
    setAllowedCapabilities(allowedCapabilities: Uint8Array): void;
    withAllowedCapabilities(allowedCapabilities: Uint8Array): RestrictedAddress;
    getAllowedCapabilities(): Uint8Array;
    toString(): string;
}
/**
 * A weighted address.
 */
declare class WeightedAddress {
    /**
     * The unlocked address.
     */
    readonly address: Address;
    /**
     * The weight of the unlocked address.
     */
    readonly weight: number;
    /**
     * @param address The unlocked address.
     * @param weight The weight of the unlocked address.
     */
    constructor(address: Address, weight: number);
}
/**
 * An address that consists of addresses with weights and a threshold value.
 * The Multi Address can be unlocked if the cumulative weight of all unlocked addresses is equal to or exceeds the
 * threshold.
 */
declare class MultiAddress extends Address {
    /**
     * The weighted unlocked addresses.
     */
    readonly addresses: WeightedAddress[];
    /**
     * The threshold that needs to be reached by the unlocked addresses in order to unlock the multi address.
     */
    readonly threshold: number;
    /**
     * @param addresses The weighted unlocked addresses.
     * @param threshold The threshold that needs to be reached by the unlocked addresses in order to unlock the multi address.
     */
    constructor(addresses: WeightedAddress[], threshold: number);
    toString(): string;
}
declare const AddressDiscriminator: {
    property: string;
    subTypes: ({
        value: typeof Ed25519Address;
        name: any;
    } | {
        value: typeof AccountAddress;
        name: any;
    } | {
        value: typeof NftAddress;
        name: any;
    } | {
        value: typeof AnchorAddress;
        name: any;
    } | {
        value: typeof ImplicitAccountCreationAddress;
        name: any;
    } | {
        value: typeof MultiAddress;
        name: any;
    } | {
        value: typeof RestrictedAddress;
        name: any;
    })[];
};
export { AddressDiscriminator, Bech32Address, Address, AddressType, Ed25519Address, AccountAddress, NftAddress, AnchorAddress, ImplicitAccountCreationAddress, WeightedAddress, MultiAddress, RestrictedAddress, };
