@budiauktioner/buildi-primitives 0.1.0

package/dist/swedish-address-DNC3ftRF.d.cts

@@ -0,0 +1,297 @@
+import { P as PrimitiveTypeInfo, T as TextCandidate } from './text-candidate-qg2bD9PY.cjs';
+import { a as Country } from './country-BhD51LDL.cjs';
+
+/**
+ * The postal city (`postort`) is the locality associated with a postal code.
+ * Normalization applies Swedish-aware title casing.
+ */
+declare class AddressCity {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    private constructor();
+    static tryParse(input: string | null | undefined): AddressCity | null;
+    static parse(input: string): AddressCity;
+    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;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: AddressCity | null | undefined): boolean;
+    compareTo(other: AddressCity | null | undefined): number;
+}
+
+/**
+ * A street address (`gatuadress`). Extracts care-of (c/o), apartment number
+ * (lgh/apt), and post box (Box) when present.
+ */
+declare class AddressStreet {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly street: string;
+    readonly streetName: string | null;
+    readonly streetNumber: string | null;
+    readonly apartmentNumber: string | null;
+    readonly careOf: string | null;
+    readonly postBox: string | null;
+    private constructor();
+    get isPostBox(): boolean;
+    static tryParse(input: string | null | undefined, options?: {
+        city?: string | null;
+        zipCode?: string | null;
+    }): AddressStreet | null;
+    static parse(input: string): AddressStreet;
+    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;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: AddressStreet | null | undefined): boolean;
+    compareTo(other: AddressStreet | null | undefined): number;
+}
+
+/**
+ * A postal code (`postnummer`). Swedish 5-digit codes (formatted `NNN NN`) and
+ * many international formats (Danish `DK-9000`, Dutch `1012 AB`, British `W1A 1AB`)
+ * are accepted.
+ */
+declare class AddressZipCode {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly formatted: string;
+    readonly country: Country | null;
+    private constructor();
+    get isSwedish(): boolean;
+    static tryParse(input: string | null | undefined, options?: {
+        country?: Country | null;
+    }): AddressZipCode | null;
+    static parse(input: string, options?: {
+        country?: Country | null;
+    }): AddressZipCode;
+    static isValid(input: string | null | undefined, options?: {
+        country?: Country | null;
+    }): boolean;
+    /** Parse as a Swedish 5-digit postal code only. */
+    static tryParseSwedish(input: string | null | undefined): AddressZipCode | null;
+    /** Parse as a non-Swedish international postal code. */
+    static tryParseInternational(input: string | null | undefined, country?: Country | null): AddressZipCode | null;
+    static format(input: string | null | undefined, options?: {
+        country?: Country | null;
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static normalize(input: string | null | undefined, options?: {
+        country?: Country | null;
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<AddressZipCode>[];
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: AddressZipCode | null | undefined): boolean;
+    compareTo(other: AddressZipCode | null | undefined): number;
+}
+/** Internal masking for zip codes used in scan results. */
+declare function maskZip(zip: AddressZipCode): string;
+
+/** Common interface for all country-specific zip code types. */
+interface ICountryAddressZipCode {
+    readonly country: Country;
+    readonly value: string;
+    readonly formatted: string;
+    readonly zipCode: AddressZipCode;
+    toNormalizedString(): string;
+    toString(): string;
+}
+/** Common interface for all country-specific address types. */
+interface ICountryAddress {
+    readonly country: Country;
+    readonly street: AddressStreet;
+    readonly countryZipCode: ICountryAddressZipCode;
+    readonly city: AddressCity;
+    readonly address: Address;
+    readonly careOf: string | null;
+    readonly postBox: string | null;
+    readonly isPostBox: boolean;
+    readonly value: string;
+    readonly formatted: string;
+    toNormalizedString(): string;
+    toMultilineString(): string;
+    toString(): string;
+}
+/** Abstract base class for country-specific zip code types. */
+declare abstract class CountryAddressZipCodeBase implements ICountryAddressZipCode {
+    readonly value: string;
+    readonly formatted: string;
+    readonly zipCode: AddressZipCode;
+    abstract get country(): Country;
+    protected constructor(value: string, formatted: string, zipCode: AddressZipCode);
+    toNormalizedString(): string;
+    toString(): string;
+}
+/** Abstract base class for country-specific address types. */
+declare abstract class CountryAddressBase implements ICountryAddress {
+    readonly street: AddressStreet;
+    readonly city: AddressCity;
+    readonly address: Address;
+    abstract get countryZipCode(): ICountryAddressZipCode;
+    get country(): Country;
+    get careOf(): string | null;
+    get postBox(): string | null;
+    get isPostBox(): boolean;
+    get value(): string;
+    get formatted(): string;
+    protected constructor(street: AddressStreet, city: AddressCity, address: Address);
+    toNormalizedString(): string;
+    toString(): string;
+    toMultilineString(): string;
+}
+/**
+ * Validates and unwraps a generic {@link Address} for a specific country, then constructs
+ * a typed country-specific address. Used by every `XxxAddress.tryParse` implementation.
+ */
+declare function tryWrapCountryAddress<TZip, TAddr>(address: Address, alpha2: string, defaultCountry: Country, tryParseZip: (value: string) => TZip | null, factory: (street: AddressStreet, zip: TZip, city: AddressCity, address: Address) => TAddr): TAddr | null;
+
+/** A complete address combining street, zip, city and country. */
+declare class Address {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly street: AddressStreet;
+    readonly zipCode: AddressZipCode | null;
+    readonly city: AddressCity | null;
+    readonly country: Country | null;
+    constructor(street: AddressStreet, zipCode?: AddressZipCode | null, city?: AddressCity | null, country?: Country | null);
+    get careOf(): string | null;
+    get apartmentNumber(): string | null;
+    get postBox(): string | null;
+    get isPostBox(): boolean;
+    get value(): string;
+    get formatted(): string;
+    static tryParse(input: string | null | undefined): Address | null;
+    static tryParse(parts: {
+        street: string | null | undefined;
+        zipCode?: string | null;
+        city?: string | null;
+        country?: string | null;
+    }): Address | null;
+    static parse(input: string): Address;
+    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;
+    /**
+     * Scans unstructured text for potential Swedish-style addresses.
+     *
+     * Results are heuristic candidates and can include false positives. Zip-code
+     * anchored matches receive medium confidence, while street-only matches
+     * receive low confidence.
+     */
+    static findCandidatesInText(text: string): readonly TextCandidate<Address>[];
+    toNormalizedString(): string;
+    toMultilineString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toNativeString(): string;
+    toString(): string;
+    toDomesticString(): string;
+    /**
+     * Multi-line form without the country line, using the country's own zip-code
+     * formatting when a country-specific address type is registered.
+     */
+    toDomesticMultilineString(): string;
+    /**
+     * Wraps this address in its country-specific type when the country is known
+     * and an implementation is registered, otherwise `null`.
+     */
+    asCountryAddress(): ICountryAddress | null;
+    /** Countries that have a dedicated country-specific address type. */
+    static get supportedCountryAddressTypes(): readonly Country[];
+    private buildStreetLine;
+    private buildStreetCoreLine;
+    private buildLocalityLine;
+    private buildDomesticLocalityLine;
+    private countryFormattedZip;
+    private buildSingleLine;
+}
+
+/** A Swedish postal code (`postnummer`) — strictly 5 digits, formatted `NNN NN`. */
+declare class SwedishAddressZipCode {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly formatted: string;
+    readonly zipCode: AddressZipCode;
+    get country(): Country;
+    private constructor();
+    static tryParse(input: string | null | undefined): SwedishAddressZipCode | null;
+    static parse(input: string): SwedishAddressZipCode;
+    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;
+    toNormalizedString(): string;
+    toString(): string;
+}
+
+/** A Swedish address — street + 5-digit zip + city, all within Sweden. */
+declare class SwedishAddress {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly street: AddressStreet;
+    readonly zipCode: SwedishAddressZipCode;
+    readonly city: AddressCity;
+    readonly address: Address;
+    get country(): Country;
+    /** The zip code as the country-agnostic {@link ICountryAddressZipCode} view. */
+    get countryZipCode(): ICountryAddressZipCode;
+    get careOf(): string | null;
+    get postBox(): string | null;
+    get isPostBox(): boolean;
+    get apartmentNumber(): string | null;
+    get value(): string;
+    get formatted(): string;
+    private constructor();
+    static tryParse(input: string | null | undefined): SwedishAddress | null;
+    static tryParse(parts: {
+        street: string | null | undefined;
+        zipCode?: string | null;
+        city?: string | null;
+        country?: string | null;
+    }): SwedishAddress | null;
+    static parse(input: string): SwedishAddress;
+    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;
+    /**
+     * Scans unstructured text for potential Swedish addresses.
+     *
+     * Results are heuristic candidates and can include false positives. Only
+     * address candidates with a Swedish zip code and city are returned.
+     */
+    static findCandidatesInText(text: string): readonly TextCandidate<SwedishAddress>[];
+    toNormalizedString(): string;
+    toString(): string;
+    toMultilineString(): string;
+    private buildStreetCoreLine;
+    /** Wraps an already-parsed {@link Address}. Used by the country-address registry. */
+    static tryWrap(address: Address): SwedishAddress | null;
+}
+
+export { Address as A, CountryAddressBase as C, type ICountryAddress as I, SwedishAddress as S, AddressCity as a, AddressStreet as b, AddressZipCode as c, CountryAddressZipCodeBase as d, type ICountryAddressZipCode as e, SwedishAddressZipCode as f, maskZip as m, tryWrapCountryAddress as t };

package/dist/swedish-address-GMzjqgxb.d.ts

@@ -0,0 +1,297 @@
+import { P as PrimitiveTypeInfo, T as TextCandidate } from './text-candidate-qg2bD9PY.js';
+import { a as Country } from './country-p0n0EVQ9.js';
+
+/**
+ * The postal city (`postort`) is the locality associated with a postal code.
+ * Normalization applies Swedish-aware title casing.
+ */
+declare class AddressCity {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    private constructor();
+    static tryParse(input: string | null | undefined): AddressCity | null;
+    static parse(input: string): AddressCity;
+    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;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: AddressCity | null | undefined): boolean;
+    compareTo(other: AddressCity | null | undefined): number;
+}
+
+/**
+ * A street address (`gatuadress`). Extracts care-of (c/o), apartment number
+ * (lgh/apt), and post box (Box) when present.
+ */
+declare class AddressStreet {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly street: string;
+    readonly streetName: string | null;
+    readonly streetNumber: string | null;
+    readonly apartmentNumber: string | null;
+    readonly careOf: string | null;
+    readonly postBox: string | null;
+    private constructor();
+    get isPostBox(): boolean;
+    static tryParse(input: string | null | undefined, options?: {
+        city?: string | null;
+        zipCode?: string | null;
+    }): AddressStreet | null;
+    static parse(input: string): AddressStreet;
+    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;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: AddressStreet | null | undefined): boolean;
+    compareTo(other: AddressStreet | null | undefined): number;
+}
+
+/**
+ * A postal code (`postnummer`). Swedish 5-digit codes (formatted `NNN NN`) and
+ * many international formats (Danish `DK-9000`, Dutch `1012 AB`, British `W1A 1AB`)
+ * are accepted.
+ */
+declare class AddressZipCode {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly formatted: string;
+    readonly country: Country | null;
+    private constructor();
+    get isSwedish(): boolean;
+    static tryParse(input: string | null | undefined, options?: {
+        country?: Country | null;
+    }): AddressZipCode | null;
+    static parse(input: string, options?: {
+        country?: Country | null;
+    }): AddressZipCode;
+    static isValid(input: string | null | undefined, options?: {
+        country?: Country | null;
+    }): boolean;
+    /** Parse as a Swedish 5-digit postal code only. */
+    static tryParseSwedish(input: string | null | undefined): AddressZipCode | null;
+    /** Parse as a non-Swedish international postal code. */
+    static tryParseInternational(input: string | null | undefined, country?: Country | null): AddressZipCode | null;
+    static format(input: string | null | undefined, options?: {
+        country?: Country | null;
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static normalize(input: string | null | undefined, options?: {
+        country?: Country | null;
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<AddressZipCode>[];
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: AddressZipCode | null | undefined): boolean;
+    compareTo(other: AddressZipCode | null | undefined): number;
+}
+/** Internal masking for zip codes used in scan results. */
+declare function maskZip(zip: AddressZipCode): string;
+
+/** Common interface for all country-specific zip code types. */
+interface ICountryAddressZipCode {
+    readonly country: Country;
+    readonly value: string;
+    readonly formatted: string;
+    readonly zipCode: AddressZipCode;
+    toNormalizedString(): string;
+    toString(): string;
+}
+/** Common interface for all country-specific address types. */
+interface ICountryAddress {
+    readonly country: Country;
+    readonly street: AddressStreet;
+    readonly countryZipCode: ICountryAddressZipCode;
+    readonly city: AddressCity;
+    readonly address: Address;
+    readonly careOf: string | null;
+    readonly postBox: string | null;
+    readonly isPostBox: boolean;
+    readonly value: string;
+    readonly formatted: string;
+    toNormalizedString(): string;
+    toMultilineString(): string;
+    toString(): string;
+}
+/** Abstract base class for country-specific zip code types. */
+declare abstract class CountryAddressZipCodeBase implements ICountryAddressZipCode {
+    readonly value: string;
+    readonly formatted: string;
+    readonly zipCode: AddressZipCode;
+    abstract get country(): Country;
+    protected constructor(value: string, formatted: string, zipCode: AddressZipCode);
+    toNormalizedString(): string;
+    toString(): string;
+}
+/** Abstract base class for country-specific address types. */
+declare abstract class CountryAddressBase implements ICountryAddress {
+    readonly street: AddressStreet;
+    readonly city: AddressCity;
+    readonly address: Address;
+    abstract get countryZipCode(): ICountryAddressZipCode;
+    get country(): Country;
+    get careOf(): string | null;
+    get postBox(): string | null;
+    get isPostBox(): boolean;
+    get value(): string;
+    get formatted(): string;
+    protected constructor(street: AddressStreet, city: AddressCity, address: Address);
+    toNormalizedString(): string;
+    toString(): string;
+    toMultilineString(): string;
+}
+/**
+ * Validates and unwraps a generic {@link Address} for a specific country, then constructs
+ * a typed country-specific address. Used by every `XxxAddress.tryParse` implementation.
+ */
+declare function tryWrapCountryAddress<TZip, TAddr>(address: Address, alpha2: string, defaultCountry: Country, tryParseZip: (value: string) => TZip | null, factory: (street: AddressStreet, zip: TZip, city: AddressCity, address: Address) => TAddr): TAddr | null;
+
+/** A complete address combining street, zip, city and country. */
+declare class Address {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly street: AddressStreet;
+    readonly zipCode: AddressZipCode | null;
+    readonly city: AddressCity | null;
+    readonly country: Country | null;
+    constructor(street: AddressStreet, zipCode?: AddressZipCode | null, city?: AddressCity | null, country?: Country | null);
+    get careOf(): string | null;
+    get apartmentNumber(): string | null;
+    get postBox(): string | null;
+    get isPostBox(): boolean;
+    get value(): string;
+    get formatted(): string;
+    static tryParse(input: string | null | undefined): Address | null;
+    static tryParse(parts: {
+        street: string | null | undefined;
+        zipCode?: string | null;
+        city?: string | null;
+        country?: string | null;
+    }): Address | null;
+    static parse(input: string): Address;
+    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;
+    /**
+     * Scans unstructured text for potential Swedish-style addresses.
+     *
+     * Results are heuristic candidates and can include false positives. Zip-code
+     * anchored matches receive medium confidence, while street-only matches
+     * receive low confidence.
+     */
+    static findCandidatesInText(text: string): readonly TextCandidate<Address>[];
+    toNormalizedString(): string;
+    toMultilineString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toNativeString(): string;
+    toString(): string;
+    toDomesticString(): string;
+    /**
+     * Multi-line form without the country line, using the country's own zip-code
+     * formatting when a country-specific address type is registered.
+     */
+    toDomesticMultilineString(): string;
+    /**
+     * Wraps this address in its country-specific type when the country is known
+     * and an implementation is registered, otherwise `null`.
+     */
+    asCountryAddress(): ICountryAddress | null;
+    /** Countries that have a dedicated country-specific address type. */
+    static get supportedCountryAddressTypes(): readonly Country[];
+    private buildStreetLine;
+    private buildStreetCoreLine;
+    private buildLocalityLine;
+    private buildDomesticLocalityLine;
+    private countryFormattedZip;
+    private buildSingleLine;
+}
+
+/** A Swedish postal code (`postnummer`) — strictly 5 digits, formatted `NNN NN`. */
+declare class SwedishAddressZipCode {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly formatted: string;
+    readonly zipCode: AddressZipCode;
+    get country(): Country;
+    private constructor();
+    static tryParse(input: string | null | undefined): SwedishAddressZipCode | null;
+    static parse(input: string): SwedishAddressZipCode;
+    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;
+    toNormalizedString(): string;
+    toString(): string;
+}
+
+/** A Swedish address — street + 5-digit zip + city, all within Sweden. */
+declare class SwedishAddress {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly street: AddressStreet;
+    readonly zipCode: SwedishAddressZipCode;
+    readonly city: AddressCity;
+    readonly address: Address;
+    get country(): Country;
+    /** The zip code as the country-agnostic {@link ICountryAddressZipCode} view. */
+    get countryZipCode(): ICountryAddressZipCode;
+    get careOf(): string | null;
+    get postBox(): string | null;
+    get isPostBox(): boolean;
+    get apartmentNumber(): string | null;
+    get value(): string;
+    get formatted(): string;
+    private constructor();
+    static tryParse(input: string | null | undefined): SwedishAddress | null;
+    static tryParse(parts: {
+        street: string | null | undefined;
+        zipCode?: string | null;
+        city?: string | null;
+        country?: string | null;
+    }): SwedishAddress | null;
+    static parse(input: string): SwedishAddress;
+    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;
+    /**
+     * Scans unstructured text for potential Swedish addresses.
+     *
+     * Results are heuristic candidates and can include false positives. Only
+     * address candidates with a Swedish zip code and city are returned.
+     */
+    static findCandidatesInText(text: string): readonly TextCandidate<SwedishAddress>[];
+    toNormalizedString(): string;
+    toString(): string;
+    toMultilineString(): string;
+    private buildStreetCoreLine;
+    /** Wraps an already-parsed {@link Address}. Used by the country-address registry. */
+    static tryWrap(address: Address): SwedishAddress | null;
+}
+
+export { Address as A, CountryAddressBase as C, type ICountryAddress as I, SwedishAddress as S, AddressCity as a, AddressStreet as b, AddressZipCode as c, CountryAddressZipCodeBase as d, type ICountryAddressZipCode as e, SwedishAddressZipCode as f, maskZip as m, tryWrapCountryAddress as t };

package/dist/swedish-bank-account-holder-name-BFJ8h1aO.d.cts

@@ -0,0 +1,45 @@
+import { P as PrimitiveTypeInfo } from './text-candidate-qg2bD9PY.cjs';
+import { a as PersonFullName } from './person-full-name-Cmc9Ynuc.cjs';
+import { S as SwedishOrganizationName } from './swedish-organization-name-D7NvERxA.cjs';
+
+/** The type of bank account holder. */
+declare const BankAccountHolderType: {
+    readonly Unknown: "Unknown";
+    readonly Person: "Person";
+    readonly Organization: "Organization";
+};
+type BankAccountHolderType = (typeof BankAccountHolderType)[keyof typeof BankAccountHolderType];
+/**
+ * A Swedish bank account holder name (`kontoinnehavare`).
+ * Detects whether the holder is a person or an organization based on
+ * `SwedishOrganizationName.hasOrganizationIndicators`.
+ */
+declare class SwedishBankAccountHolderName {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly holderType: BankAccountHolderType;
+    readonly personName: PersonFullName | null;
+    readonly organizationName: SwedishOrganizationName | null;
+    private constructor();
+    static tryParse(input: string | null | undefined): SwedishBankAccountHolderName | null;
+    static parse(input: string): SwedishBankAccountHolderName;
+    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;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: SwedishBankAccountHolderName | null | undefined): boolean;
+    compareTo(other: SwedishBankAccountHolderName | null | undefined): number;
+}
+/**
+ * Returns a masked account holder name where each word's first character is preserved
+ * and the rest is masked, e.g. `Anna Andersson` → `A*** A********`.
+ */
+declare function maskSwedishBankAccountHolderName(holder: SwedishBankAccountHolderName): string;
+
+export { BankAccountHolderType as B, SwedishBankAccountHolderName as S, maskSwedishBankAccountHolderName as m };

package/dist/swedish-bank-account-holder-name-CAAru07F.d.ts

@@ -0,0 +1,45 @@
+import { P as PrimitiveTypeInfo } from './text-candidate-qg2bD9PY.js';
+import { a as PersonFullName } from './person-full-name-D6Hbsab6.js';
+import { S as SwedishOrganizationName } from './swedish-organization-name-rR0Q836C.js';
+
+/** The type of bank account holder. */
+declare const BankAccountHolderType: {
+    readonly Unknown: "Unknown";
+    readonly Person: "Person";
+    readonly Organization: "Organization";
+};
+type BankAccountHolderType = (typeof BankAccountHolderType)[keyof typeof BankAccountHolderType];
+/**
+ * A Swedish bank account holder name (`kontoinnehavare`).
+ * Detects whether the holder is a person or an organization based on
+ * `SwedishOrganizationName.hasOrganizationIndicators`.
+ */
+declare class SwedishBankAccountHolderName {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly holderType: BankAccountHolderType;
+    readonly personName: PersonFullName | null;
+    readonly organizationName: SwedishOrganizationName | null;
+    private constructor();
+    static tryParse(input: string | null | undefined): SwedishBankAccountHolderName | null;
+    static parse(input: string): SwedishBankAccountHolderName;
+    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;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: SwedishBankAccountHolderName | null | undefined): boolean;
+    compareTo(other: SwedishBankAccountHolderName | null | undefined): number;
+}
+/**
+ * Returns a masked account holder name where each word's first character is preserved
+ * and the rest is masked, e.g. `Anna Andersson` → `A*** A********`.
+ */
+declare function maskSwedishBankAccountHolderName(holder: SwedishBankAccountHolderName): string;
+
+export { BankAccountHolderType as B, SwedishBankAccountHolderName as S, maskSwedishBankAccountHolderName as m };