@budiauktioner/buildi-primitives 0.1.0 → 0.2.0

package/dist/types/weight-C5C7OuV_.d.cts

@@ -0,0 +1,1057 @@
+import { M as MeasurementUnit, c as MeasurementUnitIndex, D as Decimal, Q as Quantity } from './length-XRL5Eg7F.cjs';
+import { P as PrimitiveTypeInfo, T as TextCandidate } from './text-candidate-qg2bD9PY.cjs';
+
+/**
+ * A unit of area identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class AreaUnit extends MeasurementUnit {
+    private readonly __areaUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly SquareMillimeter: AreaUnit;
+    static readonly SquareCentimeter: AreaUnit;
+    static readonly SquareMeter: AreaUnit;
+    static readonly SquareKilometer: AreaUnit;
+    static readonly Hectare: AreaUnit;
+    static readonly Acre: AreaUnit;
+    static readonly SquareFoot: AreaUnit;
+    static readonly SquareInch: AreaUnit;
+    static readonly SquareYard: AreaUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<AreaUnit>;
+    static get all(): readonly AreaUnit[];
+    /** The base unit: m². */
+    static get baseUnit(): AreaUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly AreaUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): AreaUnit | null;
+    static parse(input: string): AreaUnit;
+    /** Returns the most human-readable unit for a value in m². */
+    static getNatural(baseValue: Decimal): AreaUnit;
+}
+
+/** Options for {@link Area.format} and {@link Area.normalize}. */
+interface AreaFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: AreaUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A area stored internally in square meters,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Area extends Quantity<AreaUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<AreaUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: AreaUnit): this;
+    get squareMillimeters(): number;
+    get squareCentimeters(): number;
+    get squareMeters(): number;
+    get squareKilometers(): number;
+    get hectares(): number;
+    get acres(): number;
+    get squareFeet(): number;
+    get squareInches(): number;
+    get squareYards(): number;
+    /** Creates a area from a value and unit. */
+    static create(value: number | Decimal, unit: AreaUnit): Area;
+    static fromSquareMillimeters(value: number | Decimal): Area;
+    static fromSquareCentimeters(value: number | Decimal): Area;
+    static fromSquareMeters(value: number | Decimal): Area;
+    static fromSquareKilometers(value: number | Decimal): Area;
+    static fromHectares(value: number | Decimal): Area;
+    static fromAcres(value: number | Decimal): Area;
+    static fromSquareFeet(value: number | Decimal): Area;
+    static fromSquareInches(value: number | Decimal): Area;
+    static fromSquareYards(value: number | Decimal): Area;
+    static tryParse(input: string | null | undefined): Area | null;
+    static parse(input: string): Area;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: AreaFormatOptions): string | null;
+    /** The value in square meters, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: AreaFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Area>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked area, e.g. `10 m²` becomes `*** m²`. */
+declare function maskArea(value: Area): string;
+
+/**
+ * A unit of electric current identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class ElectricCurrentUnit extends MeasurementUnit {
+    private readonly __electricCurrentUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Microampere: ElectricCurrentUnit;
+    static readonly Milliampere: ElectricCurrentUnit;
+    static readonly Ampere: ElectricCurrentUnit;
+    static readonly Kiloampere: ElectricCurrentUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<ElectricCurrentUnit>;
+    static get all(): readonly ElectricCurrentUnit[];
+    /** The base unit: A. */
+    static get baseUnit(): ElectricCurrentUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly ElectricCurrentUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): ElectricCurrentUnit | null;
+    static parse(input: string): ElectricCurrentUnit;
+    /** Returns the most human-readable unit for a value in A. */
+    static getNatural(baseValue: Decimal): ElectricCurrentUnit;
+}
+
+/** Options for {@link ElectricCurrent.format} and {@link ElectricCurrent.normalize}. */
+interface ElectricCurrentFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: ElectricCurrentUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A electric current stored internally in amperes,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class ElectricCurrent extends Quantity<ElectricCurrentUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<ElectricCurrentUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: ElectricCurrentUnit): this;
+    get microamperes(): number;
+    get milliamperes(): number;
+    get amperes(): number;
+    get kiloamperes(): number;
+    /** Creates a electric current from a value and unit. */
+    static create(value: number | Decimal, unit: ElectricCurrentUnit): ElectricCurrent;
+    static fromMicroamperes(value: number | Decimal): ElectricCurrent;
+    static fromMilliamperes(value: number | Decimal): ElectricCurrent;
+    static fromAmperes(value: number | Decimal): ElectricCurrent;
+    static fromKiloamperes(value: number | Decimal): ElectricCurrent;
+    static tryParse(input: string | null | undefined): ElectricCurrent | null;
+    static parse(input: string): ElectricCurrent;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: ElectricCurrentFormatOptions): string | null;
+    /** The value in amperes, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: ElectricCurrentFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<ElectricCurrent>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked electric current, e.g. `10 A` becomes `*** A`. */
+declare function maskElectricCurrent(value: ElectricCurrent): string;
+
+/**
+ * A unit of flow rate identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class FlowRateUnit extends MeasurementUnit {
+    private readonly __flowRateUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly LitersPerSecond: FlowRateUnit;
+    static readonly LitersPerMinute: FlowRateUnit;
+    static readonly LitersPerHour: FlowRateUnit;
+    static readonly CubicMetersPerHour: FlowRateUnit;
+    static readonly CubicMetersPerMinute: FlowRateUnit;
+    static readonly GallonsPerMinute: FlowRateUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<FlowRateUnit>;
+    static get all(): readonly FlowRateUnit[];
+    /** The base unit: L/min. */
+    static get baseUnit(): FlowRateUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly FlowRateUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): FlowRateUnit | null;
+    static parse(input: string): FlowRateUnit;
+    /** Returns the most human-readable unit for a value in L/min. */
+    static getNatural(baseValue: Decimal): FlowRateUnit;
+}
+
+/** Options for {@link FlowRate.format} and {@link FlowRate.normalize}. */
+interface FlowRateFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: FlowRateUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A flow rate stored internally in liters per minute,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class FlowRate extends Quantity<FlowRateUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<FlowRateUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: FlowRateUnit): this;
+    get litersPerSecond(): number;
+    get litersPerMinute(): number;
+    get litersPerHour(): number;
+    get cubicMetersPerHour(): number;
+    get cubicMetersPerMinute(): number;
+    get gallonsPerMinute(): number;
+    /** Creates a flow rate from a value and unit. */
+    static create(value: number | Decimal, unit: FlowRateUnit): FlowRate;
+    static fromLitersPerSecond(value: number | Decimal): FlowRate;
+    static fromLitersPerMinute(value: number | Decimal): FlowRate;
+    static fromLitersPerHour(value: number | Decimal): FlowRate;
+    static fromCubicMetersPerHour(value: number | Decimal): FlowRate;
+    static fromCubicMetersPerMinute(value: number | Decimal): FlowRate;
+    static fromGallonsPerMinute(value: number | Decimal): FlowRate;
+    static tryParse(input: string | null | undefined): FlowRate | null;
+    static parse(input: string): FlowRate;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: FlowRateFormatOptions): string | null;
+    /** The value in liters per minute, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: FlowRateFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<FlowRate>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked flow rate, e.g. `10 L/min` becomes `*** L/min`. */
+declare function maskFlowRate(value: FlowRate): string;
+
+/**
+ * A unit of luminance identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class LuminanceUnit extends MeasurementUnit {
+    private readonly __luminanceUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly CandelaPerSquareMetre: LuminanceUnit;
+    static readonly Nit: LuminanceUnit;
+    static readonly KilocandelaPerSquareMetre: LuminanceUnit;
+    static readonly Kilonit: LuminanceUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<LuminanceUnit>;
+    static get all(): readonly LuminanceUnit[];
+    /** The base unit: cd/m². */
+    static get baseUnit(): LuminanceUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly LuminanceUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): LuminanceUnit | null;
+    static parse(input: string): LuminanceUnit;
+    /** Returns the most human-readable unit for a value in cd/m². */
+    static getNatural(baseValue: Decimal): LuminanceUnit;
+}
+
+/** Options for {@link Luminance.format} and {@link Luminance.normalize}. */
+interface LuminanceFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: LuminanceUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A luminance stored internally in candela per square metre,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Luminance extends Quantity<LuminanceUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<LuminanceUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: LuminanceUnit): this;
+    get candelaPerSquareMetre(): number;
+    get nits(): number;
+    get kilocandelaPerSquareMetre(): number;
+    /** Creates a luminance from a value and unit. */
+    static create(value: number | Decimal, unit: LuminanceUnit): Luminance;
+    static fromCandelaPerSquareMetre(value: number | Decimal): Luminance;
+    static fromNits(value: number | Decimal): Luminance;
+    static fromKilocandelaPerSquareMetre(value: number | Decimal): Luminance;
+    /**
+     * A bare number is read as candela per square metre, since screen brightness
+     * is quoted that way. Negative luminance is rejected.
+     */
+    static tryParse(input: string | null | undefined): Luminance | null;
+    static parse(input: string): Luminance;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: LuminanceFormatOptions): string | null;
+    /** The value in candela per square metre, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: LuminanceFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Luminance>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked luminance, e.g. `10 cd/m²` becomes `*** cd/m²`. */
+declare function maskLuminance(value: Luminance): string;
+
+/**
+ * A unit of luminous flux identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class LuminousFluxUnit extends MeasurementUnit {
+    private readonly __luminousFluxUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Lumen: LuminousFluxUnit;
+    static readonly Kilolumen: LuminousFluxUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<LuminousFluxUnit>;
+    static get all(): readonly LuminousFluxUnit[];
+    /** The base unit: lm. */
+    static get baseUnit(): LuminousFluxUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly LuminousFluxUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): LuminousFluxUnit | null;
+    static parse(input: string): LuminousFluxUnit;
+    /** Returns the most human-readable unit for a value in lm. */
+    static getNatural(baseValue: Decimal): LuminousFluxUnit;
+}
+
+/** Options for {@link LuminousFlux.format} and {@link LuminousFlux.normalize}. */
+interface LuminousFluxFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: LuminousFluxUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A luminous flux stored internally in lumens,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class LuminousFlux extends Quantity<LuminousFluxUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<LuminousFluxUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: LuminousFluxUnit): this;
+    get lumens(): number;
+    get kilolumens(): number;
+    /** Creates a luminous flux from a value and unit. */
+    static create(value: number | Decimal, unit: LuminousFluxUnit): LuminousFlux;
+    static fromLumens(value: number | Decimal): LuminousFlux;
+    static fromKilolumens(value: number | Decimal): LuminousFlux;
+    static tryParse(input: string | null | undefined): LuminousFlux | null;
+    static parse(input: string): LuminousFlux;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: LuminousFluxFormatOptions): string | null;
+    /** The value in lumens, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: LuminousFluxFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<LuminousFlux>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked luminous flux, e.g. `10 lm` becomes `*** lm`. */
+declare function maskLuminousFlux(value: LuminousFlux): string;
+
+/** Options for {@link Percentage.format} and {@link Percentage.normalize}. */
+interface PercentageFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A proportion from 0 to 100 percent, held internally as a fraction from 0 to
+ * 1.
+ *
+ * Input without a percent sign is read on whichever scale fits: `0.85` is a
+ * fraction, `85` is a percentage, and anything above 100 is rejected. With a
+ * sign or the word `procent` / `percent` the percentage scale is explicit.
+ */
+declare class Percentage {
+    private readonly fraction;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    private constructor();
+    /** The value as a fraction from 0 to 1, e.g. `0.85` for 85%. */
+    get value(): number;
+    /** The value on a 0–100 scale, e.g. `85` for 85%. */
+    get percent(): number;
+    /** Creates a percentage from a 0–1 fraction, e.g. `0.85` for 85%. */
+    static fromDecimal(value: number | Decimal): Percentage;
+    /** Creates a percentage from a 0–100 value, e.g. `85` for 85%. */
+    static fromPercent(percent: number | Decimal): Percentage;
+    /** Creates a percentage from a 0–100 value; the same as {@link fromPercent}. */
+    static create(percent: number | Decimal): Percentage;
+    static tryParse(input: string | null | undefined): Percentage | null;
+    static parse(input: string): Percentage;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form with a percent sign, e.g. `85%`. */
+    static format(input: string | null | undefined, options?: PercentageFormatOptions): string | null;
+    /** The fraction as an invariant decimal string, e.g. `0.85`. */
+    static normalize(input: string | null | undefined, options?: PercentageFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** The fraction, e.g. `0.85`. */
+    toNormalizedString(): string;
+    /** The value with a percent sign, e.g. `85%`. */
+    toString(): string;
+    plus(other: Percentage): Percentage;
+    minus(other: Percentage): Percentage;
+    times(factor: number | Decimal): Percentage;
+    dividedBy(divisor: number | Decimal): Percentage;
+    compareTo(other: Percentage | null | undefined): number;
+    equals(other: Percentage | null | undefined): boolean;
+    isLessThan(other: Percentage): boolean;
+    isGreaterThan(other: Percentage): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Percentage>[];
+}
+/** Returns a masked percentage, e.g. `85%` becomes `***%`. */
+declare function maskPercentage(percentage: Percentage): string;
+
+/**
+ * The frequency weighting curve applied to a sound measurement.
+ */
+declare const SoundWeighting: {
+    /** No weighting: a flat response. */
+    readonly Unweighted: 0;
+    /** A-weighting, which approximates human hearing sensitivity. */
+    readonly A: 1;
+    /** B-weighting, an intermediate curve that is rarely used. */
+    readonly B: 2;
+    /** C-weighting, flat across most audible frequencies. */
+    readonly C: 3;
+    /** Z-weighting, zero weighting, flat from 10 Hz to 20 kHz. */
+    readonly Z: 4;
+};
+type SoundWeighting = (typeof SoundWeighting)[keyof typeof SoundWeighting];
+/** Options for {@link SoundLevel.format} and {@link SoundLevel.normalize}. */
+interface SoundLevelFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A sound pressure level in decibels, optionally carrying a frequency
+ * weighting — `85 dB`, `69 dB(A)`, `40 dBZ`.
+ *
+ * The decibel unit is missing from many inputs in practice, so a bare number is
+ * accepted and read as unweighted decibels.
+ */
+declare class SoundLevel {
+    private readonly decibelsValue;
+    /** The frequency weighting applied to this measurement. */
+    readonly weighting: SoundWeighting;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The display form, e.g. `69 dB(A)`. */
+    readonly value: string;
+    private constructor();
+    /** The numeric decibel value, e.g. `69`. */
+    get decibels(): number;
+    /** Creates a sound level from a value and weighting. */
+    static create(value: number | Decimal, weighting: SoundWeighting): SoundLevel;
+    /** Creates an unweighted sound level, e.g. `85 dB`. */
+    static fromDecibels(value: number | Decimal): SoundLevel;
+    /** Creates an A-weighted sound level, e.g. `69 dB(A)`. */
+    static fromDecibelA(value: number | Decimal): SoundLevel;
+    static tryParse(input: string | null | undefined): SoundLevel | null;
+    static parse(input: string): SoundLevel;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form, e.g. `69 dB(A)`. */
+    static format(input: string | null | undefined, options?: SoundLevelFormatOptions): string | null;
+    /** Canonical form, e.g. `69 dB(A)`. */
+    static normalize(input: string | null | undefined, options?: SoundLevelFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    compareTo(other: SoundLevel | null | undefined): number;
+    equals(other: SoundLevel | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<SoundLevel>[];
+}
+/** Returns a masked sound level, e.g. `69 dB(A)` becomes `*** dB(A)`. */
+declare function maskSoundLevel(soundLevel: SoundLevel): string;
+
+/**
+ * A unit of pressure identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class PressureUnit extends MeasurementUnit {
+    private readonly __pressureUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Pascal: PressureUnit;
+    static readonly Hectopascal: PressureUnit;
+    static readonly Kilopascal: PressureUnit;
+    static readonly Megapascal: PressureUnit;
+    static readonly Gigapascal: PressureUnit;
+    static readonly Bar: PressureUnit;
+    static readonly Millibar: PressureUnit;
+    static readonly Psi: PressureUnit;
+    static readonly Atmosphere: PressureUnit;
+    static readonly MillimeterOfMercury: PressureUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<PressureUnit>;
+    static get all(): readonly PressureUnit[];
+    /** The base unit: Pa. */
+    static get baseUnit(): PressureUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly PressureUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): PressureUnit | null;
+    static parse(input: string): PressureUnit;
+    /** Returns the most human-readable unit for a value in Pa. */
+    static getNatural(baseValue: Decimal): PressureUnit;
+}
+
+/** Options for {@link Pressure.format} and {@link Pressure.normalize}. */
+interface PressureFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: PressureUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A pressure stored internally in pascals,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Pressure extends Quantity<PressureUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<PressureUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: PressureUnit): this;
+    get pascals(): number;
+    get hectopascals(): number;
+    get kilopascals(): number;
+    get megapascals(): number;
+    get gigapascals(): number;
+    get bars(): number;
+    get millibars(): number;
+    get psi(): number;
+    get atmospheres(): number;
+    get millimetersOfMercury(): number;
+    /** Creates a pressure from a value and unit. */
+    static create(value: number | Decimal, unit: PressureUnit): Pressure;
+    static fromPascals(value: number | Decimal): Pressure;
+    static fromHectopascals(value: number | Decimal): Pressure;
+    static fromKilopascals(value: number | Decimal): Pressure;
+    static fromMegapascals(value: number | Decimal): Pressure;
+    static fromGigapascals(value: number | Decimal): Pressure;
+    static fromBars(value: number | Decimal): Pressure;
+    static fromMillibars(value: number | Decimal): Pressure;
+    static fromPsi(value: number | Decimal): Pressure;
+    static fromAtmospheres(value: number | Decimal): Pressure;
+    static fromMillimetersOfMercury(value: number | Decimal): Pressure;
+    static tryParse(input: string | null | undefined): Pressure | null;
+    static parse(input: string): Pressure;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: PressureFormatOptions): string | null;
+    /** The value in pascals, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: PressureFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Pressure>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked pressure, e.g. `10 Pa` becomes `*** Pa`. */
+declare function maskPressure(value: Pressure): string;
+
+/**
+ * A unit of rotational speed identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class RotationalSpeedUnit extends MeasurementUnit {
+    private readonly __rotationalSpeedUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Rpm: RotationalSpeedUnit;
+    static readonly Rps: RotationalSpeedUnit;
+    static readonly RadiansPerSecond: RotationalSpeedUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<RotationalSpeedUnit>;
+    static get all(): readonly RotationalSpeedUnit[];
+    /** The base unit: rpm. */
+    static get baseUnit(): RotationalSpeedUnit;
+    /** Empty — this dimension has no curated display scale in .NET either. */
+    static get naturalScale(): readonly RotationalSpeedUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): RotationalSpeedUnit | null;
+    static parse(input: string): RotationalSpeedUnit;
+    /** Returns the most human-readable unit for a value in rpm. */
+    static getNatural(baseValue: Decimal): RotationalSpeedUnit;
+}
+
+/** Options for {@link RotationalSpeed.format} and {@link RotationalSpeed.normalize}. */
+interface RotationalSpeedFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: RotationalSpeedUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A rotational speed stored internally in revolutions per minute,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class RotationalSpeed extends Quantity<RotationalSpeedUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<RotationalSpeedUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: RotationalSpeedUnit): this;
+    get rpm(): number;
+    get rps(): number;
+    get radiansPerSecond(): number;
+    /** Creates a rotational speed from a value and unit. */
+    static create(value: number | Decimal, unit: RotationalSpeedUnit): RotationalSpeed;
+    static fromRpm(value: number | Decimal): RotationalSpeed;
+    static fromRps(value: number | Decimal): RotationalSpeed;
+    static fromRadiansPerSecond(value: number | Decimal): RotationalSpeed;
+    /** A bare number is read as rpm, the unit rotational speed is usually quoted in. */
+    static tryParse(input: string | null | undefined): RotationalSpeed | null;
+    static parse(input: string): RotationalSpeed;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: RotationalSpeedFormatOptions): string | null;
+    /** The value in revolutions per minute, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: RotationalSpeedFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<RotationalSpeed>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked rotational speed, e.g. `10 rpm` becomes `*** rpm`. */
+declare function maskRotationalSpeed(value: RotationalSpeed): string;
+
+/**
+ * A unit of speed identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class SpeedUnit extends MeasurementUnit {
+    private readonly __speedUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly MetersPerSecond: SpeedUnit;
+    static readonly KilometersPerHour: SpeedUnit;
+    static readonly MilesPerHour: SpeedUnit;
+    static readonly FeetPerSecond: SpeedUnit;
+    static readonly Knot: SpeedUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<SpeedUnit>;
+    static get all(): readonly SpeedUnit[];
+    /** The base unit: m/s. */
+    static get baseUnit(): SpeedUnit;
+    /** Empty — this dimension has no curated display scale in .NET either. */
+    static get naturalScale(): readonly SpeedUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): SpeedUnit | null;
+    static parse(input: string): SpeedUnit;
+    /** Returns the most human-readable unit for a value in m/s. */
+    static getNatural(baseValue: Decimal): SpeedUnit;
+}
+
+/** Options for {@link Speed.format} and {@link Speed.normalize}. */
+interface SpeedFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: SpeedUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A speed stored internally in meters per second,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Speed extends Quantity<SpeedUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<SpeedUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: SpeedUnit): this;
+    get metersPerSecond(): number;
+    get kilometersPerHour(): number;
+    get milesPerHour(): number;
+    get feetPerSecond(): number;
+    get knots(): number;
+    /** Creates a speed from a value and unit. */
+    static create(value: number | Decimal, unit: SpeedUnit): Speed;
+    static fromMetersPerSecond(value: number | Decimal): Speed;
+    static fromKilometersPerHour(value: number | Decimal): Speed;
+    static fromMilesPerHour(value: number | Decimal): Speed;
+    static fromFeetPerSecond(value: number | Decimal): Speed;
+    static fromKnots(value: number | Decimal): Speed;
+    static tryParse(input: string | null | undefined): Speed | null;
+    static parse(input: string): Speed;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: SpeedFormatOptions): string | null;
+    /** The value in meters per second, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: SpeedFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Speed>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked speed, e.g. `10 m/s` becomes `*** m/s`. */
+declare function maskSpeed(value: Speed): string;
+
+/**
+ * A temperature difference, stored in kelvin.
+ *
+ * Differences do not carry the offset that absolute temperatures do: one kelvin
+ * of difference is one degree Celsius, while a Fahrenheit interval scales by
+ * 9/5. Subtracting two {@link Temperature} values produces one of these.
+ */
+declare class TemperatureDelta {
+    private readonly deltaKelvin;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    private constructor();
+    /** The interval in kelvin, numerically the same as {@link celsius}. */
+    get kelvin(): number;
+    /** The interval in degrees Celsius, numerically the same as {@link kelvin}. */
+    get celsius(): number;
+    /** The interval in degrees Fahrenheit, so a 5 K interval is 9 °F. */
+    get fahrenheit(): number;
+    /** @internal The exact interval in kelvin, for {@link Temperature} arithmetic. */
+    get exactKelvin(): Decimal;
+    static fromKelvin(value: number | Decimal): TemperatureDelta;
+    static fromCelsius(value: number | Decimal): TemperatureDelta;
+    static fromFahrenheit(value: number | Decimal): TemperatureDelta;
+    plus(other: TemperatureDelta): TemperatureDelta;
+    minus(other: TemperatureDelta): TemperatureDelta;
+    times(factor: number | Decimal): TemperatureDelta;
+    dividedBy(divisor: number | Decimal): TemperatureDelta;
+    negated(): TemperatureDelta;
+    compareTo(other: TemperatureDelta | null | undefined): number;
+    equals(other: TemperatureDelta | null | undefined): boolean;
+    isLessThan(other: TemperatureDelta): boolean;
+    isGreaterThan(other: TemperatureDelta): boolean;
+    private fahrenheitDecimal;
+}
+
+/**
+ * A temperature scale identified by its symbol.
+ *
+ * Unlike every other unit in this namespace, temperature scales carry no
+ * conversion factor: Celsius, Fahrenheit and kelvin differ by an offset as well
+ * as a scale, so {@link Temperature} converts between them explicitly. That is
+ * also why this class does not share the common unit machinery.
+ */
+declare class TemperatureUnit {
+    private readonly __temperatureUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    private static index;
+    readonly symbol: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly pluralEnglish: string;
+    readonly pluralSwedish: string;
+    readonly aliases: readonly string[];
+    private constructor();
+    static readonly Celsius: TemperatureUnit;
+    static readonly Fahrenheit: TemperatureUnit;
+    static readonly Kelvin: TemperatureUnit;
+    private static readonly units;
+    static get all(): readonly TemperatureUnit[];
+    /** The SI base unit for thermodynamic temperature: kelvin. */
+    static get baseUnit(): TemperatureUnit;
+    /** Resolves a scale from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): TemperatureUnit | null;
+    static parse(input: string): TemperatureUnit;
+    static assertOwns(unit: unknown): asserts unit is TemperatureUnit;
+    toString(): string;
+    private static symbolIndex;
+}
+
+/** Options for {@link Temperature.format} and {@link Temperature.normalize}. */
+interface TemperatureFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this scale instead of preserving the parsed one. */
+    unit?: TemperatureUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * An absolute temperature stored internally in kelvin, parsed from Celsius,
+ * Fahrenheit or kelvin.
+ *
+ * This is the one dimension that cannot share the machinery the other
+ * measurement types use: its scales differ by an offset as well as a factor, so
+ * conversion is affine rather than a single multiplication.
+ *
+ * Sources:
+ * - https://www.bipm.org/en/measurement-units/si-base-units — kelvin definition
+ * - https://en.wikipedia.org/wiki/Conversion_of_units
+ */
+declare class Temperature {
+    private readonly kelvinValue;
+    /** The scale the value was originally parsed or created from. */
+    readonly originalUnit: TemperatureUnit;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    private constructor();
+    /** The value in degrees Celsius, so `0` at the ice point. */
+    get celsius(): number;
+    /** The value in degrees Fahrenheit, so `32` at 0 °C. */
+    get fahrenheit(): number;
+    /** The value in kelvin. */
+    get kelvin(): number;
+    /** The exact value converted to `unit`. */
+    inDecimal(unit: TemperatureUnit): Decimal;
+    /** The value converted to `unit`, as a `number` for ergonomic access. */
+    in(unit: TemperatureUnit): number;
+    static fromCelsius(value: number | Decimal): Temperature;
+    static fromFahrenheit(value: number | Decimal): Temperature;
+    static fromKelvin(value: number | Decimal): Temperature;
+    /** Creates a temperature from a value on the given scale. */
+    static create(value: number | Decimal, unit: TemperatureUnit): Temperature;
+    static tryParse(input: string | null | undefined): Temperature | null;
+    static parse(input: string): Temperature;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form on the parsed scale, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: TemperatureFormatOptions): string | null;
+    /** The value in kelvin, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: TemperatureFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** The value in kelvin, e.g. `293.15 K`. */
+    toNormalizedString(): string;
+    /** The value on the scale it was parsed from, e.g. `20 °C`. */
+    toString(): string;
+    /** The value converted to `unit`, e.g. `68 °F`. */
+    toStringInUnit(unit: TemperatureUnit, decimals?: number): string;
+    /** Adds a temperature difference, keeping the original scale. */
+    plus(delta: TemperatureDelta): Temperature;
+    /** Subtracts a temperature difference, keeping the original scale. */
+    minus(delta: TemperatureDelta): Temperature;
+    /** The difference between two temperatures. */
+    difference(other: Temperature): TemperatureDelta;
+    compareTo(other: Temperature | null | undefined): number;
+    equals(other: Temperature | null | undefined): boolean;
+    isLessThan(other: Temperature): boolean;
+    isGreaterThan(other: Temperature): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Temperature>[];
+    private static fallback;
+}
+/** Returns a masked temperature, e.g. `20 °C` becomes `*** °C`. */
+declare function maskTemperature(value: Temperature): string;
+
+/**
+ * A unit of torque identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class TorqueUnit extends MeasurementUnit {
+    private readonly __torqueUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly NewtonMeter: TorqueUnit;
+    static readonly MillinewtonMeter: TorqueUnit;
+    static readonly KilonewtonMeter: TorqueUnit;
+    static readonly FootPound: TorqueUnit;
+    static readonly KilogramForceMeter: TorqueUnit;
+    static readonly InchPound: TorqueUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<TorqueUnit>;
+    static get all(): readonly TorqueUnit[];
+    /** The base unit: Nm. */
+    static get baseUnit(): TorqueUnit;
+    /** Empty — this dimension has no curated display scale in .NET either. */
+    static get naturalScale(): readonly TorqueUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): TorqueUnit | null;
+    static parse(input: string): TorqueUnit;
+    /** Returns the most human-readable unit for a value in Nm. */
+    static getNatural(baseValue: Decimal): TorqueUnit;
+}
+
+/** Options for {@link Torque.format} and {@link Torque.normalize}. */
+interface TorqueFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: TorqueUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A torque stored internally in newton meters,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Torque extends Quantity<TorqueUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<TorqueUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: TorqueUnit): this;
+    get millinewtonMeters(): number;
+    get newtonMeters(): number;
+    get kilonewtonMeters(): number;
+    get footPounds(): number;
+    get kilogramForceMeters(): number;
+    get inchPounds(): number;
+    /** Creates a torque from a value and unit. */
+    static create(value: number | Decimal, unit: TorqueUnit): Torque;
+    static fromMillinewtonMeters(value: number | Decimal): Torque;
+    static fromNewtonMeters(value: number | Decimal): Torque;
+    static fromKilonewtonMeters(value: number | Decimal): Torque;
+    static fromFootPounds(value: number | Decimal): Torque;
+    static fromKilogramForceMeters(value: number | Decimal): Torque;
+    static fromInchPounds(value: number | Decimal): Torque;
+    static tryParse(input: string | null | undefined): Torque | null;
+    static parse(input: string): Torque;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: TorqueFormatOptions): string | null;
+    /** The value in newton meters, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: TorqueFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Torque>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked torque, e.g. `10 Nm` becomes `*** Nm`. */
+declare function maskTorque(value: Torque): string;
+
+/**
+ * A unit of voltage identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class VoltageUnit extends MeasurementUnit {
+    private readonly __voltageUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Microvolt: VoltageUnit;
+    static readonly Millivolt: VoltageUnit;
+    static readonly Volt: VoltageUnit;
+    static readonly Kilovolt: VoltageUnit;
+    static readonly Megavolt: VoltageUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<VoltageUnit>;
+    static get all(): readonly VoltageUnit[];
+    /** The base unit: V. */
+    static get baseUnit(): VoltageUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly VoltageUnit[];
+    /**
+     * Resolves a unit from a symbol, name, plural or alias, case-insensitively —
+     * except for `mV` and `MV`, which differ by a factor of a billion and are
+     * therefore the one case-sensitive pair.
+     */
+    static tryParse(input: string | null | undefined): VoltageUnit | null;
+    static parse(input: string): VoltageUnit;
+    /** Returns the most human-readable unit for a value in V. */
+    static getNatural(baseValue: Decimal): VoltageUnit;
+}
+
+/** Options for {@link Voltage.format} and {@link Voltage.normalize}. */
+interface VoltageFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: VoltageUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A voltage stored internally in volts,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Voltage extends Quantity<VoltageUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<VoltageUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: VoltageUnit): this;
+    get microvolts(): number;
+    get millivolts(): number;
+    get volts(): number;
+    get kilovolts(): number;
+    get megavolts(): number;
+    /** Creates a voltage from a value and unit. */
+    static create(value: number | Decimal, unit: VoltageUnit): Voltage;
+    static fromMicrovolts(value: number | Decimal): Voltage;
+    static fromMillivolts(value: number | Decimal): Voltage;
+    static fromVolts(value: number | Decimal): Voltage;
+    static fromKilovolts(value: number | Decimal): Voltage;
+    static fromMegavolts(value: number | Decimal): Voltage;
+    static tryParse(input: string | null | undefined): Voltage | null;
+    static parse(input: string): Voltage;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: VoltageFormatOptions): string | null;
+    /** The value in volts, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: VoltageFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Voltage>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked voltage, e.g. `10 V` becomes `*** V`. */
+declare function maskVoltage(value: Voltage): string;
+
+/**
+ * A unit of weight identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class WeightUnit extends MeasurementUnit {
+    private readonly __weightUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Microgram: WeightUnit;
+    static readonly Milligram: WeightUnit;
+    static readonly Gram: WeightUnit;
+    static readonly Hectogram: WeightUnit;
+    static readonly Kilogram: WeightUnit;
+    static readonly MetricTon: WeightUnit;
+    static readonly Pound: WeightUnit;
+    static readonly Ounce: WeightUnit;
+    static readonly Stone: WeightUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<WeightUnit>;
+    static get all(): readonly WeightUnit[];
+    /** The base unit: kg. */
+    static get baseUnit(): WeightUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly WeightUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): WeightUnit | null;
+    static parse(input: string): WeightUnit;
+    /** Returns the most human-readable unit for a value in kg. */
+    static getNatural(baseValue: Decimal): WeightUnit;
+}
+
+/** Options for {@link Weight.format} and {@link Weight.normalize}. */
+interface WeightFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: WeightUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A weight stored internally in kilograms,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Weight extends Quantity<WeightUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<WeightUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: WeightUnit): this;
+    get micrograms(): number;
+    get milligrams(): number;
+    get grams(): number;
+    get hectograms(): number;
+    get kilograms(): number;
+    get metricTons(): number;
+    get pounds(): number;
+    get ounces(): number;
+    get stones(): number;
+    /** Creates a weight from a value and unit. */
+    static create(value: number | Decimal, unit: WeightUnit): Weight;
+    static fromMicrograms(value: number | Decimal): Weight;
+    static fromMilligrams(value: number | Decimal): Weight;
+    static fromGrams(value: number | Decimal): Weight;
+    static fromHectograms(value: number | Decimal): Weight;
+    static fromKilograms(value: number | Decimal): Weight;
+    static fromMetricTons(value: number | Decimal): Weight;
+    static fromPounds(value: number | Decimal): Weight;
+    static fromOunces(value: number | Decimal): Weight;
+    static fromStones(value: number | Decimal): Weight;
+    static tryParse(input: string | null | undefined): Weight | null;
+    static parse(input: string): Weight;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: WeightFormatOptions): string | null;
+    /** The value in kilograms, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: WeightFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Weight>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked weight, e.g. `10 kg` becomes `*** kg`. */
+declare function maskWeight(value: Weight): string;
+
+export { maskTorque as $, Area as A, type TorqueFormatOptions as B, TorqueUnit as C, type VoltageFormatOptions as D, ElectricCurrent as E, FlowRate as F, VoltageUnit as G, type WeightFormatOptions as H, WeightUnit as I, maskArea as J, maskElectricCurrent as K, Luminance as L, maskFlowRate as M, maskLuminance as N, maskLuminousFlux as O, Percentage as P, maskPercentage as Q, RotationalSpeed as R, SoundLevel as S, Temperature as T, maskPressure as U, Voltage as V, Weight as W, maskRotationalSpeed as X, maskSoundLevel as Y, maskSpeed as Z, maskTemperature as _, type AreaFormatOptions as a, maskVoltage as a0, maskWeight as a1, AreaUnit as b, type ElectricCurrentFormatOptions as c, ElectricCurrentUnit as d, type FlowRateFormatOptions as e, FlowRateUnit as f, type LuminanceFormatOptions as g, LuminanceUnit as h, LuminousFlux as i, type LuminousFluxFormatOptions as j, LuminousFluxUnit as k, type PercentageFormatOptions as l, Pressure as m, type PressureFormatOptions as n, PressureUnit as o, type RotationalSpeedFormatOptions as p, RotationalSpeedUnit as q, type SoundLevelFormatOptions as r, SoundWeighting as s, Speed as t, type SpeedFormatOptions as u, SpeedUnit as v, TemperatureDelta as w, type TemperatureFormatOptions as x, TemperatureUnit as y, Torque as z };