@budiauktioner/buildi-primitives 0.1.1 → 0.2.0

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

@@ -0,0 +1,1239 @@
+import { P as PrimitiveTypeInfo, T as TextCandidate } from '../text-candidate-qg2bD9PY.js';
+import { D as Decimal } from '../length-CceXIJYY.js';
+import { E as ElectricCharge, e as Energy, F as Frequency, i as FrequencyUnit, D as DataSize, b as DataSizeUnit } from '../frequency-DdOMV6Sw.js';
+import { h as Gtin8, d as Gtin13, C as Color, E as ElectricalPhase, G as Gtin12, f as Gtin14, I as IpRating, R as Refrigerant, S as ScreenResolution, n as ScreenSize } from '../screen-size-DUmjNjxG.js';
+export { a as ColorFormatOptions, b as ElectricalPhaseFormatOptions, c as Gtin12FormatOptions, e as Gtin13FormatOptions, g as Gtin14FormatOptions, i as Gtin8FormatOptions, j as IpRatingFormatOptions, k as RefrigerantFamily, l as RefrigerantFormatOptions, m as ScreenResolutionFormatOptions, o as ScreenSizeFormatOptions } from '../screen-size-DUmjNjxG.js';
+
+/** Sizing system a parsed clothing size was expressed in. */
+declare const ClothingSizeSystem: {
+    readonly Unknown: 0;
+    readonly EU: 1;
+    readonly US: 2;
+    readonly UK: 3;
+    readonly Letter: 4;
+};
+type ClothingSizeSystem = (typeof ClothingSizeSystem)[keyof typeof ClothingSizeSystem];
+
+/** Options shared by the string-in, string-out helpers. */
+interface AdultClothingSizeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Adult clothing size (`klädstorlek`) with approximate conversions between the EU numeric, US,
+ * UK and letter (XXS–XXXXL) systems. Stored as an even EU size between 32 and 56. A bare number
+ * is always read as EU; US and UK sizes need an explicit prefix.
+ *
+ * The conversions are industry approximations (EU ≈ US + 30, EU ≈ UK + 28) and vary by brand.
+ */
+declare class AdultClothingSize {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** EU numeric size, even and between 32 and 56, e.g. `40`. */
+    readonly euSize: number;
+    /** Approximate US numeric size (EU − 30), e.g. `10` for EU 40. */
+    readonly usSize: number;
+    /** Approximate UK numeric size (EU − 28), e.g. `12` for EU 40. */
+    readonly ukSize: number;
+    /** Standard letter size when the EU size maps to one; otherwise `null`. */
+    readonly letterSize: string | null;
+    /** The sizing system the value was parsed from. */
+    readonly system: ClothingSizeSystem;
+    /** Display form: the letter when mapped, e.g. `L`, otherwise `EU 50`. */
+    readonly value: string;
+    private constructor();
+    static tryParse(input: string | null | undefined): AdultClothingSize | null;
+    static parse(input: string): AdultClothingSize;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the letter size when the EU size maps to one, otherwise the `EU 40` form. */
+    static format(input: string | null | undefined, options?: AdultClothingSizeFormatOptions): string | null;
+    /** Returns the canonical EU form, e.g. `EU 40`. */
+    static normalize(input: string | null | undefined, options?: AdultClothingSizeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: AdultClothingSize | null | undefined): boolean;
+    compareTo(other: AdultClothingSize | null | undefined): number;
+}
+
+/** Sizing system a parsed shoe size was expressed in. */
+declare const ShoeSizeSystem: {
+    readonly Unknown: 0;
+    readonly EU: 1;
+    readonly USMen: 2;
+    readonly USWomen: 3;
+    readonly UK: 4;
+};
+type ShoeSizeSystem = (typeof ShoeSizeSystem)[keyof typeof ShoeSizeSystem];
+
+/** Options shared by the string-in, string-out helpers. */
+interface AdultShoeSizeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Adult shoe size (`skostorlek`) stored as an EU size between 35 and 50 in half steps, with
+ * US men's, US women's and UK conversions. A bare number below 35 is rejected so that children's
+ * sizes do not silently resolve as adult ones.
+ *
+ * Conversions follow common retail charts with EU as the anchor: US men ≈ EU − 33,
+ * US women ≈ EU − 31.5, UK ≈ EU − 33.5.
+ */
+declare class AdultShoeSize {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The EU size, e.g. `42` or `42.5`. */
+    readonly euSize: number;
+    /** The sizing system the value was parsed from. */
+    readonly system: ShoeSizeSystem;
+    /** Display form as an EU size, e.g. `EU 42` or `EU 42.5`. */
+    readonly value: string;
+    private constructor();
+    /** US men's size derived from EU, e.g. `9` for EU 42. */
+    get usMenSize(): number;
+    /** US women's size derived from EU, e.g. `10.5` for EU 42. */
+    get usWomenSize(): number;
+    /** UK size derived from EU, e.g. `8.5` for EU 42. */
+    get ukSize(): number;
+    static tryParse(input: string | null | undefined): AdultShoeSize | null;
+    static parse(input: string): AdultShoeSize;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical `EU 42` form. */
+    static format(input: string | null | undefined, options?: AdultShoeSizeFormatOptions): string | null;
+    /** Returns the canonical `EU 42` form, the same as {@link format} for this type. */
+    static normalize(input: string | null | undefined, options?: AdultShoeSizeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: AdultShoeSize | null | undefined): boolean;
+    compareTo(other: AdultShoeSize | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface AspectRatioFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A display or image aspect ratio (`bildformat`) expressed as `width:height`, e.g. `16:9`,
+ * `4:3`, `21:9`. Accepts colon, slash and `x`-separated forms, as well as decimal ratios such
+ * as `1.78` or `1.78:1`. Decimal inputs snap to the closest known ratio within a small
+ * tolerance, so `1.7777` and `16:9` do not become separate values.
+ */
+declare class AspectRatio {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Canonical width:height form, e.g. `16:9`. */
+    readonly value: string;
+    /** Width component, e.g. `16`. */
+    readonly width: number;
+    /** Height component, e.g. `9`. */
+    readonly height: number;
+    /** Common name when available, e.g. `Widescreen` for `16:9`; otherwise `null`. */
+    readonly commonName: string | null;
+    private constructor();
+    static readonly OneToOne: AspectRatio;
+    static readonly FourThree: AspectRatio;
+    static readonly FiveFour: AspectRatio;
+    static readonly ThreeTwo: AspectRatio;
+    static readonly SixteenTen: AspectRatio;
+    static readonly SixteenNine: AspectRatio;
+    static readonly EighteenNine: AspectRatio;
+    static readonly TwentyOneNine: AspectRatio;
+    static readonly ThirtyTwoNine: AspectRatio;
+    static readonly NineSixteen: AspectRatio;
+    static readonly NineEighteen: AspectRatio;
+    /** All 11 predefined ratios, in canonical order. */
+    static get all(): readonly AspectRatio[];
+    /** Numeric ratio ({@link width} divided by {@link height}), e.g. `1.7777…`. */
+    get ratio(): Decimal;
+    /**
+     * Resolves a ratio from a `width:height`, `width/height` or `width x height` form, or from a
+     * decimal ratio close enough to one of the canonical values.
+     */
+    static tryParse(input: string | null | undefined): AspectRatio | null;
+    static parse(input: string): AspectRatio;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical width:height form, e.g. `16:9`. */
+    static format(input: string | null | undefined, options?: AspectRatioFormatOptions): string | null;
+    /** Returns the canonical width:height form, e.g. `16:9`. */
+    static normalize(input: string | null | undefined, options?: AspectRatioFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: AspectRatio | null | undefined): boolean;
+    compareTo(other: AspectRatio | null | undefined): number;
+}
+
+/** Options for {@link BatteryCapacity.format} and {@link BatteryCapacity.normalize}. */
+interface BatteryCapacityFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Battery capacity (`batterikapacitet`) expressed either as charge (`5000 mAh`, `5 Ah`) or as
+ * energy (`50 Wh`, `75 kWh`). A bare number is read as milliampere-hours. Which of the two a
+ * value carries depends on the unit it was parsed from, and the two never mix.
+ */
+declare class BatteryCapacity {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The charge, when parsed from charge units; `null` when parsed from energy units. */
+    readonly charge: ElectricCharge | null;
+    /** The energy, when parsed from energy units; `null` when parsed from charge units. */
+    readonly energy: Energy | null;
+    /** Display form preserving the parsed unit, e.g. `5000 mAh` or `50 Wh`. */
+    readonly value: string;
+    private constructor();
+    private static ofCharge;
+    private static ofEnergy;
+    /** Creates a capacity from milliampere-hours. The value must be positive. */
+    static fromMilliampereHours(value: number | Decimal): BatteryCapacity;
+    /** Creates a capacity from ampere-hours. The value must be positive. */
+    static fromAmpereHours(value: number | Decimal): BatteryCapacity;
+    /** Creates a capacity from watt-hours. The value must be positive. */
+    static fromWattHours(value: number | Decimal): BatteryCapacity;
+    /** Creates a capacity from kilowatt-hours. The value must be positive. */
+    static fromKilowattHours(value: number | Decimal): BatteryCapacity;
+    static tryParse(input: string | null | undefined): BatteryCapacity | null;
+    static parse(input: string): BatteryCapacity;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form, e.g. `5000 mAh` or `50 Wh`. Returns `null` when invalid. */
+    static format(input: string | null | undefined, options?: BatteryCapacityFormatOptions): string | null;
+    /** Returns the value in base units, e.g. `18000 C` or `180000 J`. Returns `null` when invalid. */
+    static normalize(input: string | null | undefined, options?: BatteryCapacityFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    /** Returns the value in the most readable unit, e.g. `5000 mAh` or `50 Wh`. */
+    toNaturalString(decimals?: number): string;
+    /** Adding a charge-based capacity to an energy-based one throws, as the two do not convert. */
+    plus(other: BatteryCapacity): BatteryCapacity;
+    minus(other: BatteryCapacity): BatteryCapacity;
+    times(factor: number | Decimal): BatteryCapacity;
+    dividedBy(divisor: number | Decimal): BatteryCapacity;
+    negated(): BatteryCapacity;
+    /** Capacities of different kinds are never equal, even when they describe the same battery. */
+    equals(other: BatteryCapacity | null | undefined): boolean;
+    /** Orders by normalized string, which keeps charge and energy values apart. */
+    compareTo(other: BatteryCapacity | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface BatteryChemistryFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * The electrochemical chemistry of a battery (`batterikemi`), e.g. `Li-ion`, `LiFePO4`, `AGM`,
+ * `Pb-Acid`, `Gel`.
+ */
+declare class BatteryChemistry {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly isRechargeable: boolean;
+    readonly nominalCellVoltageV: Decimal;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly LithiumIon: BatteryChemistry;
+    static readonly LiFePO4: BatteryChemistry;
+    static readonly LithiumPolymer: BatteryChemistry;
+    static readonly LithiumTitanate: BatteryChemistry;
+    static readonly NickelMetalHydride: BatteryChemistry;
+    static readonly NickelCadmium: BatteryChemistry;
+    static readonly FloodedLeadAcid: BatteryChemistry;
+    static readonly AbsorbedGlassMat: BatteryChemistry;
+    static readonly GelLeadAcid: BatteryChemistry;
+    static readonly Alkaline: BatteryChemistry;
+    static readonly ZincCarbon: BatteryChemistry;
+    /** All 11 values, in canonical order. */
+    static get all(): readonly BatteryChemistry[];
+    /** 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): BatteryChemistry | null;
+    static parse(input: string): BatteryChemistry;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: BatteryChemistryFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: BatteryChemistryFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: BatteryChemistry | null | undefined): boolean;
+    compareTo(other: BatteryChemistry | null | undefined): number;
+}
+
+/** Options for {@link CameraResolution.format}. */
+interface CameraResolutionFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A camera image-sensor resolution in megapixels (`kamerapixlar`), e.g. `12 MP` or
+ * `108 megapixels`. Bare numbers and raw pixel counts such as `12000000` are rejected, since
+ * they cannot be told apart from other product numbers.
+ */
+declare class CameraResolution {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    private readonly exactMegapixels;
+    private constructor();
+    /** Resolution in megapixels, e.g. `12.2`. */
+    get megapixels(): number;
+    /** Total pixel count, e.g. `12200000` for 12.2 MP. */
+    get totalPixels(): number;
+    /** Builds a resolution from a megapixel value, e.g. `fromMegapixels(12.2)`. */
+    static fromMegapixels(megapixels: number | Decimal): CameraResolution;
+    /** Builds a resolution from a total pixel count, e.g. `fromTotalPixels(12200000)`. */
+    static fromTotalPixels(totalPixels: number): CameraResolution;
+    static tryParse(input: string | null | undefined): CameraResolution | null;
+    static parse(input: string): CameraResolution;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form in megapixels, e.g. `12.2 MP`. */
+    static format(input: string | null | undefined, options?: CameraResolutionFormatOptions): string | null;
+    /** Returns the value with the canonical `MP` suffix, e.g. `12.2 MP`. */
+    static normalize(input: string | null | undefined, options?: CameraResolutionFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /**
+     * Scans unstructured text for megapixel values such as `12 MP` or `108 megapixels`. The scan
+     * is heuristic and may produce false positives.
+     */
+    static findCandidatesInText(text: string): readonly TextCandidate<CameraResolution>[];
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: CameraResolution | null | undefined): boolean;
+    compareTo(other: CameraResolution | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface ChildClothingSizeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Children's clothing size (`barnklädesstorlek`) keyed on body height in centimetres, the EU
+ * standard, with approximate US, UK and age labels alongside. A bare number is always read as an
+ * EU height; US and UK labels need an explicit prefix. Ages and height ranges snap to the
+ * closest standard height.
+ */
+declare class ChildClothingSize {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Body height in centimetres, e.g. `128`. */
+    readonly heightCm: number;
+    /** EU size, which is the height as a string, e.g. `128`. */
+    readonly euSize: string;
+    /** Approximate US label, e.g. `8` or `3-6m`. */
+    readonly usSize: string;
+    /** Approximate UK label, e.g. `8-9` or `12-18m`. */
+    readonly ukSize: string;
+    /** Approximate age range label, e.g. `8-9 years`. */
+    readonly ageRange: string;
+    /** The sizing system the value was parsed from. */
+    readonly system: ClothingSizeSystem;
+    private constructor();
+    private static create;
+    static tryParse(input: string | null | undefined): ChildClothingSize | null;
+    static parse(input: string): ChildClothingSize;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical form, e.g. `EU 128`. */
+    static format(input: string | null | undefined, options?: ChildClothingSizeFormatOptions): string | null;
+    /** Returns the canonical form, e.g. `EU 128`. */
+    static normalize(input: string | null | undefined, options?: ChildClothingSizeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: ChildClothingSize | null | undefined): boolean;
+    compareTo(other: ChildClothingSize | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface ChildShoeSizeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Children's shoe size (`barnskostorlek`) stored as an EU size between 16 and 39 in half steps,
+ * with US child (C/Y) and UK labels alongside.
+ *
+ * US labels follow a fixed EU anchor chart. UK uses approximate offsets: toddler EU − 16.5 and
+ * youth EU − 33.5, where youth labels can go negative around EU 33. Parsing a UK size tries
+ * youth first when the result lands in EU 33–39, then toddler.
+ */
+declare class ChildShoeSize {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The EU size, e.g. `28` or `28.5`. */
+    readonly euSize: number;
+    /** The sizing system the value was parsed from. */
+    readonly system: ShoeSizeSystem;
+    /** Display form as an EU size, e.g. `EU 28` or `EU 28.5`. */
+    readonly value: string;
+    private constructor();
+    /** US child size label derived from EU, e.g. `10.5C` or `3.5Y`. */
+    get usSize(): string;
+    /** UK size label derived from EU: toddler is EU − 16.5, youth is EU − 33.5. */
+    get ukSize(): string;
+    static tryParse(input: string | null | undefined): ChildShoeSize | null;
+    static parse(input: string): ChildShoeSize;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical `EU 28` form. */
+    static format(input: string | null | undefined, options?: ChildShoeSizeFormatOptions): string | null;
+    /** Returns the canonical `EU 28` form, the same as {@link format} for this type. */
+    static normalize(input: string | null | undefined, options?: ChildShoeSizeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: ChildShoeSize | null | undefined): boolean;
+    compareTo(other: ChildShoeSize | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface ClothingFitFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Garment fit/silhouette (`passform`) used in apparel product feeds and fashion e-commerce,
+ * e.g. `Slim`, `Regular`, `Loose`, `Oversized`, `Tailored`.
+ */
+declare class ClothingFit {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Slim: ClothingFit;
+    static readonly Regular: ClothingFit;
+    static readonly Loose: ClothingFit;
+    static readonly Oversized: ClothingFit;
+    static readonly Tailored: ClothingFit;
+    /** All 5 values, in canonical order. */
+    static get all(): readonly ClothingFit[];
+    /** 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): ClothingFit | null;
+    static parse(input: string): ClothingFit;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: ClothingFitFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: ClothingFitFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: ClothingFit | null | undefined): boolean;
+    compareTo(other: ClothingFit | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface ClothingGenderFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Clothing target gender (`klädkön`) as used in product feeds and fashion e-commerce, e.g.
+ * `Male` (`Herr`), `Female` (`Dam`), `Unisex`.
+ */
+declare class ClothingGender {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Male: ClothingGender;
+    static readonly Female: ClothingGender;
+    static readonly Unisex: ClothingGender;
+    static readonly Boys: ClothingGender;
+    static readonly Girls: ClothingGender;
+    /** All 5 values, in canonical order. */
+    static get all(): readonly ClothingGender[];
+    /** 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): ClothingGender | null;
+    static parse(input: string): ClothingGender;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: ClothingGenderFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: ClothingGenderFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: ClothingGender | null | undefined): boolean;
+    compareTo(other: ClothingGender | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface ClothingSeasonFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Clothing/seasonal product season (`säsong`) used in fashion product feeds and retail
+ * catalogs, e.g. `Spring`, `Summer`, `Autumn`, `Winter`, `All-Season`.
+ */
+declare class ClothingSeason {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly monthsCovered: readonly number[];
+    readonly isAllSeason: boolean;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Spring: ClothingSeason;
+    static readonly Summer: ClothingSeason;
+    static readonly Autumn: ClothingSeason;
+    static readonly Winter: ClothingSeason;
+    static readonly AllSeason: ClothingSeason;
+    /** All 5 values, in canonical order. */
+    static get all(): readonly ClothingSeason[];
+    /** 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): ClothingSeason | null;
+    static parse(input: string): ClothingSeason;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: ClothingSeasonFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: ClothingSeasonFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: ClothingSeason | null | undefined): boolean;
+    compareTo(other: ClothingSeason | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface ClothingSizeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Generic clothing size (`klädstorlek`) wrapping either an {@link AdultClothingSize} or a
+ * {@link ChildClothingSize}, detected from the input or from an explicit `adult`/`vuxen` or
+ * `child`/`barn` prefix.
+ *
+ * Letter sizes such as `M` and adult EU/US/UK ranges resolve as adult; child height in
+ * centimetres such as `128` resolves as child when adult parsing does not apply.
+ */
+declare class ClothingSize {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    private readonly adult;
+    private readonly child;
+    private constructor();
+    /** `true` when this instance wraps an {@link AdultClothingSize}. */
+    get isAdult(): boolean;
+    /** `true` when this instance wraps a {@link ChildClothingSize}. */
+    get isChild(): boolean;
+    /** Display form of the wrapped size, e.g. `L` or `EU 128`. */
+    get value(): string;
+    /** Returns the adult size when {@link isAdult}, otherwise `null`. */
+    asAdult(): AdultClothingSize | null;
+    /** Returns the child size when {@link isChild}, otherwise `null`. */
+    asChild(): ChildClothingSize | null;
+    static tryParse(input: string | null | undefined): ClothingSize | null;
+    static parse(input: string): ClothingSize;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form of the resolved kind, e.g. `L` or `EU 128`. */
+    static format(input: string | null | undefined, options?: ClothingSizeFormatOptions): string | null;
+    /** Returns the canonical EU form of the resolved kind, e.g. `EU 40` or `EU 128`. */
+    static normalize(input: string | null | undefined, options?: ClothingSizeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: ClothingSize | null | undefined): boolean;
+    compareTo(other: ClothingSize | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface DisplayPanelTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * The panel technology used in a display (`paneltyp`), e.g. `LCD`, `IPS`, `VA`, `OLED`,
+ * `QLED`, `MicroLED`, `E-Ink`.
+ */
+declare class DisplayPanelType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly family: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Lcd: DisplayPanelType;
+    static readonly Tn: DisplayPanelType;
+    static readonly Ips: DisplayPanelType;
+    static readonly Va: DisplayPanelType;
+    static readonly Pls: DisplayPanelType;
+    static readonly Tft: DisplayPanelType;
+    static readonly Oled: DisplayPanelType;
+    static readonly Amoled: DisplayPanelType;
+    static readonly PmOled: DisplayPanelType;
+    static readonly Qled: DisplayPanelType;
+    static readonly QdOled: DisplayPanelType;
+    static readonly MiniLed: DisplayPanelType;
+    static readonly MicroLed: DisplayPanelType;
+    static readonly Plasma: DisplayPanelType;
+    static readonly Crt: DisplayPanelType;
+    static readonly EInk: DisplayPanelType;
+    /** All 16 values, in canonical order. */
+    static get all(): readonly DisplayPanelType[];
+    /** 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): DisplayPanelType | null;
+    static parse(input: string): DisplayPanelType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: DisplayPanelTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: DisplayPanelTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: DisplayPanelType | null | undefined): boolean;
+    compareTo(other: DisplayPanelType | null | undefined): number;
+}
+
+/** Which EU label scale a value belongs to. */
+declare const EnergyScale: {
+    readonly Unknown: 0;
+    /** The pre-2021 scale, which ran from `A+++` down to `G`. */
+    readonly Old: 1;
+    /** The rescaled 2021 label, which runs from `A` down to `G`. */
+    readonly New: 2;
+};
+type EnergyScale = (typeof EnergyScale)[keyof typeof EnergyScale];
+
+/** Options shared by the string-in, string-out helpers. */
+interface EuEnergyEfficiencyClassFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * EU energy efficiency class (`energimärkning`) for appliance labels, covering both the
+ * pre-2021 `A+++` scale and the rescaled A–G (2021) scale.
+ */
+declare class EuEnergyEfficiencyClass {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Display label, e.g. `A+++`, `B`, `G`. */
+    readonly label: string;
+    /** Whether this value sits on the pre-2021 `A+++` scale or the rescaled A–G scale. */
+    readonly scale: EnergyScale;
+    /** Rank where lower is better: old scale `A+++`=0 … `G`=9, new scale `A`=0 … `G`=6. */
+    readonly numericRank: number;
+    private constructor();
+    static readonly APlusPlusPlus: EuEnergyEfficiencyClass;
+    static readonly APlusPlus: EuEnergyEfficiencyClass;
+    static readonly APlus: EuEnergyEfficiencyClass;
+    static readonly A: EuEnergyEfficiencyClass;
+    static readonly B: EuEnergyEfficiencyClass;
+    static readonly C: EuEnergyEfficiencyClass;
+    static readonly D: EuEnergyEfficiencyClass;
+    static readonly E: EuEnergyEfficiencyClass;
+    static readonly F: EuEnergyEfficiencyClass;
+    static readonly G: EuEnergyEfficiencyClass;
+    /** Rescaled EU label (2021): `A` is rank 0, `G` is rank 6. */
+    static readonly NewA: EuEnergyEfficiencyClass;
+    static readonly NewB: EuEnergyEfficiencyClass;
+    static readonly NewC: EuEnergyEfficiencyClass;
+    static readonly NewD: EuEnergyEfficiencyClass;
+    static readonly NewE: EuEnergyEfficiencyClass;
+    static readonly NewF: EuEnergyEfficiencyClass;
+    static readonly NewG: EuEnergyEfficiencyClass;
+    /** The ten values of the pre-2021 scale, best first. */
+    static get all(): readonly EuEnergyEfficiencyClass[];
+    /** Same as {@link label}. */
+    get value(): string;
+    /** Resolves a label. Parsing always yields a value on the pre-2021 scale. */
+    static tryParse(input: string | null | undefined): EuEnergyEfficiencyClass | null;
+    static parse(input: string): EuEnergyEfficiencyClass;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical label, e.g. `A+++` or `B`. */
+    static format(input: string | null | undefined, options?: EuEnergyEfficiencyClassFormatOptions): string | null;
+    /** Returns the canonical label, e.g. `A+++` or `B`. */
+    static normalize(input: string | null | undefined, options?: EuEnergyEfficiencyClassFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    /** Ranks compare across scales, so old `A` and new `D` are treated as equivalent. */
+    equals(other: EuEnergyEfficiencyClass | null | undefined): boolean;
+    compareTo(other: EuEnergyEfficiencyClass | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface GoogleProductCategoryFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A Google product category path used by Google Shopping and Merchant Center, written as
+ * `>`-separated segments such as `Animals & Pet Supplies > Pet Supplies > Bird Supplies`.
+ *
+ * Only the path structure is checked; the segments are not matched against Google's published
+ * taxonomy, which changes over time.
+ */
+declare class GoogleProductCategory {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The full path in canonical form, e.g. `Animals & Pet Supplies > Pet Supplies`. */
+    readonly path: string;
+    /** The individual segments, e.g. `["Animals & Pet Supplies", "Pet Supplies"]`. */
+    readonly segments: readonly string[];
+    private constructor();
+    /** The number of hierarchy levels, where 1 is a root category on its own. */
+    get depth(): number;
+    /** The top-level category, e.g. `Animals & Pet Supplies`. */
+    get rootCategory(): string;
+    /** The most specific category, e.g. `Bird Supplies`. */
+    get leafCategory(): string;
+    static tryParse(input: string | null | undefined): GoogleProductCategory | null;
+    static parse(input: string): GoogleProductCategory;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the path with canonical ` > ` separators. */
+    static format(input: string | null | undefined, options?: GoogleProductCategoryFormatOptions): string | null;
+    /** Returns the path with canonical ` > ` separators. */
+    static normalize(input: string | null | undefined, options?: GoogleProductCategoryFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: GoogleProductCategory | null | undefined): boolean;
+    /** Orders segment by segment, so a parent sorts before its children. */
+    compareTo(other: GoogleProductCategory | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface GtinFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A Global Trade Item Number of any GS1 length: 8, 12, 13 or 14 digits. Use this when the
+ * length is not known up front; the fixed-length types expose the parts specific to each
+ * format. Validated with the GS1 modulo-10 check digit.
+ */
+declare class Gtin {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The digits, e.g. `5901234123457`. */
+    readonly digits: string;
+    /** Number of digits: 8, 12, 13 or 14. */
+    readonly length: number;
+    /** The GS1 modulo-10 check digit (last digit). */
+    readonly checkDigit: number;
+    private constructor();
+    /** Returns the GTIN zero-padded to 14 digits, the form used for cross-length comparison. */
+    toGtin14Digits(): string;
+    static tryParse(input: string | null | undefined): Gtin | null;
+    static parse(input: string): Gtin;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: GtinFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: GtinFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: Gtin | null | undefined): boolean;
+    compareTo(other: Gtin | null | undefined): number;
+}
+
+/** The hierarchy level of an HS code, from a two-digit chapter to a ten-digit TARIC code. */
+declare const HsCodeLevel: {
+    readonly Unknown: 0;
+    readonly Chapter: 1;
+    readonly Heading: 2;
+    readonly Subheading: 3;
+    readonly CnSubheading: 4;
+    readonly TaricCode: 5;
+};
+type HsCodeLevel = (typeof HsCodeLevel)[keyof typeof HsCodeLevel];
+
+/** Options shared by the string-in, string-out helpers. */
+interface HsCodeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A Harmonized System code for classifying goods in international trade, accepted at all five
+ * levels: the two-digit chapter, four-digit heading, six-digit subheading maintained by the WCO,
+ * the EU's eight-digit Combined Nomenclature code (`KN-nummer`) and its ten-digit TARIC code.
+ *
+ * Separators in the input are ignored, so `8471.30` and `8471 30` both give the same code.
+ */
+declare class HsCode {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The code as digits only, e.g. `847130`. */
+    readonly digits: string;
+    /** The display form with dots, e.g. `8471.30`. */
+    readonly formatted: string;
+    /** The chapter, the first two digits, e.g. `84`. */
+    readonly chapter: string;
+    /** The hierarchy level this code sits at. */
+    readonly level: HsCodeLevel;
+    private constructor();
+    static tryParse(input: string | null | undefined): HsCode | null;
+    static parse(input: string): HsCode;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the dot-separated display form, e.g. `8471.30` or `8471.30.00`. */
+    static format(input: string | null | undefined, options?: HsCodeFormatOptions): string | null;
+    /** Returns the dot-separated canonical form, e.g. `8471.30`. */
+    static normalize(input: string | null | undefined, options?: HsCodeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: HsCode | null | undefined): boolean;
+    compareTo(other: HsCode | null | undefined): number;
+}
+
+/** The family a recognized operating system name belongs to. */
+declare const OperatingSystemFamily: {
+    readonly Unknown: 0;
+    readonly Windows: 1;
+    readonly MacOS: 2;
+    readonly Linux: 3;
+    readonly Android: 4;
+    readonly IOS: 5;
+    readonly IPadOS: 6;
+    readonly ChromeOS: 7;
+    readonly WatchOS: 8;
+    readonly Other: 9;
+    readonly None: 10;
+};
+type OperatingSystemFamily = (typeof OperatingSystemFamily)[keyof typeof OperatingSystemFamily];
+
+/** Options shared by the string-in, string-out helpers. */
+interface OperatingSystemNameFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A recognized operating system name, e.g. `Windows`, `macOS` or `Ubuntu`, resolved from the
+ * aliases the trade uses, so `win`, `ms windows` and `Windows` all give the same value.
+ */
+declare class OperatingSystemName {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The canonical name, e.g. `macOS`. */
+    readonly value: string;
+    /** The family this name belongs to. */
+    readonly family: OperatingSystemFamily;
+    private constructor();
+    static tryParse(input: string | null | undefined): OperatingSystemName | null;
+    static parse(input: string): OperatingSystemName;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical name, e.g. `macOS`. */
+    static format(input: string | null | undefined, options?: OperatingSystemNameFormatOptions): string | null;
+    /** Returns the canonical name, e.g. `macOS`. */
+    static normalize(input: string | null | undefined, options?: OperatingSystemNameFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: OperatingSystemName | null | undefined): boolean;
+    compareTo(other: OperatingSystemName | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface OperatingSystemVersionFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * An operating system version, e.g. `11`, `14.5`, `10.15.7` or `22.04`, with up to four numeric
+ * parts. A leading `v` is accepted on input and dropped from the value.
+ */
+declare class OperatingSystemVersion {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The version string, e.g. `14.5`. */
+    readonly value: string;
+    /** The first part, e.g. `14` in `14.5`. */
+    readonly major: number;
+    /** The second part when present, e.g. `5` in `14.5`. */
+    readonly minor: number | null;
+    /** The third part when present, e.g. `7` in `10.15.7`. */
+    readonly patch: number | null;
+    /** The fourth part when present. */
+    readonly build: number | null;
+    private constructor();
+    static tryParse(input: string | null | undefined): OperatingSystemVersion | null;
+    static parse(input: string): OperatingSystemVersion;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical version string, e.g. `14.5`. */
+    static format(input: string | null | undefined, options?: OperatingSystemVersionFormatOptions): string | null;
+    /** Returns the canonical version string, e.g. `14.5`. */
+    static normalize(input: string | null | undefined, options?: OperatingSystemVersionFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: OperatingSystemVersion | null | undefined): boolean;
+    /** Orders numerically part by part, treating a missing part as zero. */
+    compareTo(other: OperatingSystemVersion | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface OperatingSystemInfoFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * An operating system name with an optional version, e.g. `Windows 11`, `macOS 14.5` or
+ * `Ubuntu 22.04`. The name is matched greedily from the longest prefix, so multi-word names such
+ * as `Arch Linux` are not mistaken for a shorter one followed by a version.
+ */
+declare class OperatingSystemInfo {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The operating system name. */
+    readonly name: OperatingSystemName;
+    /** The version when the input carried one, otherwise `null`. */
+    readonly version: OperatingSystemVersion | null;
+    /** Display form, e.g. `Windows 11`. */
+    readonly value: string;
+    private constructor();
+    static tryParse(input: string | null | undefined): OperatingSystemInfo | null;
+    static parse(input: string): OperatingSystemInfo;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical display form, e.g. `Windows 11`. */
+    static format(input: string | null | undefined, options?: OperatingSystemInfoFormatOptions): string | null;
+    /** Returns the canonical display form, e.g. `Windows 11`. */
+    static normalize(input: string | null | undefined, options?: OperatingSystemInfoFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: OperatingSystemInfo | null | undefined): boolean;
+    compareTo(other: OperatingSystemInfo | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface PowerSourceFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Power source (`strömkälla` / `drivkälla`) of a device, machine, or appliance, e.g.
+ * `Electric`, `Battery`, `Diesel`, `Petrol`, `Hybrid`, `Manual`.
+ */
+declare class PowerSource {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly isElectric: boolean;
+    readonly isCombustion: boolean;
+    readonly requiresFuel: boolean;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Electric: PowerSource;
+    static readonly Battery: PowerSource;
+    static readonly Solar: PowerSource;
+    static readonly Hybrid: PowerSource;
+    static readonly Petrol: PowerSource;
+    static readonly Diesel: PowerSource;
+    static readonly Hydrogen: PowerSource;
+    static readonly Pneumatic: PowerSource;
+    static readonly Hydraulic: PowerSource;
+    static readonly Manual: PowerSource;
+    /** All 10 values, in canonical order. */
+    static get all(): readonly PowerSource[];
+    /** 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): PowerSource | null;
+    static parse(input: string): PowerSource;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: PowerSourceFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: PowerSourceFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: PowerSource | null | undefined): boolean;
+    compareTo(other: PowerSource | null | undefined): number;
+}
+
+/** Options for {@link ProcessorSpeed.format} and {@link ProcessorSpeed.normalize}. */
+interface ProcessorSpeedFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: FrequencyUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * Processor clock speed (`processorhastighet`), e.g. `3.5 GHz` or `800 MHz`. A bare number is
+ * read as gigahertz.
+ */
+declare class ProcessorSpeed {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The underlying frequency. */
+    readonly speed: Frequency;
+    /** Display form preserving the parsed unit, e.g. `3.5 GHz`. */
+    readonly value: string;
+    private constructor();
+    get hertz(): number;
+    get megahertz(): number;
+    get gigahertz(): number;
+    /** Creates a speed from a value and frequency unit. The value must be positive. */
+    static create(value: number | Decimal, unit: FrequencyUnit): ProcessorSpeed;
+    static fromMegahertz(value: number | Decimal): ProcessorSpeed;
+    static fromGigahertz(value: number | Decimal): ProcessorSpeed;
+    static tryParse(input: string | null | undefined): ProcessorSpeed | null;
+    static parse(input: string): ProcessorSpeed;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form, e.g. `3.5 GHz`. Returns `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: ProcessorSpeedFormatOptions): string | null;
+    /** Returns the value in hertz, e.g. `3500000000 Hz`. Returns `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: ProcessorSpeedFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    /** Returns the value in the most readable unit, e.g. `3.5 GHz` rather than `3500000000 Hz`. */
+    toNaturalString(decimals?: number): string;
+    plus(other: ProcessorSpeed): ProcessorSpeed;
+    minus(other: ProcessorSpeed): ProcessorSpeed;
+    times(factor: number | Decimal): ProcessorSpeed;
+    dividedBy(divisor: number | Decimal): ProcessorSpeed;
+    negated(): ProcessorSpeed;
+    equals(other: ProcessorSpeed | null | undefined): boolean;
+    compareTo(other: ProcessorSpeed | null | undefined): number;
+}
+
+/** Options for {@link RamCapacity.format} and {@link RamCapacity.normalize}. */
+interface RamCapacityFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: DataSizeUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * Working memory capacity (`arbetsminne`), e.g. `16 GB` or `512 MB`. A bare number is read as
+ * gigabytes.
+ */
+declare class RamCapacity {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The underlying data size. */
+    readonly size: DataSize;
+    /** Display form preserving the parsed unit, e.g. `16 GB`. */
+    readonly value: string;
+    private constructor();
+    get bytes(): number;
+    get megabytes(): number;
+    get gigabytes(): number;
+    /** Creates a capacity from a value and data size unit. The value must be positive. */
+    static create(value: number | Decimal, unit: DataSizeUnit): RamCapacity;
+    static fromMegabytes(value: number | Decimal): RamCapacity;
+    static fromGigabytes(value: number | Decimal): RamCapacity;
+    static tryParse(input: string | null | undefined): RamCapacity | null;
+    static parse(input: string): RamCapacity;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form, e.g. `16 GB`. Returns `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: RamCapacityFormatOptions): string | null;
+    /** Returns the value in bytes, e.g. `16000000000 B`. Returns `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: RamCapacityFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    /** Returns the value in the most readable unit, e.g. `16 GB` rather than `16000000000 B`. */
+    toNaturalString(decimals?: number): string;
+    plus(other: RamCapacity): RamCapacity;
+    minus(other: RamCapacity): RamCapacity;
+    times(factor: number | Decimal): RamCapacity;
+    dividedBy(divisor: number | Decimal): RamCapacity;
+    negated(): RamCapacity;
+    equals(other: RamCapacity | null | undefined): boolean;
+    compareTo(other: RamCapacity | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface ShoeSizeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Generic shoe size (`skostorlek`) wrapping either an {@link AdultShoeSize} or a
+ * {@link ChildShoeSize}, chosen by parsing heuristics.
+ *
+ * An explicit `adult`/`vuxen` or `child`/`barn` prefix forces the matching parser. US sizes with
+ * a `C` or `Y` suffix are read as children's first; otherwise adult is tried before child, so an
+ * unprefixed EU 35–39 resolves as adult.
+ */
+declare class ShoeSize {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    private readonly adult;
+    private readonly child;
+    private constructor();
+    /** `true` when this instance wraps an {@link AdultShoeSize}. */
+    get isAdult(): boolean;
+    /** `true` when this instance wraps a {@link ChildShoeSize}. */
+    get isChild(): boolean;
+    /** Display form of the wrapped size, e.g. `EU 42` or `EU 28`. */
+    get value(): string;
+    /** Returns the adult size when {@link isAdult}, otherwise `null`. */
+    asAdult(): AdultShoeSize | null;
+    /** Returns the child size when {@link isChild}, otherwise `null`. */
+    asChild(): ChildShoeSize | null;
+    static tryParse(input: string | null | undefined): ShoeSize | null;
+    static parse(input: string): ShoeSize;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the canonical EU display of the resolved kind, e.g. `EU 42` or `EU 28`. */
+    static format(input: string | null | undefined, options?: ShoeSizeFormatOptions): string | null;
+    /** Returns the canonical EU display, the same as {@link format} for this wrapper. */
+    static normalize(input: string | null | undefined, options?: ShoeSizeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: ShoeSize | null | undefined): boolean;
+    compareTo(other: ShoeSize | null | undefined): number;
+}
+
+/** Options for {@link StorageCapacity.format} and {@link StorageCapacity.normalize}. */
+interface StorageCapacityFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: DataSizeUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * Storage capacity for hard drives, SSDs and USB drives (`lagringskapacitet`), e.g. `512 GB`
+ * or `1 TB`. A bare number is read as gigabytes.
+ */
+declare class StorageCapacity {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The underlying data size. */
+    readonly size: DataSize;
+    /** Display form preserving the parsed unit, e.g. `512 GB`. */
+    readonly value: string;
+    private constructor();
+    get bytes(): number;
+    get gigabytes(): number;
+    get terabytes(): number;
+    /** Creates a capacity from a value and data size unit. The value must be positive. */
+    static create(value: number | Decimal, unit: DataSizeUnit): StorageCapacity;
+    static fromMegabytes(value: number | Decimal): StorageCapacity;
+    static fromGigabytes(value: number | Decimal): StorageCapacity;
+    static fromTerabytes(value: number | Decimal): StorageCapacity;
+    static tryParse(input: string | null | undefined): StorageCapacity | null;
+    static parse(input: string): StorageCapacity;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form, e.g. `512 GB`. Returns `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: StorageCapacityFormatOptions): string | null;
+    /** Returns the value in bytes, e.g. `512000000000 B`. Returns `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: StorageCapacityFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    /** Returns the value in the most readable unit, e.g. `512 GB` rather than `512000000000 B`. */
+    toNaturalString(decimals?: number): string;
+    plus(other: StorageCapacity): StorageCapacity;
+    minus(other: StorageCapacity): StorageCapacity;
+    times(factor: number | Decimal): StorageCapacity;
+    dividedBy(divisor: number | Decimal): StorageCapacity;
+    negated(): StorageCapacity;
+    equals(other: StorageCapacity | null | undefined): boolean;
+    compareTo(other: StorageCapacity | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface StorageMediaTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Storage media technology (`lagringsmedia`) used in computers, laptops, phones, and consumer
+ * electronics, e.g. `SSD`, `HDD`, `NVMe`, `eMMC`, `UFS`, `Flash`.
+ */
+declare class StorageMediaType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly family: string;
+    readonly isSolidState: boolean;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Hdd: StorageMediaType;
+    static readonly Sshd: StorageMediaType;
+    static readonly Ssd: StorageMediaType;
+    static readonly Nvme: StorageMediaType;
+    static readonly EMmc: StorageMediaType;
+    static readonly Ufs: StorageMediaType;
+    static readonly Flash: StorageMediaType;
+    static readonly Optane: StorageMediaType;
+    /** All 8 values, in canonical order. */
+    static get all(): readonly StorageMediaType[];
+    /** 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): StorageMediaType | null;
+    static parse(input: string): StorageMediaType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: StorageMediaTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: StorageMediaTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: StorageMediaType | null | undefined): boolean;
+    compareTo(other: StorageMediaType | null | undefined): number;
+}
+
+/** BarcodeLookup.com URL for a GTIN-8 or GTIN-13, e.g. `https://www.barcodelookup.com/5901234123457`. */
+declare function toBarcodeLookupUrl(gtin: Gtin8 | Gtin13): string;
+
+/** Mask an aspect ratio, e.g. `16:9` becomes `**:*`. */
+declare function maskAspectRatio(ratio: AspectRatio): string;
+/** Mask a battery chemistry, e.g. `Li-ion` becomes `******`. */
+declare function maskBatteryChemistry(chemistry: BatteryChemistry): string;
+/** Mask a camera resolution, e.g. `12.2 MP` becomes `*** MP`. */
+declare function maskCameraResolution(_resolution: CameraResolution): string;
+/** Mask a clothing fit, e.g. `Slim` becomes `****`. */
+declare function maskClothingFit(fit: ClothingFit): string;
+/** Mask a clothing season, e.g. `All-Season` becomes `***-******`. Hyphens stay visible. */
+declare function maskClothingSeason(season: ClothingSeason): string;
+/** Mask a color, e.g. `#FF0000` becomes `#******`. */
+declare function maskColor(_color: Color): string;
+/** Mask a display panel type, e.g. `OLED` becomes `****`. */
+declare function maskDisplayPanelType(panel: DisplayPanelType): string;
+/** Mask an electrical phase, e.g. `3-phase` becomes `*-phase`. */
+declare function maskElectricalPhase(phase: ElectricalPhase): string;
+/** Mask a GTIN-8 completely, e.g. `96385074` becomes `********`. */
+declare function maskGtin8(gtin: Gtin8): string;
+/** Mask a GTIN-12 completely, e.g. `614141000036` becomes `************`. */
+declare function maskGtin12(gtin: Gtin12): string;
+/** Mask a GTIN-13, keeping the GS1 prefix: `5901234123457` becomes `590**********`. */
+declare function maskGtin13(gtin: Gtin13): string;
+/** Mask a GTIN-14 completely, e.g. `10614141000415` becomes `**************`. */
+declare function maskGtin14(gtin: Gtin14): string;
+/** Mask an IP rating, e.g. `IP65` becomes `IP**`. */
+declare function maskIpRating(_rating: IpRating): string;
+/** Mask a power source, e.g. `Electric` becomes `********`. */
+declare function maskPowerSource(source: PowerSource): string;
+/** Mask a refrigerant designation, keeping the `R` prefix: `R-134a` becomes `R-****`. */
+declare function maskRefrigerant(refrigerant: Refrigerant): string;
+/** Mask a screen resolution, e.g. `1920x1080` becomes `*** x ***`. */
+declare function maskScreenResolution(_resolution: ScreenResolution): string;
+/** Mask a screen size, e.g. `15.6 in` becomes `*** in`. */
+declare function maskScreenSize(_size: ScreenSize): string;
+/** Mask a storage media type, e.g. `NVMe` becomes `****`. */
+declare function maskStorageMediaType(storage: StorageMediaType): string;
+
+export { AdultClothingSize, type AdultClothingSizeFormatOptions, AdultShoeSize, type AdultShoeSizeFormatOptions, AspectRatio, type AspectRatioFormatOptions, BatteryCapacity, type BatteryCapacityFormatOptions, BatteryChemistry, type BatteryChemistryFormatOptions, CameraResolution, type CameraResolutionFormatOptions, ChildClothingSize, type ChildClothingSizeFormatOptions, ChildShoeSize, type ChildShoeSizeFormatOptions, ClothingFit, type ClothingFitFormatOptions, ClothingGender, type ClothingGenderFormatOptions, ClothingSeason, type ClothingSeasonFormatOptions, ClothingSize, type ClothingSizeFormatOptions, ClothingSizeSystem, Color, DisplayPanelType, type DisplayPanelTypeFormatOptions, ElectricalPhase, EnergyScale, EuEnergyEfficiencyClass, type EuEnergyEfficiencyClassFormatOptions, GoogleProductCategory, type GoogleProductCategoryFormatOptions, Gtin, Gtin12, Gtin13, Gtin14, Gtin8, type GtinFormatOptions, HsCode, type HsCodeFormatOptions, HsCodeLevel, IpRating, OperatingSystemFamily, OperatingSystemInfo, type OperatingSystemInfoFormatOptions, OperatingSystemName, type OperatingSystemNameFormatOptions, OperatingSystemVersion, type OperatingSystemVersionFormatOptions, PowerSource, type PowerSourceFormatOptions, ProcessorSpeed, type ProcessorSpeedFormatOptions, RamCapacity, type RamCapacityFormatOptions, Refrigerant, ScreenResolution, ScreenSize, ShoeSize, type ShoeSizeFormatOptions, ShoeSizeSystem, StorageCapacity, type StorageCapacityFormatOptions, StorageMediaType, type StorageMediaTypeFormatOptions, maskAspectRatio, maskBatteryChemistry, maskCameraResolution, maskClothingFit, maskClothingSeason, maskColor, maskDisplayPanelType, maskElectricalPhase, maskGtin12, maskGtin13, maskGtin14, maskGtin8, maskIpRating, maskPowerSource, maskRefrigerant, maskScreenResolution, maskScreenSize, maskStorageMediaType, toBarcodeLookupUrl };