import { ABISerializableObject } from "../serializer/Serializable.js";
import { ABIEncoder } from "../serializer/Encoder.js";
import { ABIDecoder } from "../serializer/Decoder.js";
import { Int64, Int64Type, UInt64 } from "./Integer.js";
import { Name, NameType } from "./Name.js";
export type AssetType = Asset | string;
export declare class Asset implements ABISerializableObject {
    static abiName: string;
    units: Int64;
    symbol: Asset.Symbol;
    static from(value: AssetType): Asset;
    static from(value: number, symbol: Asset.SymbolType): Asset;
    static fromString(value: string): Asset;
    static fromFloat(value: number, symbol: Asset.SymbolType): Asset;
    static fromUnits(value: Int64Type, symbol: Asset.SymbolType): Asset;
    static fromABI(decoder: ABIDecoder): Asset;
    static abiDefault(): Asset;
    static formatUnits(units: Int64Type, precision: number): string;
    constructor(units: Int64, symbol: Asset.Symbol);
    equals(other: AssetType): boolean;
    get value(): number;
    set value(newValue: number);
    get quantity(): string;
    toABI(encoder: ABIEncoder): void;
    toString(): string;
    toJSON(): string;
}
export declare namespace Asset {
    type SymbolType = Symbol | UInt64 | string;
    class Symbol implements ABISerializableObject {
        static abiName: string;
        static maxPrecision: number;
        static from(value: SymbolType): Symbol;
        static fromParts(name: string, precision: number): Symbol;
        static fromABI(decoder: ABIDecoder): Symbol;
        static abiDefault(): Symbol;
        value: UInt64;
        constructor(value: UInt64);
        equals(other: SymbolType): boolean;
        get name(): string;
        get precision(): number;
        get code(): SymbolCode;
        toABI(encoder: ABIEncoder): void;
        /**
         * Convert units to floating point number according to symbol precision.
         * @throws If the given units can't be represented in 53 bits.
         **/
        convertUnits(units: Int64): number;
        /**
         * Convert floating point to units according to symbol precision.
         * Note that the value will be rounded to closest precision.
         **/
        convertFloat(float: number): Int64;
        toString(): string;
        toJSON(): string;
    }
    type SymbolCodeType = SymbolCode | UInt64 | string | number;
    class SymbolCode implements ABISerializableObject {
        static abiName: string;
        static pattern: RegExp;
        static from(value: SymbolCodeType): SymbolCode;
        static fromABI(decoder: ABIDecoder): SymbolCode;
        static abiDefault(): SymbolCode;
        value: UInt64;
        constructor(value: UInt64);
        equals(other: SymbolCodeType): boolean;
        toABI(encoder: ABIEncoder): void;
        toString(): string;
        toJSON(): string;
    }
}
export type ExtendedAssetType = ExtendedAsset | {
    quantity: AssetType;
    contract: NameType;
};
export declare class ExtendedAsset implements ABISerializableObject {
    static abiName: string;
    static from(value: ExtendedAssetType): ExtendedAsset;
    static fromABI(decoder: ABIDecoder): ExtendedAsset;
    quantity: Asset;
    contract: Name;
    constructor(quantity: Asset, contract: Name);
    equals(other: ExtendedAssetType): boolean;
    toABI(encoder: ABIEncoder): void;
    toJSON(): {
        quantity: Asset;
        contract: Name;
    };
}
export type ExtendedSymbolType = ExtendedSymbol | {
    sym: Asset.SymbolType;
    contract: NameType;
};
export declare class ExtendedSymbol implements ABISerializableObject {
    static abiName: string;
    static from(value: ExtendedSymbolType): ExtendedSymbol;
    static fromABI(decoder: ABIDecoder): ExtendedSymbol;
    sym: Asset.Symbol;
    contract: Name;
    constructor(sym: Asset.Symbol, contract: Name);
    equals(other: ExtendedSymbolType): boolean;
    toABI(encoder: ABIEncoder): void;
    toJSON(): {
        sym: Asset.Symbol;
        contract: Name;
    };
}
//# sourceMappingURL=Asset.d.ts.map