@budiauktioner/buildi-primitives 0.1.1 → 0.2.1

package/dist/types/length-XRL5Eg7F.d.cts

@@ -0,0 +1,354 @@
+import { P as PrimitiveTypeInfo, T as TextCandidate } from './text-candidate-qg2bD9PY.cjs';
+
+/**
+ * Exact base-10 arithmetic matching the observable semantics of .NET
+ * `System.Decimal`, which is what every `Measurement` quantity in
+ * `Buildi.Primitives` stores its value as.
+ *
+ * A binary `number` cannot stand in here. Unit conversion multiplies by exact
+ * decimal factors, and the result is what `normalize()` writes out as the
+ * canonical storage form:
+ *
+ * ```text
+ * 3 ft -> meters      number: 0.9144000000000001      decimal: 0.9144
+ * ```
+ *
+ * Since `isNormalized(input)` is defined as `input === normalize(input)`, that
+ * drift would break the contract the package is built around, and would fail
+ * the parity vectors ported from the .NET test suite.
+ *
+ * A value is `units / 10 ** scale`. Both the 96-bit magnitude limit and the
+ * maximum scale of 28 are reproduced so that inputs .NET rejects as overflow
+ * are rejected here too.
+ *
+ * Equivalent of .NET `System.Decimal`. Internal; not re-exported publicly.
+ */
+/**
+ * How to break a tie when discarding digits.
+ *
+ * .NET uses `HalfEven` for arithmetic (verified: `1m / 536870912m` yields
+ * `0.0000000018626451492309570312`, keeping the even `2` where away-from-zero
+ * would produce `3`), while `Math.Round(x, n, MidpointRounding.AwayFromZero)`
+ * is what the quantity formatters ask for explicitly.
+ */
+type RoundingMode = "half-even" | "away-from-zero";
+declare class Decimal {
+    private readonly units;
+    private readonly scale;
+    static readonly zero: Decimal;
+    static readonly one: Decimal;
+    private constructor();
+    /**
+     * Drops scale until the value fits in 96 bits and 28 fractional digits.
+     *
+     * .NET reduces precision before it gives up, which is why `1e-16 * 1e-16`
+     * yields a scale-28 zero rather than throwing.
+     */
+    private static fit;
+    /** Builds a value from an integer. Throws if it does not fit. */
+    static fromBigInt(value: bigint): Decimal;
+    /**
+     * Parses a plain decimal literal such as `-12.750`. Trailing zeros are
+     * significant and preserved, as in .NET. Exponent notation is not accepted.
+     * Returns `null` when the input is malformed or too large.
+     */
+    static parse(input: string): Decimal | null;
+    /**
+     * Converts a `number`, expanding the exponent notation JavaScript uses for
+     * very large and very small magnitudes so that `1e-7` parses as
+     * `0.0000001`. Returns `null` for non-finite input or a magnitude outside the
+     * representable range.
+     */
+    static fromNumber(value: number): Decimal | null;
+    get isZero(): boolean;
+    get isNegative(): boolean;
+    plus(other: Decimal): Decimal;
+    minus(other: Decimal): Decimal;
+    /** Scales add, as in .NET: `1.0 * 1.0` is `1.00`. */
+    times(other: Decimal): Decimal;
+    /**
+     * Divides at the highest precision that still fits, which is how .NET arrives
+     * at `1m / 0.0254m === 39.370078740157480314960629921` — 27 fractional
+     * digits, because 28 would not fit in 96 bits.
+     *
+     * Unlike the other operations, division discards trailing zeros down to a
+     * preferred scale of `dividend scale - divisor scale`. That is what makes
+     * `536870912m / 2.5m` come out as `214748364.8` while `1.00m / 2m` keeps both
+     * digits as `0.50`.
+     */
+    dividedBy(other: Decimal): Decimal;
+    negated(): Decimal;
+    abs(): Decimal;
+    /**
+     * Rounds to `decimals` fractional digits. Asking for more digits than the
+     * value carries leaves it untouched, matching .NET `Math.Round`.
+     */
+    round(decimals: number, mode?: RoundingMode): Decimal;
+    /** Compares by value; scale is ignored, so `1.0` and `1.00` are equal. */
+    compareTo(other: Decimal): number;
+    equals(other: Decimal): boolean;
+    /** Renders with trailing zeros intact, as .NET does. */
+    toString(): string;
+    /**
+     * Renders without trailing fractional zeros, e.g. `0.9144` rather than
+     * `0.914400`. This is the form the quantity types display.
+     */
+    toTrimmedString(): string;
+    /**
+     * Converts to a binary `number` for ergonomic consumer-facing accessors.
+     * Lossy beyond 17 significant digits — never round-trip a value through this
+     * on the normalization path.
+     */
+    toNumber(): number;
+}
+
+/**
+ * Shared machinery for the `Measurement` unit classes (`LengthUnit`,
+ * `PowerUnit`, and the rest).
+ *
+ * In .NET each of these is a hand-written class repeating the same symbol
+ * index, natural-scale walk and lookup. Repetition is free there; here it would
+ * be bytes shipped to a browser for all nineteen dimensions, so the shared part
+ * lives once and each public unit class supplies only its table.
+ *
+ * Internal; not re-exported publicly.
+ */
+
+/** The fields every unit in a dimension carries. */
+interface MeasurementUnitDefinition {
+    readonly symbol: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly pluralEnglish: string;
+    readonly pluralSwedish: string;
+    /** Multiply a value in this unit by this factor to reach the base unit. */
+    readonly toBaseUnitFactor: Decimal;
+    /**
+     * Exact conversion as a `[numerator, denominator]` pair, for units whose
+     * factor is a repeating decimal — 1/60 for rpm, 1/3600 for coulomb, 1000/3600
+     * for km/h. Multiplying by the rounded factor and dividing by it are not
+     * inverses, so both directions go through the ratio instead. .NET
+     * special-cases exactly these units for the same reason.
+     */
+    readonly exactRatio?: readonly [numerator: Decimal, denominator: Decimal];
+    readonly aliases?: readonly string[];
+}
+declare class MeasurementUnit {
+    readonly symbol: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly pluralEnglish: string;
+    readonly pluralSwedish: string;
+    readonly toBaseUnitFactor: Decimal;
+    readonly aliases: readonly string[];
+    private readonly exactRatio;
+    protected constructor(definition: MeasurementUnitDefinition);
+    /** Converts a value expressed in this unit into the dimension's base unit. */
+    toBase(value: Decimal): Decimal;
+    /** Converts a value expressed in the base unit into this unit. */
+    fromBase(baseValue: Decimal): Decimal;
+    toString(): string;
+}
+/**
+ * Case-insensitive lookup over a dimension's units plus the natural-scale walk
+ * used for display.
+ */
+declare class MeasurementUnitIndex<TUnit extends MeasurementUnit> {
+    readonly all: readonly TUnit[];
+    readonly baseUnit: TUnit;
+    readonly naturalScale: readonly TUnit[];
+    private readonly symbolsExcludedFromIndex;
+    private readonly index;
+    private readonly ownedUnits;
+    constructor(all: readonly TUnit[], baseUnit: TUnit, 
+    /** Metric units ordered small to large, used to auto-scale display. */
+    naturalScale: readonly TUnit[], 
+    /**
+     * Units whose symbol is deliberately left out of the index because it
+     * collides case-insensitively with another unit's — `mW` against `MW`. The
+     * owning class resolves those itself.
+     */
+    symbolsExcludedFromIndex?: readonly TUnit[]);
+    assertOwns(unit: MeasurementUnit): asserts unit is TUnit;
+    /**
+     * Matches on symbol, English and Swedish names, plurals and aliases. Earlier
+     * units win a collision, mirroring the `TryAdd` order in .NET.
+     */
+    tryParse(input: string | null | undefined): TUnit | null;
+    /**
+     * Picks the largest unit on the natural scale where the magnitude is still at
+     * least one, so 1500 meters displays as `1.5 km`.
+     */
+    getNatural(baseValue: Decimal): TUnit;
+    private buildSymbolIndex;
+}
+
+/**
+ * Shared behaviour for the `Measurement` quantity types (`Length`, `Power`,
+ * `Weight`, and the rest).
+ *
+ * Each of those is ~230 near-identical lines in .NET. Here the common half —
+ * parsing, conversion, formatting, comparison and arithmetic — lives once, and
+ * a public type supplies its unit table plus the named accessors that make its
+ * API readable.
+ *
+ * The value is held in the base unit as an exact {@link Decimal}. Converting
+ * only at the formatting boundary is what keeps `normalize()` byte-identical to
+ * .NET; see the note at the top of `decimal.ts`.
+ *
+ * Internal; not re-exported publicly.
+ */
+
+declare abstract class Quantity<TUnit extends MeasurementUnit> {
+    /** The value expressed in the dimension's base unit. */
+    protected readonly baseValue: Decimal;
+    /** The unit the value was originally parsed from. */
+    readonly originalUnit: TUnit;
+    protected constructor(
+    /** The value expressed in the dimension's base unit. */
+    baseValue: Decimal, 
+    /** The unit the value was originally parsed from. */
+    originalUnit: TUnit);
+    /** The unit index for this dimension, supplied by the concrete type. */
+    protected abstract get units(): MeasurementUnitIndex<TUnit>;
+    /** Builds another instance of the concrete type, used by the arithmetic. */
+    protected abstract withBaseValue(baseValue: Decimal, unit: TUnit): this;
+    /** The exact value converted to `unit`. */
+    inDecimal(unit: TUnit): Decimal;
+    /** The value converted to `unit`, as a `number` for ergonomic access. */
+    in(unit: TUnit): number;
+    /** The most human-readable unit on this dimension's natural scale. */
+    get naturalUnit(): TUnit;
+    /** The value in the base unit, e.g. `10000 m`. */
+    toNormalizedString(): string;
+    /** The value in the unit it was parsed from, e.g. `10 km`. */
+    toString(): string;
+    /** The value converted to `unit`, e.g. `0.01 km`. */
+    toStringInUnit(unit: TUnit, decimals?: number): string;
+    /** The value in the most readable unit, e.g. `1.5 km` rather than `1500 m`. */
+    toNaturalString(decimals?: number): string;
+    plus(other: Quantity<TUnit>): this;
+    minus(other: Quantity<TUnit>): this;
+    times(factor: number | Decimal): this;
+    dividedBy(divisor: number | Decimal): this;
+    negated(): this;
+    compareTo(other: Quantity<TUnit> | null | undefined): number;
+    equals(other: Quantity<TUnit> | null | undefined): boolean;
+    isLessThan(other: Quantity<TUnit>): boolean;
+    isGreaterThan(other: Quantity<TUnit>): boolean;
+    private assertSameDimension;
+}
+
+/**
+ * A unit of length identified by its symbol. Each unit carries English and
+ * Swedish names, singular and plural forms, and an exact conversion factor to
+ * the base SI unit (meter).
+ */
+declare class LengthUnit extends MeasurementUnit {
+    private readonly __lengthUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Nanometer: LengthUnit;
+    static readonly Micrometer: LengthUnit;
+    static readonly Millimeter: LengthUnit;
+    static readonly Centimeter: LengthUnit;
+    static readonly Decimeter: LengthUnit;
+    static readonly Meter: LengthUnit;
+    static readonly Kilometer: LengthUnit;
+    static readonly Inch: LengthUnit;
+    static readonly Foot: LengthUnit;
+    static readonly Yard: LengthUnit;
+    static readonly Mile: LengthUnit;
+    static readonly NauticalMile: LengthUnit;
+    /** The Swedish `mil`, which is 10 km — not the international mile. */
+    static readonly SwedishMile: LengthUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<LengthUnit>;
+    static get all(): readonly LengthUnit[];
+    /** The base SI unit: meter. */
+    static get baseUnit(): LengthUnit;
+    /**
+     * Metric units ordered small to large, used to auto-scale display. Imperial
+     * and niche units are excluded.
+     */
+    static get naturalScale(): readonly LengthUnit[];
+    /**
+     * Resolves a unit from a symbol, name, plural or alias, case-insensitively.
+     *
+     * `NM` is the one case-sensitive exception: uppercase means nautical mile,
+     * while `nm` is nanometer.
+     */
+    static tryParse(input: string | null | undefined): LengthUnit | null;
+    static parse(input: string): LengthUnit;
+    /** Returns the most human-readable unit for a value in meters. */
+    static getNatural(meters: Decimal): LengthUnit;
+}
+
+/** Options for {@link Length.format} and {@link Length.normalize}. */
+interface LengthFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: LengthUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A length stored internally in meters, parsed from any supported unit format
+ * such as `10 km`, `5.5 cm` or `3 ft`, and convertible between metric and
+ * imperial units.
+ *
+ * Sources:
+ * - https://www.bipm.org/en/measurement-units/si-base-units — meter definition
+ * - https://en.wikipedia.org/wiki/Conversion_of_units
+ */
+declare class Length extends Quantity<LengthUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<LengthUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: LengthUnit): this;
+    get nanometers(): number;
+    get micrometers(): number;
+    get millimeters(): number;
+    get centimeters(): number;
+    get decimeters(): number;
+    get meters(): number;
+    get kilometers(): number;
+    get inches(): number;
+    get feet(): number;
+    get yards(): number;
+    get miles(): number;
+    get nauticalMiles(): number;
+    /** The value in Swedish miles, where 1 mil is 10 km. */
+    get swedishMiles(): number;
+    /** Creates a length from a value and unit. */
+    static create(value: number | Decimal, unit: LengthUnit): Length;
+    static fromNanometers(value: number | Decimal): Length;
+    static fromMicrometers(value: number | Decimal): Length;
+    static fromMillimeters(value: number | Decimal): Length;
+    static fromCentimeters(value: number | Decimal): Length;
+    static fromDecimeters(value: number | Decimal): Length;
+    static fromMeters(value: number | Decimal): Length;
+    static fromKilometers(value: number | Decimal): Length;
+    static fromInches(value: number | Decimal): Length;
+    static fromFeet(value: number | Decimal): Length;
+    static fromYards(value: number | Decimal): Length;
+    static fromMiles(value: number | Decimal): Length;
+    static fromNauticalMiles(value: number | Decimal): Length;
+    static fromSwedishMiles(value: number | Decimal): Length;
+    static tryParse(input: string | null | undefined): Length | null;
+    static parse(input: string): Length;
+    static isValid(input: string | null | undefined): boolean;
+    /**
+     * Returns a display-friendly string such as `10 km`, preserving the parsed
+     * unit unless `unit` is given. Returns `null` when the input is invalid.
+     */
+    static format(input: string | null | undefined, options?: LengthFormatOptions): string | null;
+    /** Returns the value in meters, e.g. `10000 m`. Returns `null` when invalid. */
+    static normalize(input: string | null | undefined, options?: LengthFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Length>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked length, e.g. `10 km` becomes `*** km`. */
+declare function maskLength(length: Length): string;
+
+export { Decimal as D, Length as L, MeasurementUnit as M, Quantity as Q, type LengthFormatOptions as a, LengthUnit as b, MeasurementUnitIndex as c, maskLength as m };

package/dist/types/measurement/index.d.cts

@@ -0,0 +1,136 @@
+export { A as Area, a as AreaFormatOptions, b as AreaUnit, E as ElectricCurrent, c as ElectricCurrentFormatOptions, d as ElectricCurrentUnit, F as FlowRate, e as FlowRateFormatOptions, f as FlowRateUnit, L as Luminance, g as LuminanceFormatOptions, h as LuminanceUnit, i as LuminousFlux, j as LuminousFluxFormatOptions, k as LuminousFluxUnit, P as Percentage, l as PercentageFormatOptions, m as Pressure, n as PressureFormatOptions, o as PressureUnit, R as RotationalSpeed, p as RotationalSpeedFormatOptions, q as RotationalSpeedUnit, S as SoundLevel, r as SoundLevelFormatOptions, s as SoundWeighting, t as Speed, u as SpeedFormatOptions, v as SpeedUnit, T as Temperature, w as TemperatureDelta, x as TemperatureFormatOptions, y as TemperatureUnit, z as Torque, B as TorqueFormatOptions, C as TorqueUnit, V as Voltage, D as VoltageFormatOptions, G as VoltageUnit, W as Weight, H as WeightFormatOptions, I as WeightUnit, J as maskArea, K as maskElectricCurrent, M as maskFlowRate, N as maskLuminance, O as maskLuminousFlux, Q as maskPercentage, U as maskPressure, X as maskRotationalSpeed, Y as maskSoundLevel, Z as maskSpeed, _ as maskTemperature, $ as maskTorque, a0 as maskVoltage, a1 as maskWeight } from '../weight-C5C7OuV_.cjs';
+import { P as PrimitiveTypeInfo } from '../text-candidate-qg2bD9PY.cjs';
+export { D as DataSize, a as DataSizeFormatOptions, b as DataSizeUnit, E as ElectricCharge, c as ElectricChargeFormatOptions, d as ElectricChargeUnit, e as Energy, f as EnergyFormatOptions, g as EnergyUnit, F as Frequency, h as FrequencyFormatOptions, i as FrequencyUnit, m as maskDataSize, j as maskElectricCharge, k as maskEnergy, l as maskFrequency } from '../frequency-CweGfJFS.cjs';
+export { L as Length, a as LengthFormatOptions, b as LengthUnit, m as maskLength } from '../length-XRL5Eg7F.cjs';
+export { P as Power, a as PowerFormatOptions, b as PowerUnit, V as Volume, c as VolumeFormatOptions, d as VolumeUnit, m as maskPower, e as maskVolume } from '../volume-CFA4e3dc.cjs';
+
+/** Options for {@link Count.format} and {@link Count.normalize}. */
+interface CountFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A whole number of items, from 0 to one billion, written with or without a
+ * piece suffix — `5`, `5 st`, `1 345 stycken`, `3 x`.
+ *
+ * Separators are treated as thousands grouping, so `1.345` is one thousand
+ * three hundred and forty-five. A group of one or two digits after the last
+ * separator cannot be grouping, so `1,5` is rejected rather than rounded.
+ */
+declare class Count {
+    /** The count as an integer, e.g. `5`. */
+    readonly value: number;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The smallest count that can be represented. */
+    static readonly minValue = 0;
+    /** The largest count that can be represented. */
+    static readonly maxValue = 1000000000;
+    private constructor();
+    /** Creates a count from an integer. Throws when it is out of range. */
+    static create(value: number): Count;
+    static tryParse(input: string | null | undefined): Count | null;
+    static parse(input: string): Count;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form with the Swedish piece abbreviation, e.g. `1 345 st`. */
+    static format(input: string | null | undefined, options?: CountFormatOptions): string | null;
+    /** The digit-only canonical form, e.g. `1345`. */
+    static normalize(input: string | null | undefined, options?: CountFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** The digit-only canonical form, e.g. `1345`. */
+    toNormalizedString(): string;
+    /** The count with grouped thousands and a piece abbreviation, e.g. `1 345 st`. */
+    toString(): string;
+    /** Grouped but without the suffix, e.g. `1 345`. */
+    toNaturalString(): string;
+    compareTo(other: Count | null | undefined): number;
+    equals(other: Count | null | undefined): boolean;
+}
+/** Returns a masked count, e.g. `5 st` becomes `*** st`. */
+declare function maskCount(count: Count): string;
+
+/** Options for {@link Year.format} and {@link Year.normalize}. */
+interface YearFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A four-digit calendar year from 1000 to 9999.
+ *
+ * Sources:
+ * - https://www.iso.org/iso-8601-date-and-time-format.html
+ */
+declare class Year {
+    /** The calendar year as an integer, e.g. `2024`. */
+    readonly value: number;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The earliest supported year. */
+    static readonly minYear = 1000;
+    /** The latest supported year. */
+    static readonly maxYear = 9999;
+    private constructor();
+    /** Creates a year from an integer. Throws when it is out of range. */
+    static create(year: number): Year;
+    static tryParse(input: string | null | undefined): Year | null;
+    static parse(input: string): Year;
+    static isValid(input: string | null | undefined): boolean;
+    /** The year as a four-digit string, e.g. `2024`. */
+    static format(input: string | null | undefined, options?: YearFormatOptions): string | null;
+    /** The canonical four-digit year, e.g. `2024`. */
+    static normalize(input: string | null | undefined, options?: YearFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    compareTo(other: Year | null | undefined): number;
+    equals(other: Year | null | undefined): boolean;
+}
+/** Returns a masked year, e.g. `2024` becomes `****`. */
+declare function maskYear(year: Year): string;
+
+/** Options for {@link YearMonth.format} and {@link YearMonth.normalize}. */
+interface YearMonthFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A calendar month, held as a year from 1000 to 9999 and a month from 1 to 12.
+ *
+ * Accepts ISO 8601 (`2026-07`), a full ISO date read at month precision
+ * (`2026-07-01`), slash-separated forms (`2026/07`, `07/2026`), and Swedish or
+ * English month names (`juli 2026`, `Jul 2026`, `2026 July`).
+ *
+ * Sources:
+ * - https://www.iso.org/iso-8601-date-and-time-format.html
+ */
+declare class YearMonth {
+    /** The calendar year, e.g. `2026`. */
+    readonly year: number;
+    /** The calendar month, from 1 to 12. */
+    readonly month: number;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The earliest supported year. */
+    static readonly minYear = 1000;
+    /** The latest supported year. */
+    static readonly maxYear = 9999;
+    private constructor();
+    /** Creates a year-month. Throws when either part is out of range. */
+    static create(year: number, month: number): YearMonth;
+    /** Creates a year-month from a date, discarding the day. */
+    static fromDate(date: Date): YearMonth;
+    static tryParse(input: string | null | undefined): YearMonth | null;
+    static parse(input: string): YearMonth;
+    static isValid(input: string | null | undefined): boolean;
+    /** The canonical ISO 8601 form, e.g. `2026-07`. */
+    static format(input: string | null | undefined, options?: YearMonthFormatOptions): string | null;
+    /** The canonical ISO 8601 form, e.g. `2026-07`. */
+    static normalize(input: string | null | undefined, options?: YearMonthFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    /** The first day of the month, as a UTC date. */
+    toFirstDayOfMonth(): Date;
+    /** The last day of the month, as a UTC date. */
+    toLastDayOfMonth(): Date;
+    compareTo(other: YearMonth | null | undefined): number;
+    equals(other: YearMonth | null | undefined): boolean;
+}
+/** Returns a masked year-month, e.g. `2026-07` becomes `****-**`. */
+declare function maskYearMonth(yearMonth: YearMonth): string;
+
+export { Count, type CountFormatOptions, Year, type YearFormatOptions, YearMonth, type YearMonthFormatOptions, maskCount, maskYear, maskYearMonth };

package/dist/types/measurement/index.d.ts

@@ -0,0 +1,136 @@
+export { A as Area, a as AreaFormatOptions, b as AreaUnit, E as ElectricCurrent, c as ElectricCurrentFormatOptions, d as ElectricCurrentUnit, F as FlowRate, e as FlowRateFormatOptions, f as FlowRateUnit, L as Luminance, g as LuminanceFormatOptions, h as LuminanceUnit, i as LuminousFlux, j as LuminousFluxFormatOptions, k as LuminousFluxUnit, P as Percentage, l as PercentageFormatOptions, m as Pressure, n as PressureFormatOptions, o as PressureUnit, R as RotationalSpeed, p as RotationalSpeedFormatOptions, q as RotationalSpeedUnit, S as SoundLevel, r as SoundLevelFormatOptions, s as SoundWeighting, t as Speed, u as SpeedFormatOptions, v as SpeedUnit, T as Temperature, w as TemperatureDelta, x as TemperatureFormatOptions, y as TemperatureUnit, z as Torque, B as TorqueFormatOptions, C as TorqueUnit, V as Voltage, D as VoltageFormatOptions, G as VoltageUnit, W as Weight, H as WeightFormatOptions, I as WeightUnit, J as maskArea, K as maskElectricCurrent, M as maskFlowRate, N as maskLuminance, O as maskLuminousFlux, Q as maskPercentage, U as maskPressure, X as maskRotationalSpeed, Y as maskSoundLevel, Z as maskSpeed, _ as maskTemperature, $ as maskTorque, a0 as maskVoltage, a1 as maskWeight } from '../weight-B30-Hzxu.js';
+import { P as PrimitiveTypeInfo } from '../text-candidate-qg2bD9PY.js';
+export { D as DataSize, a as DataSizeFormatOptions, b as DataSizeUnit, E as ElectricCharge, c as ElectricChargeFormatOptions, d as ElectricChargeUnit, e as Energy, f as EnergyFormatOptions, g as EnergyUnit, F as Frequency, h as FrequencyFormatOptions, i as FrequencyUnit, m as maskDataSize, j as maskElectricCharge, k as maskEnergy, l as maskFrequency } from '../frequency-DdOMV6Sw.js';
+export { L as Length, a as LengthFormatOptions, b as LengthUnit, m as maskLength } from '../length-CceXIJYY.js';
+export { P as Power, a as PowerFormatOptions, b as PowerUnit, V as Volume, c as VolumeFormatOptions, d as VolumeUnit, m as maskPower, e as maskVolume } from '../volume-DGLPQypt.js';
+
+/** Options for {@link Count.format} and {@link Count.normalize}. */
+interface CountFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A whole number of items, from 0 to one billion, written with or without a
+ * piece suffix — `5`, `5 st`, `1 345 stycken`, `3 x`.
+ *
+ * Separators are treated as thousands grouping, so `1.345` is one thousand
+ * three hundred and forty-five. A group of one or two digits after the last
+ * separator cannot be grouping, so `1,5` is rejected rather than rounded.
+ */
+declare class Count {
+    /** The count as an integer, e.g. `5`. */
+    readonly value: number;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The smallest count that can be represented. */
+    static readonly minValue = 0;
+    /** The largest count that can be represented. */
+    static readonly maxValue = 1000000000;
+    private constructor();
+    /** Creates a count from an integer. Throws when it is out of range. */
+    static create(value: number): Count;
+    static tryParse(input: string | null | undefined): Count | null;
+    static parse(input: string): Count;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form with the Swedish piece abbreviation, e.g. `1 345 st`. */
+    static format(input: string | null | undefined, options?: CountFormatOptions): string | null;
+    /** The digit-only canonical form, e.g. `1345`. */
+    static normalize(input: string | null | undefined, options?: CountFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** The digit-only canonical form, e.g. `1345`. */
+    toNormalizedString(): string;
+    /** The count with grouped thousands and a piece abbreviation, e.g. `1 345 st`. */
+    toString(): string;
+    /** Grouped but without the suffix, e.g. `1 345`. */
+    toNaturalString(): string;
+    compareTo(other: Count | null | undefined): number;
+    equals(other: Count | null | undefined): boolean;
+}
+/** Returns a masked count, e.g. `5 st` becomes `*** st`. */
+declare function maskCount(count: Count): string;
+
+/** Options for {@link Year.format} and {@link Year.normalize}. */
+interface YearFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A four-digit calendar year from 1000 to 9999.
+ *
+ * Sources:
+ * - https://www.iso.org/iso-8601-date-and-time-format.html
+ */
+declare class Year {
+    /** The calendar year as an integer, e.g. `2024`. */
+    readonly value: number;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The earliest supported year. */
+    static readonly minYear = 1000;
+    /** The latest supported year. */
+    static readonly maxYear = 9999;
+    private constructor();
+    /** Creates a year from an integer. Throws when it is out of range. */
+    static create(year: number): Year;
+    static tryParse(input: string | null | undefined): Year | null;
+    static parse(input: string): Year;
+    static isValid(input: string | null | undefined): boolean;
+    /** The year as a four-digit string, e.g. `2024`. */
+    static format(input: string | null | undefined, options?: YearFormatOptions): string | null;
+    /** The canonical four-digit year, e.g. `2024`. */
+    static normalize(input: string | null | undefined, options?: YearFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    compareTo(other: Year | null | undefined): number;
+    equals(other: Year | null | undefined): boolean;
+}
+/** Returns a masked year, e.g. `2024` becomes `****`. */
+declare function maskYear(year: Year): string;
+
+/** Options for {@link YearMonth.format} and {@link YearMonth.normalize}. */
+interface YearMonthFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A calendar month, held as a year from 1000 to 9999 and a month from 1 to 12.
+ *
+ * Accepts ISO 8601 (`2026-07`), a full ISO date read at month precision
+ * (`2026-07-01`), slash-separated forms (`2026/07`, `07/2026`), and Swedish or
+ * English month names (`juli 2026`, `Jul 2026`, `2026 July`).
+ *
+ * Sources:
+ * - https://www.iso.org/iso-8601-date-and-time-format.html
+ */
+declare class YearMonth {
+    /** The calendar year, e.g. `2026`. */
+    readonly year: number;
+    /** The calendar month, from 1 to 12. */
+    readonly month: number;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The earliest supported year. */
+    static readonly minYear = 1000;
+    /** The latest supported year. */
+    static readonly maxYear = 9999;
+    private constructor();
+    /** Creates a year-month. Throws when either part is out of range. */
+    static create(year: number, month: number): YearMonth;
+    /** Creates a year-month from a date, discarding the day. */
+    static fromDate(date: Date): YearMonth;
+    static tryParse(input: string | null | undefined): YearMonth | null;
+    static parse(input: string): YearMonth;
+    static isValid(input: string | null | undefined): boolean;
+    /** The canonical ISO 8601 form, e.g. `2026-07`. */
+    static format(input: string | null | undefined, options?: YearMonthFormatOptions): string | null;
+    /** The canonical ISO 8601 form, e.g. `2026-07`. */
+    static normalize(input: string | null | undefined, options?: YearMonthFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    /** The first day of the month, as a UTC date. */
+    toFirstDayOfMonth(): Date;
+    /** The last day of the month, as a UTC date. */
+    toLastDayOfMonth(): Date;
+    compareTo(other: YearMonth | null | undefined): number;
+    equals(other: YearMonth | null | undefined): boolean;
+}
+/** Returns a masked year-month, e.g. `2026-07` becomes `****-**`. */
+declare function maskYearMonth(yearMonth: YearMonth): string;
+
+export { Count, type CountFormatOptions, Year, type YearFormatOptions, YearMonth, type YearMonthFormatOptions, maskCount, maskYear, maskYearMonth };