@budiauktioner/buildi-primitives 0.1.0 → 0.2.0

package/dist/types/wheel-rim-dimension-CVCmLASl.d.ts

@@ -0,0 +1,699 @@
+import { D as Decimal } from './length-CceXIJYY.js';
+import { P as PrimitiveTypeInfo, T as TextCandidate } from './text-candidate-qg2bD9PY.js';
+import { P as Power, b as PowerUnit } from './volume-DGLPQypt.js';
+import { ValidationResult } from './validation/index.js';
+
+/** Options for {@link BoltPattern.format} and {@link BoltPattern.normalize}. */
+interface BoltPatternFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A wheel bolt pattern (`bultcirkelmått`) such as `5x114.3`: the number of bolt holes
+ * and the pitch circle diameter in millimetres.
+ *
+ * Sources:
+ * - https://en.wikipedia.org/wiki/Bolt_pattern
+ */
+declare class BoltPattern {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Number of bolt holes, e.g. `5`. */
+    readonly boltCount: number;
+    /** Normalized compact form, e.g. `5x114.3`. */
+    readonly value: string;
+    private readonly exactPcd;
+    private constructor();
+    /** Pitch circle diameter in millimetres, e.g. `114.3`. */
+    get pitchCircleDiameter(): number;
+    static tryParse(input: string | null | undefined): BoltPattern | null;
+    static parse(input: string): BoltPattern;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form with spaces, e.g. `5 x 114.3`. */
+    static format(input: string | null | undefined, options?: BoltPatternFormatOptions): string | null;
+    /** Returns the compact form, e.g. `5x114.3`. */
+    static normalize(input: string | null | undefined, options?: BoltPatternFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds bolt patterns in unstructured text, e.g. `5x114.3`. */
+    static findCandidatesInText(text: string): readonly TextCandidate<BoltPattern>[];
+    /** Returns the compact form, e.g. `5x114.3`. */
+    toNormalizedString(): string;
+    /** Returns the display form with spaces, e.g. `5 x 114.3`. */
+    toString(): string;
+    equals(other: BoltPattern | null | undefined): boolean;
+    compareTo(other: BoltPattern | null | undefined): number;
+    /** @internal Exposes the parsed scale, which masking mirrors star for star. */
+    get _exactPcd(): Decimal;
+}
+/** Returns a masked bolt pattern, e.g. `5x114.3` becomes `* x *****`. */
+declare function maskBoltPattern(pattern: BoltPattern): string;
+
+/** Options for {@link EmissionRate.format} and {@link EmissionRate.normalize}. */
+interface EmissionRateFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A vehicle emission rate (`utsläpp`) such as CO₂ per distance, held as grams per
+ * kilometre. Accepts `g/km`, `mg/km`, `g/mi` and `mg/mi`; a bare number is read as
+ * grams per kilometre.
+ *
+ * Sources:
+ * - https://en.wikipedia.org/wiki/European_emission_standards
+ * - https://www.epa.gov/greenvehicles/greenhouse-gas-emissions-typical-passenger-vehicle
+ */
+declare class EmissionRate {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Display form preserving the parsed unit, e.g. `221 g/km`. */
+    readonly value: string;
+    private readonly exactGramsPerKm;
+    private constructor();
+    /** The rate in grams per kilometre, e.g. `221`. */
+    get gramsPerKm(): number;
+    /** The rate in milligrams per kilometre, e.g. `95700`. */
+    get milligramsPerKm(): number;
+    /** The rate in grams per mile, e.g. `355.66`. */
+    get gramsPerMile(): number;
+    static fromGramsPerKm(value: number | Decimal): EmissionRate;
+    static fromMilligramsPerKm(value: number | Decimal): EmissionRate;
+    private static fromUnit;
+    static tryParse(input: string | null | undefined): EmissionRate | null;
+    static parse(input: string): EmissionRate;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form in the parsed unit, e.g. `95.7 mg/km`. */
+    static format(input: string | null | undefined, options?: EmissionRateFormatOptions): string | null;
+    /** Returns the value in g/km, e.g. `221 g/km`. */
+    static normalize(input: string | null | undefined, options?: EmissionRateFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds emission rates in unstructured text, e.g. `221 g/km`. */
+    static findCandidatesInText(text: string): readonly TextCandidate<EmissionRate>[];
+    /** Returns the value in g/km, e.g. `221 g/km`. */
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: EmissionRate | null | undefined): boolean;
+    compareTo(other: EmissionRate | null | undefined): number;
+}
+/** Returns a masked emission rate, e.g. `221 g/km` becomes `*** g/km`. */
+declare function maskEmissionRate(rate: EmissionRate): string;
+
+/** Options for {@link EnginePower.format} and {@link EnginePower.normalize}. */
+interface EnginePowerFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: PowerUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * Engine power output (`motoreffekt`), e.g. `150 hp`, `110 kW` or the Swedish
+ * `150 hk`. A bare number is read as horsepower, and a leading `ca` or `~` is
+ * ignored.
+ */
+declare class EnginePower {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The underlying power value. */
+    readonly powerValue: Power;
+    /** Display form preserving the parsed unit, e.g. `150 hp`. */
+    readonly value: string;
+    private constructor();
+    get horsepower(): number;
+    get kilowatts(): number;
+    get watts(): number;
+    /** Creates an engine power from a value and power unit. The value must be positive. */
+    static create(value: number | Decimal, unit: PowerUnit): EnginePower;
+    static fromHorsepower(value: number | Decimal): EnginePower;
+    static fromKilowatts(value: number | Decimal): EnginePower;
+    static fromWatts(value: number | Decimal): EnginePower;
+    static tryParse(input: string | null | undefined): EnginePower | null;
+    static parse(input: string): EnginePower;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form, e.g. `150 hp`. Returns `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: EnginePowerFormatOptions): string | null;
+    /** Returns the value in watts, e.g. `110000 W`. Returns `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: EnginePowerFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /**
+     * Finds engine power written with the Swedish `hk` suffix. Standard power units
+     * such as `kW` and `hp` are found by {@link Power.findCandidatesInText} instead.
+     */
+    static findCandidatesInText(text: string): readonly TextCandidate<EnginePower>[];
+    toNormalizedString(): string;
+    toString(): string;
+    /** Returns the value in the most readable SI unit, e.g. `1.5 kW` rather than `1500 W`. */
+    toNaturalString(decimals?: number): string;
+    plus(other: EnginePower): EnginePower;
+    minus(other: EnginePower): EnginePower;
+    times(factor: number | Decimal): EnginePower;
+    dividedBy(divisor: number | Decimal): EnginePower;
+    negated(): EnginePower;
+    equals(other: EnginePower | null | undefined): boolean;
+    compareTo(other: EnginePower | null | undefined): number;
+    /** @internal Used by the private factories that keep a custom display form. */
+    static _fromDisplay(power: Power, displayValue: string): EnginePower;
+}
+/** Returns a masked engine power, e.g. `150 hp` becomes `*** hp`. */
+declare function maskEnginePower(power: EnginePower): string;
+
+/** Options for {@link EuTypeApprovalNumber.format} and `normalize`. */
+interface EuTypeApprovalNumberFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * An EU whole-vehicle type-approval number (`typgodkännandenummer`) such as
+ * `e9*2007/46*6364*09`: the E-mark country code, the directive or regulation, the
+ * type number and the extension.
+ *
+ * Sources:
+ * - https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32018R0858
+ * - https://unece.org/transport/vehicle-regulations
+ * - https://www.transportstyrelsen.se/
+ */
+declare class EuTypeApprovalNumber {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Canonical form, e.g. `e9*2007/46*6364*09`. */
+    readonly value: string;
+    /** E-mark country code, e.g. `9` for Spain and `5` for Sweden. */
+    readonly approvalCountryCode: number;
+    /** Country name for the E-mark code, or `null` when the code is unassigned. */
+    readonly approvalCountryName: string | null;
+    /** Directive or regulation reference, e.g. `2007/46`. */
+    readonly directive: string;
+    /** Type approval number, e.g. `6364`. */
+    readonly typeNumber: string;
+    /** Extension or variant number, e.g. `09`. */
+    readonly extension: string;
+    private constructor();
+    static tryParse(input: string | null | undefined): EuTypeApprovalNumber | null;
+    static parse(input: string): EuTypeApprovalNumber;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical number, e.g. `e9*2007/46*6364*09`. */
+    static format(input: string | null | undefined, options?: EuTypeApprovalNumberFormatOptions): string | null;
+    /** Returns the canonical number, e.g. `e9*2007/46*6364*09`. */
+    static normalize(input: string | null | undefined, options?: EuTypeApprovalNumberFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds type-approval numbers in unstructured text, e.g. `e9*2007/46*6364*09`. */
+    static findCandidatesInText(text: string): readonly TextCandidate<EuTypeApprovalNumber>[];
+    /** Returns the canonical number, e.g. `e9*2007/46*6364*09`. */
+    toNormalizedString(): string;
+    /** Returns the canonical number, e.g. `e9*2007/46*6364*09`. */
+    toString(): string;
+    equals(other: EuTypeApprovalNumber | null | undefined): boolean;
+    compareTo(other: EuTypeApprovalNumber | null | undefined): number;
+}
+/** Returns a masked approval number keeping the e-mark, e.g. `e9*****`. */
+declare function maskEuTypeApprovalNumber(approval: EuTypeApprovalNumber): string;
+
+/** Options shared by the string-in, string-out helpers. */
+interface EuroEmissionClassFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A European vehicle emission standard (`Euroklass`) with the related Swedish environmental
+ * class label (`miljöklass`).
+ */
+declare class EuroEmissionClass {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly euroClass: string;
+    readonly level: number;
+    readonly subLevel: string | null;
+    readonly swedishMiljoklass: string;
+    readonly introductionYear: number;
+    readonly value: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Euro1: EuroEmissionClass;
+    static readonly Euro2: EuroEmissionClass;
+    static readonly Euro3: EuroEmissionClass;
+    static readonly Euro4: EuroEmissionClass;
+    static readonly Euro5: EuroEmissionClass;
+    static readonly Euro5a: EuroEmissionClass;
+    static readonly Euro5b: EuroEmissionClass;
+    static readonly Euro6: EuroEmissionClass;
+    static readonly Euro6b: EuroEmissionClass;
+    static readonly Euro6c: EuroEmissionClass;
+    static readonly Euro6dTemp: EuroEmissionClass;
+    static readonly Euro6d: EuroEmissionClass;
+    static readonly Euro6e: EuroEmissionClass;
+    static readonly Euro7: EuroEmissionClass;
+    static readonly El: EuroEmissionClass;
+    /** All 15 values, in canonical order. */
+    static get all(): readonly EuroEmissionClass[];
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): EuroEmissionClass | null;
+    static parse(input: string): EuroEmissionClass;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: EuroEmissionClassFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: EuroEmissionClassFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds euro emission class mentions in unstructured text. */
+    static findCandidatesInText(text: string): readonly TextCandidate<EuroEmissionClass>[];
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: EuroEmissionClass | null | undefined): boolean;
+    compareTo(other: EuroEmissionClass | null | undefined): number;
+}
+
+/** Options for {@link FuelConsumption.format} and {@link FuelConsumption.normalize}. */
+interface FuelConsumptionFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Vehicle fuel consumption (`bränsleförbrukning`), held as litres per 100 km. Both
+ * combustion units (`l/100km`, `km/l`, `mpg`) and electric ones (`kWh/100km`,
+ * `Wh/km`) are accepted; a bare number is read as litres per 100 km.
+ *
+ * Sources:
+ * - https://en.wikipedia.org/wiki/Fuel_economy_in_automobiles
+ */
+declare class FuelConsumption {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Display form preserving the parsed unit, e.g. `8.3 l/100km`. */
+    readonly value: string;
+    private readonly exactLitersPer100Km;
+    private readonly exactKwhPer100Km;
+    private readonly electric;
+    private constructor();
+    /** Consumption in litres per 100 km. Zero for electric vehicles. */
+    get litersPer100Km(): number;
+    /** Fuel economy in kilometres per litre. Zero for electric vehicles. */
+    get kilometersPerLiter(): number;
+    /** Fuel economy in US miles per gallon. Zero for electric vehicles. */
+    get milesPerGallonUs(): number;
+    /** Fuel economy in imperial miles per gallon. Zero for electric vehicles. */
+    get milesPerGallonImp(): number;
+    /** Electric consumption in kWh per 100 km. Zero for combustion vehicles. */
+    get kwhPer100Km(): number;
+    /** `true` when the value came from a kWh-based unit. */
+    get isElectric(): boolean;
+    static fromLitersPer100Km(value: number | Decimal): FuelConsumption;
+    static fromKilometersPerLiter(value: number | Decimal): FuelConsumption;
+    static fromMpgUs(value: number | Decimal): FuelConsumption;
+    static fromKwhPer100Km(value: number | Decimal): FuelConsumption;
+    private static fromUnit;
+    static tryParse(input: string | null | undefined): FuelConsumption | null;
+    static parse(input: string): FuelConsumption;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form in the parsed unit, e.g. `12 km/l`. */
+    static format(input: string | null | undefined, options?: FuelConsumptionFormatOptions): string | null;
+    /** Returns the value in l/100km, or kWh/100km for electric vehicles. */
+    static normalize(input: string | null | undefined, options?: FuelConsumptionFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds fuel consumption values in unstructured text, e.g. `8.3 l/100km`. */
+    static findCandidatesInText(text: string): readonly TextCandidate<FuelConsumption>[];
+    /** Returns the value in l/100km, or kWh/100km for electric vehicles. */
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: FuelConsumption | null | undefined): boolean;
+    compareTo(other: FuelConsumption | null | undefined): number;
+    private reciprocal;
+}
+/** Returns a masked fuel consumption, e.g. `8.3 l/100km` becomes `*** l/100km`. */
+declare function maskFuelConsumption(consumption: FuelConsumption): string;
+
+/** Options for {@link OperatingHours.format} and {@link OperatingHours.normalize}. */
+interface OperatingHoursFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Machine operating hours (`drifttimmar`), e.g. `1234 h`. A bare number is read as
+ * hours; an explicit `h`, `tim` or `timmar` suffix is also accepted.
+ */
+declare class OperatingHours {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Display form, e.g. `1234 h`. */
+    readonly value: string;
+    private readonly exactHours;
+    private constructor();
+    /** The reading in hours. */
+    get hours(): number;
+    /** @internal The exact reading, used by the masking helper. */
+    get _exactHours(): Decimal;
+    /** Creates a reading from an hour value. The value must not be negative. */
+    static create(hours: number | Decimal): OperatingHours;
+    static fromHours(hours: number | Decimal): OperatingHours;
+    static tryParse(input: string | null | undefined): OperatingHours | null;
+    static parse(input: string): OperatingHours;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form, e.g. `1234 h`. Returns `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: OperatingHoursFormatOptions): string | null;
+    /** Returns the value in hours, e.g. `1234 h`. Returns `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: OperatingHoursFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /**
+     * Finds operating-hour readings in unstructured text. Only values with an explicit
+     * hour suffix match, which keeps false positives down.
+     */
+    static findCandidatesInText(text: string): readonly TextCandidate<OperatingHours>[];
+    /** Returns the reading in hours, e.g. `1234 h`. */
+    toNormalizedString(): string;
+    toString(): string;
+    plus(other: OperatingHours): OperatingHours;
+    minus(other: OperatingHours): OperatingHours;
+    times(factor: number | Decimal): OperatingHours;
+    dividedBy(divisor: number | Decimal): OperatingHours;
+    negated(): OperatingHours;
+    equals(other: OperatingHours | null | undefined): boolean;
+    compareTo(other: OperatingHours | null | undefined): number;
+}
+/** Returns a masked operating-hour reading, e.g. `1234 h` becomes `**** h`. */
+declare function maskOperatingHours(hours: OperatingHours): string;
+
+/** Broad vehicle group associated with a {@link SwedishDrivingLicenseCategory}. */
+declare const SwedishDrivingLicenseVehicleGroup: {
+    readonly Unknown: 0;
+    readonly Moped: 1;
+    readonly Motorcycle: 2;
+    readonly Car: 3;
+    readonly Truck: 4;
+    readonly Bus: 5;
+};
+type SwedishDrivingLicenseVehicleGroup = (typeof SwedishDrivingLicenseVehicleGroup)[keyof typeof SwedishDrivingLicenseVehicleGroup];
+
+/** Options shared by the string-in, string-out helpers. */
+interface SwedishDrivingLicenseCategoryFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/** Broad vehicle group associated with a {@link SwedishDrivingLicenseCategory}. */
+declare class SwedishDrivingLicenseCategory {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly code: string;
+    readonly localizedName: string;
+    readonly englishName: string;
+    readonly description: string;
+    readonly minimumAge: number;
+    readonly vehicleGroup: SwedishDrivingLicenseVehicleGroup;
+    readonly isTrailerCategory: boolean;
+    readonly validityYears: number;
+    readonly value: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly AM: SwedishDrivingLicenseCategory;
+    static readonly A1: SwedishDrivingLicenseCategory;
+    static readonly A2: SwedishDrivingLicenseCategory;
+    static readonly A: SwedishDrivingLicenseCategory;
+    static readonly B: SwedishDrivingLicenseCategory;
+    static readonly B96: SwedishDrivingLicenseCategory;
+    static readonly BE: SwedishDrivingLicenseCategory;
+    static readonly C1: SwedishDrivingLicenseCategory;
+    static readonly C1E: SwedishDrivingLicenseCategory;
+    static readonly C: SwedishDrivingLicenseCategory;
+    static readonly CE: SwedishDrivingLicenseCategory;
+    static readonly D1: SwedishDrivingLicenseCategory;
+    static readonly D1E: SwedishDrivingLicenseCategory;
+    static readonly D: SwedishDrivingLicenseCategory;
+    static readonly DE: SwedishDrivingLicenseCategory;
+    /** All 15 values, in canonical order. */
+    static get all(): readonly SwedishDrivingLicenseCategory[];
+    /** Name in the language selected by {@link PrimitivesDefaults.uiCulture}. */
+    get displayName(): string;
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): SwedishDrivingLicenseCategory | null;
+    static parse(input: string): SwedishDrivingLicenseCategory;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: SwedishDrivingLicenseCategoryFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: SwedishDrivingLicenseCategoryFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds driving license category mentions in unstructured text. */
+    static findCandidatesInText(text: string): readonly TextCandidate<SwedishDrivingLicenseCategory>[];
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: SwedishDrivingLicenseCategory | null | undefined): boolean;
+    compareTo(other: SwedishDrivingLicenseCategory | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface SwedishEcoVehicleClassificationFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A Swedish eco-vehicle classification (`miljöbilsklassning`) used by Transportstyrelsen and
+ * the Swedish tax legislation, e.g. `Miljöbil 2007`, `Miljöbil 2013`, `Supermiljöbil`,
+ * `Klimatbonusbil`.
+ */
+declare class SwedishEcoVehicleClassification {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly introductionYear: number;
+    readonly endYear: number | null;
+    readonly englishDescription: string;
+    readonly localizedDescription: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Miljobil2007: SwedishEcoVehicleClassification;
+    static readonly Miljobil2013: SwedishEcoVehicleClassification;
+    static readonly Supermiljobil: SwedishEcoVehicleClassification;
+    static readonly Klimatbonusbil: SwedishEcoVehicleClassification;
+    static readonly Bonusbil: SwedishEcoVehicleClassification;
+    static readonly Elbil: SwedishEcoVehicleClassification;
+    /** All 6 values, in canonical order. */
+    static get all(): readonly SwedishEcoVehicleClassification[];
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): SwedishEcoVehicleClassification | null;
+    static parse(input: string): SwedishEcoVehicleClassification;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: SwedishEcoVehicleClassificationFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: SwedishEcoVehicleClassificationFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds swedish eco-vehicle classification mentions in unstructured text. */
+    static findCandidatesInText(text: string): readonly TextCandidate<SwedishEcoVehicleClassification>[];
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: SwedishEcoVehicleClassification | null | undefined): boolean;
+    compareTo(other: SwedishEcoVehicleClassification | null | undefined): number;
+}
+
+/** Options for {@link SwedishVehicleRegistrationNumber.format} and `normalize`. */
+interface SwedishVehicleRegistrationNumberFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A Swedish vehicle registration number (`registreringsnummer`) issued by
+ * Transportstyrelsen. The classic form is three letters and three digits
+ * (`ABC 123`); since 2019 the final digit may instead be a letter (`ABC 12A`).
+ *
+ * The tax payment month is derived structurally from the number and says nothing
+ * about any particular vehicle's actual tax status.
+ *
+ * Sources:
+ * - https://www.transportstyrelsen.se/en/road/vehicles/licence-plates/
+ * - https://www.transportstyrelsen.se/en/road/vehicles/taxes-and-fees/vehicle-tax/
+ * - https://en.wikipedia.org/wiki/Vehicle_registration_plates_of_Sweden
+ */
+declare class SwedishVehicleRegistrationNumber {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The registration number without spaces, e.g. `ABC123`. */
+    readonly value: string;
+    /** Display form with a space, e.g. `ABC 123`. */
+    readonly formatted: string;
+    /** The three-letter prefix, e.g. `ABC`. */
+    readonly letters: string;
+    /** The part after the letter prefix, e.g. `123` or `12A`. */
+    readonly suffix: string;
+    /** `true` when the number uses the 2019 format whose last character is a letter. */
+    readonly isNewFormat: boolean;
+    /** The digit the tax payment month is derived from. */
+    readonly taxPaymentDigit: number;
+    /** The month (1–12) when vehicle tax is normally due. */
+    readonly taxPaymentMonth: number;
+    private constructor();
+    static tryParse(input: string | null | undefined): SwedishVehicleRegistrationNumber | null;
+    static parse(input: string): SwedishVehicleRegistrationNumber;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form with a space, e.g. `ABC 123`. */
+    static format(input: string | null | undefined, options?: SwedishVehicleRegistrationNumberFormatOptions): string | null;
+    /** Returns the number without spaces, e.g. `ABC123`. */
+    static normalize(input: string | null | undefined, options?: SwedishVehicleRegistrationNumberFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Describes why the input is not a registration number, or reports it as valid. */
+    static validate(input: string | null | undefined): ValidationResult;
+    /** Finds registration-number candidates in unstructured text. */
+    static findCandidatesInText(text: string): readonly TextCandidate<SwedishVehicleRegistrationNumber>[];
+    /** Returns the number without spaces, e.g. `ABC123`. */
+    toNormalizedString(): string;
+    /** Returns the display form with a space, e.g. `ABC 123`. */
+    toString(): string;
+    equals(other: SwedishVehicleRegistrationNumber | null | undefined): boolean;
+    compareTo(other: SwedishVehicleRegistrationNumber | null | undefined): number;
+}
+/** Returns a masked registration number, e.g. `ABC 123` becomes `*** ***`. */
+declare function maskSwedishVehicleRegistrationNumber(registration: SwedishVehicleRegistrationNumber): string;
+
+/** Options for {@link TireDimension.format} and {@link TireDimension.normalize}. */
+interface TireDimensionFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Metric tire size notation (`däckdimension`) per ISO 4000-1, e.g. `205/55R16` or
+ * `315/70R22.5 154/150L` for commercial truck tires: section width, aspect ratio,
+ * construction, rim diameter, plus optional load index, dual load index, speed
+ * symbol and commercial `C` designation.
+ *
+ * Sources:
+ * - https://www.iso.org/standard/4600.html
+ * - https://en.wikipedia.org/wiki/Tire_code
+ */
+declare class TireDimension {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Tread width in millimetres, e.g. `205`. */
+    readonly widthMm: number;
+    /** Aspect ratio, the sidewall height as a percentage of section width, e.g. `55`. */
+    readonly aspectRatio: number;
+    /** Construction code: `R` radial, `D` diagonal, `B` bias belt. */
+    readonly construction: string;
+    /** Rim diameter in inches, e.g. `16` or `22.5` for half-inch commercial rims. */
+    readonly rimDiameterInches: number;
+    /** Whether the tire carries the commercial `C` designation. */
+    readonly isCommercial: boolean;
+    /** Optional load index, e.g. `91` in `205/55R16 91H`. */
+    readonly loadIndex: number | null;
+    /** Optional dual (twin-mounted) load index, e.g. `150` in `315/70R22.5 154/150L`. */
+    readonly dualLoadIndex: number | null;
+    /** Optional speed rating letter, e.g. `H` in `205/55R16 91H`. */
+    readonly speedRating: string | null;
+    /** Normalized compact form, e.g. `205/55R16 91H`. */
+    readonly value: string;
+    private constructor();
+    static tryParse(input: string | null | undefined): TireDimension | null;
+    static parse(input: string): TireDimension;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form with spaces, e.g. `205/55 R 16 91H`. */
+    static format(input: string | null | undefined, options?: TireDimensionFormatOptions): string | null;
+    /** Returns the compact form, e.g. `205/55R16 91H`. */
+    static normalize(input: string | null | undefined, options?: TireDimensionFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds tire dimensions in unstructured text, e.g. `205/55R16`. */
+    static findCandidatesInText(text: string): readonly TextCandidate<TireDimension>[];
+    /** Returns the compact form, e.g. `205/55R16 91H`. */
+    toNormalizedString(): string;
+    /** Returns the display form with spaces, e.g. `205/55 R 16 91H`. */
+    toString(): string;
+    equals(other: TireDimension | null | undefined): boolean;
+    compareTo(other: TireDimension | null | undefined): number;
+}
+/**
+ * Returns a masked tire dimension keeping the construction letter and the commercial
+ * `C` visible, so `205/55R16` masks down to three stars, a slash, two stars, `R` and
+ * two more stars. Load-related suffixes are masked in full.
+ */
+declare function maskTireDimension(dimension: TireDimension): string;
+
+/** Options for {@link VehicleIdentificationNumber.format} and `normalize`. */
+interface VehicleIdentificationNumberFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A Vehicle Identification Number (VIN), also known as a chassis number
+ * (`chassinummer`): the 17-character ISO 3779 code that uniquely identifies a motor
+ * vehicle. Position 9 holds a MOD-11 check digit, mandatory in North America and
+ * common but not universal in Europe.
+ *
+ * Sources:
+ * - https://www.iso.org/standard/52200.html
+ * - https://en.wikipedia.org/wiki/Vehicle_identification_number
+ * - https://en.wikibooks.org/wiki/Vehicle_Identification_Numbers_(VIN_codes)/Check_digit
+ */
+declare class VehicleIdentificationNumber {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The 17-character VIN in uppercase, e.g. `WBA3A5C55CF256789`. */
+    readonly value: string;
+    /** World Manufacturer Identifier — positions 1–3. */
+    readonly wmi: string;
+    /** Vehicle Descriptor Section — positions 4–8. */
+    readonly vds: string;
+    /** The check digit at position 9 (a digit or `X`). */
+    readonly checkDigit: string;
+    /** Vehicle Indicator Section — positions 10–17. */
+    readonly vis: string;
+    /** The model year code at position 10. */
+    readonly modelYearCode: string;
+    /** The model years the code at position 10 can encode, e.g. `M` means 1991 or 2021. */
+    readonly modelYears: readonly number[];
+    /** The assembly plant code at position 11. */
+    readonly assemblyPlantCode: string;
+    /** The sequential production number — positions 12–17. */
+    readonly sequentialNumber: string;
+    /** Whether position 9 passes the ISO 3779 MOD-11 check. */
+    readonly hasValidCheckDigit: boolean;
+    private constructor();
+    static tryParse(input: string | null | undefined): VehicleIdentificationNumber | null;
+    static parse(input: string): VehicleIdentificationNumber;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the VIN in uppercase without separators, e.g. `WBA3A5C55CF256789`. */
+    static format(input: string | null | undefined, options?: VehicleIdentificationNumberFormatOptions): string | null;
+    /** Returns the VIN in uppercase without separators, e.g. `WBA3A5C55CF256789`. */
+    static normalize(input: string | null | undefined, options?: VehicleIdentificationNumberFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Describes why the input is not a VIN, or reports it as valid. */
+    static validate(input: string | null | undefined): ValidationResult;
+    /** Finds VIN candidates in unstructured text. */
+    static findCandidatesInText(text: string): readonly TextCandidate<VehicleIdentificationNumber>[];
+    /** Returns the 17-character VIN in uppercase, e.g. `WBA3A5C55CF256789`. */
+    toNormalizedString(): string;
+    /** Returns the 17-character VIN in uppercase, e.g. `WBA3A5C55CF256789`. */
+    toString(): string;
+    equals(other: VehicleIdentificationNumber | null | undefined): boolean;
+    compareTo(other: VehicleIdentificationNumber | null | undefined): number;
+}
+/** Returns a VIN with only the manufacturer prefix visible, e.g. `WBA**************`. */
+declare function maskVehicleIdentificationNumber(vin: VehicleIdentificationNumber): string;
+
+/** Options for {@link WheelRimDimension.format} and {@link WheelRimDimension.normalize}. */
+interface WheelRimDimensionFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Wheel rim size notation (`fälgdimension`) such as `18x7J`: rim diameter in inches,
+ * width in inches and an optional flange type. The reversed order used on many rims,
+ * e.g. `7.5Jx17`, is accepted as well.
+ *
+ * Sources:
+ * - https://en.wikipedia.org/wiki/Wheel_sizing
+ * - https://www.etrto.org/
+ */
+declare class WheelRimDimension {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Normalized compact form, e.g. `18x7J`. */
+    readonly value: string;
+    /** Flange type code, e.g. `J` or `JJ`, or an empty string when unspecified. */
+    readonly flangeType: string;
+    private readonly exactDiameter;
+    private readonly exactWidth;
+    private constructor();
+    /** Rim diameter in inches, e.g. `18`. */
+    get diameterInches(): number;
+    /** Rim width in inches, e.g. `7`. */
+    get widthInches(): number;
+    static tryParse(input: string | null | undefined): WheelRimDimension | null;
+    static parse(input: string): WheelRimDimension;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the spaced display form, e.g. `18 x 7 J`. */
+    static format(input: string | null | undefined, options?: WheelRimDimensionFormatOptions): string | null;
+    /** Returns the compact form, e.g. `18x7J`. */
+    static normalize(input: string | null | undefined, options?: WheelRimDimensionFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds wheel rim dimensions in unstructured text, e.g. `18x7J` or `7.5Jx17`. */
+    static findCandidatesInText(text: string): readonly TextCandidate<WheelRimDimension>[];
+    /** Returns the compact form, e.g. `18x7J`. */
+    toNormalizedString(): string;
+    /** Returns the spaced display form, e.g. `18 x 7 J`. */
+    toString(): string;
+    equals(other: WheelRimDimension | null | undefined): boolean;
+    compareTo(other: WheelRimDimension | null | undefined): number;
+    /** @internal Exposes the parsed scale, which masking mirrors star for star. */
+    get _exactParts(): {
+        diameter: Decimal;
+        width: Decimal;
+    };
+}
+/** Returns a masked rim dimension keeping the flange type, e.g. `18x7J` becomes `** x * J`. */
+declare function maskWheelRimDimension(dimension: WheelRimDimension): string;
+
+export { maskTireDimension as A, BoltPattern as B, maskVehicleIdentificationNumber as C, maskWheelRimDimension as D, EmissionRate as E, FuelConsumption as F, OperatingHours as O, SwedishDrivingLicenseCategory as S, TireDimension as T, VehicleIdentificationNumber as V, WheelRimDimension as W, type BoltPatternFormatOptions as a, type EmissionRateFormatOptions as b, EnginePower as c, type EnginePowerFormatOptions as d, EuTypeApprovalNumber as e, type EuTypeApprovalNumberFormatOptions as f, EuroEmissionClass as g, type EuroEmissionClassFormatOptions as h, type FuelConsumptionFormatOptions as i, type OperatingHoursFormatOptions as j, type SwedishDrivingLicenseCategoryFormatOptions as k, SwedishDrivingLicenseVehicleGroup as l, SwedishEcoVehicleClassification as m, type SwedishEcoVehicleClassificationFormatOptions as n, SwedishVehicleRegistrationNumber as o, type SwedishVehicleRegistrationNumberFormatOptions as p, type TireDimensionFormatOptions as q, type VehicleIdentificationNumberFormatOptions as r, type WheelRimDimensionFormatOptions as s, maskBoltPattern as t, maskEmissionRate as u, maskEnginePower as v, maskEuTypeApprovalNumber as w, maskFuelConsumption as x, maskOperatingHours as y, maskSwedishVehicleRegistrationNumber as z };