import { SlotIndex } from '../slot';
import { Address } from '../address';
import { BlockIssuerKey } from './block-issuer-key';
import { u256, u64 } from '../../utils/type-aliases';
import { EpochIndex } from '../../block/slot';
import { NativeToken } from '../../models/native-token';
import { HexEncodedString } from '../../utils/hex-encoding';
/**
 * Printable ASCII characters.
 */
export declare type PrintableASCII = string;
/**
 * All of the feature block types.
 */
declare enum FeatureType {
    /** A Sender feature. */
    Sender = 0,
    /** An Issuer feature. */
    Issuer = 1,
    /** A Metadata feature. */
    Metadata = 2,
    /** A StateMetadata feature. */
    StateMetadata = 3,
    /** A Tag feature. */
    Tag = 4,
    /** A NativeToken feature. */
    NativeToken = 5,
    /** A BlockIssuer feature. */
    BlockIssuer = 6,
    /** A Staking feature. */
    Staking = 7
}
/** The base class for features. */
declare abstract class Feature {
    readonly type: FeatureType;
    /**
     * @param type The type of feature.
     */
    constructor(type: FeatureType);
}
/**
 * A Sender feature.
 */
declare class SenderFeature extends Feature {
    readonly address: Address;
    /**
     * @param sender The Sender address stored with the feature.
     */
    constructor(sender: Address);
}
/**
 * An Issuer feature.
 */
declare class IssuerFeature extends Feature {
    readonly address: Address;
    /**
     * @param issuer The Issuer address stored with the feature.
     */
    constructor(issuer: Address);
}
/**
 * A Metadata feature.
 */
declare class MetadataFeature extends Feature {
    /** Defines metadata (arbitrary binary data) that will be stored in the output. */
    readonly entries: {
        [key: PrintableASCII]: HexEncodedString;
    };
    /**
     * @param entries The metadata stored with the feature.
     */
    constructor(entries: {
        [key: PrintableASCII]: HexEncodedString;
    });
}
/**
 * A Metadata Feature that can only be changed by the State Controller.
 */
declare class StateMetadataFeature extends Feature {
    /** Defines metadata (arbitrary binary data) that will be stored in the output. */
    readonly entries: {
        [key: PrintableASCII]: HexEncodedString;
    };
    /**
     * @param entries The metadata stored with the feature.
     */
    constructor(entries: {
        [key: PrintableASCII]: HexEncodedString;
    });
}
/**
 * A Tag feature.
 */
declare class TagFeature extends Feature {
    /** Defines a tag for the data. */
    readonly tag: string;
    /**
     * @param tag The tag stored with the feature.
     */
    constructor(tag: string);
}
/**
 * Native token feature.
 */
declare class NativeTokenFeature extends Feature {
    /**
     * Identifier of the native token.
     */
    readonly id: HexEncodedString;
    /**
     * Amount of native tokens of the given Token ID.
     */
    readonly amount: u256;
    /**
     * Creates a new `NativeTokenFeature`.
     * @param id The identifier of the native token.
     * @param amount The native token amount.
     */
    constructor(id: HexEncodedString, amount: u256);
    /**
     * Returns the native token contained in this feature.
     */
    asNativeToken(): NativeToken;
}
/**
 * Block Issuer feature.
 */
declare class BlockIssuerFeature extends Feature {
    /**
     * The slot index at which the Block Issuer Feature expires and can be removed.
     */
    readonly expirySlot: SlotIndex;
    /**
     * The Block Issuer Keys.
     */
    readonly blockIssuerKeys: BlockIssuerKey[];
    constructor(expirySlot: SlotIndex, blockIssuerKeys: BlockIssuerKey[]);
}
/**
 * Staking feature.
 */
declare class StakingFeature extends Feature {
    /**
     * The amount of coins that are locked and staked in the containing account.
     **/
    readonly stakedAmount: u64;
    /**
     * The fixed cost of the validator, which it receives as part of its Mana rewards.
     */
    readonly fixedCost: u64;
    /**
     * The epoch index in which the staking started.
     */
    readonly startEpoch: EpochIndex;
    /**
     * The epoch index in which the staking ends.
     */
    readonly endEpoch: EpochIndex;
    constructor(stakedAmount: u64, fixedCost: u64, startEpoch: EpochIndex, endEpoch: EpochIndex);
}
declare const FeatureDiscriminator: {
    property: string;
    subTypes: ({
        value: typeof SenderFeature;
        name: any;
    } | {
        value: typeof MetadataFeature;
        name: any;
    } | {
        value: typeof TagFeature;
        name: any;
    } | {
        value: typeof NativeTokenFeature;
        name: any;
    } | {
        value: typeof BlockIssuerFeature;
        name: any;
    } | {
        value: typeof StakingFeature;
        name: any;
    })[];
};
export { FeatureDiscriminator, Feature, FeatureType, SenderFeature, IssuerFeature, MetadataFeature, StateMetadataFeature, TagFeature, NativeTokenFeature, BlockIssuerFeature, StakingFeature, };
