@budiauktioner/buildi-primitives 0.1.0

package/dist/country-p0n0EVQ9.d.ts

@@ -0,0 +1,433 @@
+import { P as PrimitiveTypeInfo, T as TextCandidate } from './text-candidate-qg2bD9PY.js';
+
+interface ContinentFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A continent (`kontinent`) identified by its two-letter code, English name,
+ * or Swedish name. Seven continents are recognized: Africa, Antarctica, Asia,
+ * Europe, North America, Oceania, and South America.
+ *
+ * Sources:
+ * - UN M49 Standard
+ * - Datahub continent codes
+ */
+declare class Continent {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Africa: Continent;
+    static readonly Antarctica: Continent;
+    static readonly Asia: Continent;
+    static readonly Europe: Continent;
+    static readonly NorthAmerica: Continent;
+    static readonly Oceania: Continent;
+    static readonly SouthAmerica: Continent;
+    /** All seven continents. */
+    static readonly all: readonly Continent[];
+    readonly code: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    private constructor();
+    get displayName(): string;
+    get value(): string;
+    static tryParse(input: string | null | undefined): Continent | null;
+    static parse(input: string): Continent;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: ContinentFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: ContinentFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: Continent | null | undefined): boolean;
+    compareTo(other: Continent | null | undefined): number;
+}
+
+interface GeoCoordinateFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A geographic coordinate pair (latitude, longitude) in the WGS 84 reference
+ * system (`geografisk koordinat`). Parsing accepts decimal degrees, degrees
+ * with cardinal directions, DMS, and DDM formats. Swedish cardinal letters Ö
+ * (east) and V (west) are accepted alongside E and W.
+ */
+declare class GeoCoordinate {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly latitude: number;
+    readonly longitude: number;
+    private constructor();
+    /** @internal */
+    static _unsafe(latitude: number, longitude: number): GeoCoordinate;
+    get latitudeDirection(): "N" | "S";
+    get longitudeDirection(): "E" | "W";
+    /** Creates a coordinate from explicit latitude and longitude values. */
+    static create(latitude: number, longitude: number): GeoCoordinate;
+    static tryParse(input: string | null | undefined): GeoCoordinate | null;
+    static parse(input: string): GeoCoordinate;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: GeoCoordinateFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: GeoCoordinateFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    /** Returns the coordinate in degrees, minutes, and seconds, e.g. `59°19'45.5"N, 18°4'7"E`. */
+    toDmsString(): string;
+    /** Distance in kilometers (Haversine) between two coordinates. */
+    static distanceKilometers(a: GeoCoordinate, b: GeoCoordinate): number;
+    /** Returns true if coordinates `a` and `b` are within `radiusKm` kilometers of each other. */
+    static isWithinKilometers(a: GeoCoordinate, b: GeoCoordinate, radiusKm: number): boolean;
+    /** Distance in kilometers from this coordinate to `other`. */
+    distanceKilometersTo(other: GeoCoordinate): number;
+    /**
+     * Returns true if `other` is within `radiusKm` kilometers of this
+     * coordinate (inclusive).
+     */
+    isWithinKilometers(other: GeoCoordinate, radiusKm: number): boolean;
+    equals(other: GeoCoordinate | null | undefined): boolean;
+}
+
+/**
+ * The capital city of a country (`huvudstad`), with names in English, Swedish,
+ * and the country's native language, plus its geographic coordinates.
+ */
+declare class CountryCapital {
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly nativeName: string;
+    readonly coordinate: GeoCoordinate;
+    /** @internal */
+    constructor(englishName: string, localizedName: string, nativeName: string, coordinate: GeoCoordinate);
+    /** Capital city name in the current display language. */
+    get displayName(): string;
+    toString(): string;
+}
+
+/** Text direction for a writing system. */
+declare const TextDirection: {
+    readonly LeftToRight: "LeftToRight";
+    readonly RightToLeft: "RightToLeft";
+};
+type TextDirection = (typeof TextDirection)[keyof typeof TextDirection];
+/** Primary writing script / writing system used by a language. */
+declare const WritingScript: {
+    readonly Unknown: "Unknown";
+    readonly Latin: "Latin";
+    readonly Cyrillic: "Cyrillic";
+    readonly Arabic: "Arabic";
+    readonly Greek: "Greek";
+    readonly Hebrew: "Hebrew";
+    readonly Devanagari: "Devanagari";
+    readonly Bengali: "Bengali";
+    readonly Gurmukhi: "Gurmukhi";
+    readonly Gujarati: "Gujarati";
+    readonly Oriya: "Oriya";
+    readonly Tamil: "Tamil";
+    readonly Telugu: "Telugu";
+    readonly Kannada: "Kannada";
+    readonly Malayalam: "Malayalam";
+    readonly Sinhala: "Sinhala";
+    readonly Thai: "Thai";
+    readonly Lao: "Lao";
+    readonly Tibetan: "Tibetan";
+    readonly Myanmar: "Myanmar";
+    readonly Georgian: "Georgian";
+    readonly Hangul: "Hangul";
+    readonly Ethiopic: "Ethiopic";
+    readonly Cherokee: "Cherokee";
+    readonly Canadian: "Canadian";
+    readonly Khmer: "Khmer";
+    readonly Mongolian: "Mongolian";
+    readonly Han: "Han";
+    readonly Armenian: "Armenian";
+    readonly Thaana: "Thaana";
+};
+type WritingScript = (typeof WritingScript)[keyof typeof WritingScript];
+interface LanguageFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A language (`språk`) identified by its ISO 639-1 two-letter code, ISO 639-2/T
+ * three-letter code, English name, Swedish name, or native name (endonym).
+ */
+declare class Language {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly alpha2Code: string;
+    readonly alpha3Code: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly nativeName: string;
+    readonly script: WritingScript;
+    readonly direction: TextDirection;
+    private constructor();
+    get displayName(): string;
+    get value(): string;
+    /** @internal Used by Country and other types. */
+    static _create(alpha2: string, alpha3: string, en: string, sv: string, native: string, script: WritingScript, direction?: TextDirection): Language;
+    static tryParse(input: string | null | undefined): Language | null;
+    static parse(input: string): Language;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: LanguageFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: LanguageFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toNativeString(): string;
+    toString(): string;
+    equals(other: Language | null | undefined): boolean;
+    compareTo(other: Language | null | undefined): number;
+    /** All recognized ISO 639-1 languages. */
+    static get all(): readonly Language[];
+    static readonly Afrikaans: Language;
+    static readonly Albanian: Language;
+    static readonly Arabic: Language;
+    static readonly Bulgarian: Language;
+    static readonly Catalan: Language;
+    static readonly Chinese: Language;
+    static readonly Croatian: Language;
+    static readonly Czech: Language;
+    static readonly Danish: Language;
+    static readonly Dutch: Language;
+    static readonly English: Language;
+    static readonly Estonian: Language;
+    static readonly Faroese: Language;
+    static readonly Finnish: Language;
+    static readonly French: Language;
+    static readonly German: Language;
+    static readonly Greek: Language;
+    static readonly Hindi: Language;
+    static readonly Hungarian: Language;
+    static readonly Icelandic: Language;
+    static readonly Italian: Language;
+    static readonly Japanese: Language;
+    static readonly Korean: Language;
+    static readonly Latvian: Language;
+    static readonly Lithuanian: Language;
+    static readonly NorthernSami: Language;
+    static readonly Norwegian: Language;
+    static readonly NorwegianBokmal: Language;
+    static readonly NorwegianNynorsk: Language;
+    static readonly Polish: Language;
+    static readonly Portuguese: Language;
+    static readonly Romanian: Language;
+    static readonly Russian: Language;
+    static readonly Slovak: Language;
+    static readonly Slovenian: Language;
+    static readonly Spanish: Language;
+    static readonly Swahili: Language;
+    static readonly Swedish: Language;
+    static readonly Turkish: Language;
+    static readonly Ukrainian: Language;
+}
+
+interface CurrencyRow {
+    code: string;
+    en: string;
+    sv: string;
+    symbol: string;
+    decimalPlaces: number;
+}
+/**
+ * An ISO 4217 currency identified by its three-letter code (e.g. `SEK`, `EUR`).
+ */
+declare class Currency {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly code: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly symbol: string;
+    readonly decimalPlaces: number;
+    private constructor();
+    /** @internal */
+    static _fromRow(row: CurrencyRow): Currency;
+    /** Display name in current UI culture (Swedish or English). */
+    /**
+     * The currency name as used in its issuing country. Falls back to
+     * {@link englishName} when no issuing country is known.
+     */
+    get nativeName(): string;
+    get displayName(): string;
+    static tryParse(input: string | null | undefined): Currency | null;
+    static parse(input: string): Currency;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: {
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static normalize(input: string | null | undefined, options?: {
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** All known currencies. */
+    static get all(): readonly Currency[];
+    /** @internal Lookup by symbol. */
+    static tryParseSymbol(symbol: string | null | undefined): Currency | null;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toNativeString(): string;
+    equals(other: Currency | null | undefined): boolean;
+    compareTo(other: Currency | null | undefined): number;
+    static get SEK(): Currency;
+    static get EUR(): Currency;
+    static get USD(): Currency;
+    static get NOK(): Currency;
+    static get DKK(): Currency;
+    static get GBP(): Currency;
+}
+/**
+ * Returns the primary currency for a country, or `null` when no association
+ * is known. Resolves the country's first `currencyCodes` entry to a
+ * {@link Currency} instance.
+ */
+declare function getCurrencyForCountry(country: Country): Currency | null;
+
+/**
+ * Static country data: ISO 3166-1 alpha-2/alpha-3/numeric codes, English/Swedish/native names,
+ * E.164 calling code, ccTLD, continent. Sourced from ISO 3166, ITU-T E.164, and IANA root db.
+ */
+interface CountryRow {
+    readonly alpha2: string;
+    readonly alpha3: string;
+    readonly numeric: number;
+    readonly en: string;
+    readonly sv: string;
+    readonly native: string;
+    readonly callingCode: string;
+    readonly tld: string;
+    readonly continent: Continent;
+}
+
+/** A neighboring country with its distance from a reference point (kilometers). */
+interface CountryDistance {
+    readonly country: Country;
+    readonly distanceKilometers: number;
+}
+/**
+ * A country identified by its English name, Swedish name, local name (endonym),
+ * or ISO 3166-1 codes. Each country exposes its phone calling code, ccTLD,
+ * continent, European classifications (EU, EEA, Schengen, Nordics, SEPA), and
+ * currency metadata. Parsing accepts English/Swedish/local names, alpha-2 and
+ * alpha-3 codes, and common aliases (USA, UK, Holland, etc.).
+ */
+declare class Country {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly alpha2Code: string;
+    readonly alpha3Code: string;
+    readonly numericCode: number;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly nativeName: string;
+    readonly callingCode: string;
+    readonly topLevelDomain: string;
+    readonly continent: Continent;
+    readonly currencyCodes: readonly string[];
+    readonly languageCodes: readonly string[];
+    private constructor();
+    /** The canonical value of this country: its ISO 3166-1 alpha-2 code. */
+    get value(): string;
+    /** Display name in the current culture (Swedish or English). */
+    get displayName(): string;
+    /** Culture-independent display form. Always the English name. */
+    get formatted(): string;
+    /** Geographic coordinate of the country (centroid, from Wikidata P625). */
+    get coordinate(): GeoCoordinate;
+    /** Approximate latitude (WGS 84) of the country centroid. */
+    get latitude(): number;
+    /** Approximate longitude (WGS 84) of the country centroid. */
+    get longitude(): number;
+    /** Capital city, or `null` for entries without a capital (e.g. Antarctica). */
+    get capital(): CountryCapital | null;
+    get isInEuropeanUnion(): boolean;
+    get isInEea(): boolean;
+    get isInSchengen(): boolean;
+    get isInNordics(): boolean;
+    get isInSepa(): boolean;
+    /** True when the euro is among the country's legal tenders. */
+    get usesEuro(): boolean;
+    /** Primary ISO 4217 currency code, or `null` when unknown. */
+    get currencyCode(): string | null;
+    /**
+     * Primary legal-tender currency, or `null` when unknown. Countries with
+     * several legal tenders (Cuba, Panama, Namibia) return the first; use
+     * {@link currencies} for the full list.
+     */
+    get currency(): Currency | null;
+    /** All recognized currencies for this country, in priority order. */
+    get currencies(): readonly Currency[];
+    /**
+     * Primary official language, or `null` when unknown. Countries with several
+     * official languages (Belgium, Switzerland) return the most widely spoken;
+     * use {@link officialLanguages} for the full list.
+     */
+    get primaryLanguage(): Language | null;
+    /** All official languages of the country, in priority order. */
+    get officialLanguages(): readonly Language[];
+    static tryParse(input: string | null | undefined): Country | null;
+    static parse(input: string): Country;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: {
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static normalize(input: string | null | undefined, options?: {
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Look up a country by its phone calling code. Primary owner wins for shared codes. */
+    static tryFindByCallingCode(callingCode: string | null | undefined): Country | null;
+    /** All known countries. */
+    static get all(): readonly Country[];
+    /**
+     * Returns countries within `radiusKm` of this country, ordered by distance.
+     */
+    findNeighbors(radiusKm: number): readonly CountryDistance[];
+    /** Returns countries within `radiusKm` of `coordinate`, ordered by distance. */
+    static findNeighbors(coordinate: GeoCoordinate, radiusKm: number): readonly CountryDistance[];
+    /**
+     * Scans unstructured text for country names (4+ chars, word-bounded). Low confidence
+     * because country names can occur in non-geographic contexts.
+     */
+    static findCandidatesInText(text: string): readonly TextCandidate<Country>[];
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toNativeString(): string;
+    equals(other: Country | null | undefined): boolean;
+    compareTo(other: Country | null | undefined): number;
+    static get Sweden(): Country;
+    static get Norway(): Country;
+    static get Finland(): Country;
+    static get Denmark(): Country;
+    static get Iceland(): Country;
+    static get Germany(): Country;
+    static get Poland(): Country;
+    static get Estonia(): Country;
+    static get Lithuania(): Country;
+    static get Latvia(): Country;
+    static get Romania(): Country;
+    static get Bulgaria(): Country;
+    static get CzechRepublic(): Country;
+    static get Spain(): Country;
+    static get Netherlands(): Country;
+    static get Greece(): Country;
+    static get Italy(): Country;
+    static get Slovenia(): Country;
+    static get Croatia(): Country;
+    static get Portugal(): Country;
+    static get Hungary(): Country;
+    static get France(): Country;
+    static get Slovakia(): Country;
+    static get Belgium(): Country;
+    static get UnitedKingdom(): Country;
+    static get Austria(): Country;
+    static get Cyprus(): Country;
+    static get Switzerland(): Country;
+    static get Ireland(): Country;
+    static get Luxembourg(): Country;
+    static get Malta(): Country;
+    static get Liechtenstein(): Country;
+    /** @internal */
+    static _fromRow(row: CountryRow): Country;
+}
+
+export { Continent as C, GeoCoordinate as G, Language as L, TextDirection as T, WritingScript as W, Country as a, CountryCapital as b, type CountryDistance as c, Currency as d, getCurrencyForCountry as g };