import { Fraction } from 'fraction.js';
import { UnitSystem } from './UnitSystem.ts';
import { BaseUnitDefinition, DerivedUnitDefinition, FactorDefinition, UnitFormatOptions, UnitFormatPart } from './types.ts';
import { ApproximateEqualityThreshold } from './float.ts';
export declare const UnityFactor: FactorDefinition;
export declare class Unit<U extends Record<string, BaseUnitDefinition>, F extends Record<string, FactorDefinition>, D extends Record<string, DerivedUnitDefinition>> {
    readonly unitSystem: UnitSystem<U, F, D>;
    readonly factor: FactorDefinition;
    readonly baseUnits: Partial<Record<keyof U, Fraction>>;
    constructor(unitSystem: UnitSystem<U, F, D>, factor: FactorDefinition, baseUnits: Partial<Record<keyof U, Fraction>>);
    clone(): Unit<U, F, D>;
    exponentOf(baseUnit: keyof U): Fraction;
    get isZero(): boolean;
    get isUnitless(): boolean;
    inverse(): Unit<U, F, D>;
    isEqual(rhs: Unit<U, F, D>): boolean;
    isApproxEqual(rhs: Unit<U, F, D>, thresholds?: ApproximateEqualityThreshold): boolean;
    /** Compatible units are such that can be added together, i.e. 1 kg + 1 g */
    isCompatible(rhs: Unit<any, any, any>): boolean;
    pow(num: Fraction): Unit<U, F, D>;
    multiply(rhs: Unit<U, F, D> | number): Unit<U, F, D>;
    divide(rhs: Unit<U, F, D>): Unit<U, F, D>;
    withFactor(factor: Partial<FactorDefinition>): Unit<U, F, D>;
    /**
     * Find a more suitable factor for a `value` in the unit this instance represents.
     *
     * This method keeps the same base units, but adjusts the factor to represent the value
     * with the least amount of digits in the non-fractional part.
     *
     * @param value A quantity expressed in the unit this instance represents.
     * @param options Rules for determining the best factor.
     * @returns A unit with the same baseUnits as `this` but with a more suitable factor for `value`
     */
    withBestFactorFor(value: number, opts?: {
        allowDifferentBase?: boolean;
    }): Unit<U, F, D>;
    /**
     * Takes a dimensionless value and multiplies it by this unit's factor.
     * Assuming the value is expressed in this unit, the method converts it
     * to the base unit.
     * @example
     * const unit = SI.parseUnit('km');
     * unit.multiplyValueByFactor(2) // 2_000
     * // because 2 km = 2 000 m
     */
    multiplyValueByFactor(value: number): number;
    /**
     * Takes a dimensionless value and divides it by this unit's factor.
     * Assuming the value is expressed in the base unit, the method converts
     * it to this unit.
     * @example
     * const unit = SI.parseUnit('km');
     * unit.divideValueByFactor(2_000) // 2
     * // because 2 000 m = 2 km
     */
    divideValueByFactor(value: number): number;
    /**
     * Takes another unit, which is compatible with this one, and returns
     * a number such that if you take a quantity expressed in this unit
     * and multiply it by the number, you will have computed the quantity
     * expressed in the provided unit.
     */
    conversionFactorTo(targetUnit: Unit<U, F, D>): number;
    /**
     * Takes another unit, which is compatible with this one, and returns
     * a number such that if you take a quantity expressed in the provided
     * unit and multiply it by the number, you will have computed the quantity
     * expressed in this unit.
     */
    conversionFactorFrom(sourceUnit: Unit<U, F, D>): number;
    toString(opts?: UnitFormatOptions): string;
    toParts(opts?: UnitFormatOptions): UnitFormatPart[];
}