@fgv/ts-bcp47 0.9.6 → 2.0.2-alpha.0

package/dist/ts-bcp47.d.ts

@@ -0,0 +1,2554 @@
+import { Brand } from '@fgv/ts-utils';
+import { Conversion } from '@fgv/ts-utils';
+import { Converter } from '@fgv/ts-utils';
+import { RecordJar } from '@fgv/ts-utils';
+import { Result } from '@fgv/ts-utils';
+import { Validation } from '@fgv/ts-utils';
+
+/**
+ * @internal
+ */
+declare const allRegistryEntryScopes: RegistryEntryScope[];
+
+/**
+ * @internal
+ */
+declare const allRegistryEntryTypes: RegistryEntryType[];
+
+/**
+ * @public
+ */
+declare class Areas {
+    /**
+     * @internal
+     */
+    protected _m49: Map<Iana.Model.UnM49RegionCode, ICountryOrArea>;
+    /**
+     * @internal
+     */
+    protected _isoAlpha2: Map<Iana.Model.IsoAlpha2RegionCode, ICountryOrArea>;
+    /**
+     * @internal
+     */
+    protected _isoAlpha3: Map<Iana.Model.IsoAlpha3RegionCode, ICountryOrArea>;
+    addArea(area: ICountryOrArea): Result<ICountryOrArea>;
+    tryGetArea(from: Iana.Model.UnM49RegionCode): ICountryOrArea | undefined;
+    tryGetAlpha2Area(from: Iana.Model.IsoAlpha2RegionCode): ICountryOrArea | undefined;
+    tryGetAlpha3Area(from: Iana.Model.IsoAlpha3RegionCode): ICountryOrArea | undefined;
+    getArea(from: Iana.Model.UnM49RegionCode): Result<ICountryOrArea>;
+    getAlpha2Area(from: Iana.Model.IsoAlpha2RegionCode): Result<ICountryOrArea>;
+    getAlpha3Area(from: Iana.Model.IsoAlpha3RegionCode): Result<ICountryOrArea>;
+    getAll(): ICountryOrArea[];
+}
+
+declare namespace Bcp47 {
+    export {
+        ExtensionSingleton,
+        ExtensionSubtag,
+        IExtensionSubtagValue,
+        ISubtags,
+        subtagsToString,
+        ILanguageTagInitOptions,
+        LanguageTag,
+        ILanguageChooserOptions,
+        LanguageSimilarityMatcher,
+        TagSimilarity,
+        tagSimilarity,
+        NormalizeTag,
+        TagNormalization,
+        TagValidity,
+        ValidateTag,
+        Overrides,
+        Subtags,
+        tag,
+        tags,
+        similarity,
+        choose,
+        LanguageSpec
+    }
+}
+export { Bcp47 }
+
+/**
+ * Matches a list of desired {@link Bcp47.LanguageSpec | languages} to a list of available {@link Bcp47.LanguageSpec | languages},
+ * return a list of matching languages ordered from best to worst.
+ * @param desired - An array of {@link Bcp47.LanguageSpec | language specifications} containing an ordered list of preferred languages.
+ * @param available - An array of {@link Bcp47.LanguageSpec | language specifications} containing an unordered list of available languages.
+ * @param options - (optional) Parameters to control language tag conversion or comparison
+ * @returns `Success` with an ordered list of matching {@link Bcp47.LanguageTag | languages}, or `Failure` with details if
+ * an error occurs.
+ * @public
+ */
+declare function choose(desired: LanguageSpec[], available: LanguageSpec[], options?: ILanguageTagInitOptions & ILanguageChooserOptions): Result<LanguageTag[]>;
+
+declare namespace Converters {
+    export {
+        Jar,
+        datedRegistry,
+        yearMonthDaySpec,
+        isoAlpha2RegionCode,
+        isoAlpha3RegionCode,
+        unM49RegionCode
+    }
+}
+
+declare namespace Converters_2 {
+    export {
+        LanguageSubtags,
+        datedRegistryFromJarRecords,
+        fileDateEntry
+    }
+}
+
+declare namespace Converters_3 {
+    export {
+        Registry,
+        LanguageSubtags as Tags
+    }
+}
+
+declare namespace Converters_4 {
+    export {
+        loadLanguageSubtagsJsonFileSync,
+        LanguageSubtags as Tags,
+        extendedLanguageRange_3 as extendedLanguageRange,
+        registeredLanguage,
+        registeredExtLang,
+        registeredScript,
+        registeredRegion,
+        registeredVariant,
+        registeredGrandfatheredTag,
+        registeredRedundantTag,
+        registeredItem,
+        registryFile
+    }
+}
+
+declare namespace Converters_5 {
+    export {
+        loadLanguageTagExtensionsJsonFileSync,
+        extensionSingleton,
+        languageTagExtension,
+        languageTagExtensions
+    }
+}
+
+declare namespace Converters_6 {
+    export {
+        loadM49csvFileSync,
+        regionTier,
+        m49CsvRow,
+        m49CsvFile
+    }
+}
+
+declare namespace Converters_7 {
+    export {
+        extensionSubtag,
+        privateUsePrefix
+    }
+}
+
+declare namespace Csv {
+    export {
+        Converters_6 as Converters,
+        Model_6 as Model
+    }
+}
+
+/**
+ * Helper function which creates a converter that returns a validated {@Link Iana.Model.DatedRegistry | DatedRegistry}
+ * containing entries of supplied template type `T`.
+ * @param entryConverter - A `Converter<T>` to validate each entry
+ * @returns A new validating `Converter` which yields {@Link Iana.Model.DatedRegistry | DatedRegistry<T>}
+ * @public
+ */
+declare function datedRegistry<T, TC = unknown>(entryConverter: Converter<T, TC>): Converter<IDatedRegistry<T>, TC>;
+
+/**
+ * Helper function which creates a converter that returns a validated {@Link Iana.Model.DatedRegistry | DatedRegistry}
+ * containing entries of supplied template type `T`.
+ * @param entryConverter - A `Converter<T>` to validate each entry
+ * @returns A new validating `Converter` which yields {@Link Iana.Model.DatedRegistry | DatedRegistry<T>}
+ * @internal
+ */
+declare function datedRegistryFromJarRecords<T, TC = unknown>(entryConverter: Converter<T, TC>): Converter<IDatedRegistry<T>, TC>;
+
+/**
+ * @public
+ */
+declare class DefaultRegistries {
+    /**
+     * @internal
+     */
+    protected static _languageRegistries?: LanguageRegistries;
+    static get languageRegistries(): LanguageRegistries;
+}
+
+/**
+ * @public
+ */
+declare class DefaultRegistries_2 {
+    /**
+     * @internal
+     */
+    protected static _regionCodes?: RegionCodes;
+    static get regionCodes(): RegionCodes;
+}
+
+/**
+ * @public
+ */
+declare class DefaultRegistries_3 {
+    /**
+     * @internal
+     */
+    private static _overridesRegistry?;
+    static get overridesRegistry(): OverridesRegistry;
+}
+
+/**
+ * @internal
+ */
+declare function endOfTagRangeOrUndefined<TTAG extends string>(tagConverter: Converter<TTAG>): Converter<TTAG | undefined>;
+
+/**
+ * An extended language subtag as used in the IANA language registry.
+ * @public
+ */
+declare type ExtendedLanguageRange = Brand<string, 'ExtendedLanguageRange'>;
+
+/**
+ * @public
+ */
+declare const extendedLanguageRange: Conversion.Converter<ExtendedLanguageRange, unknown>;
+
+/**
+ * @public
+ */
+declare const extendedLanguageRange_2: TagValidationHelpers<ExtendedLanguageRange, unknown>;
+
+/**
+ * @public
+ */
+declare const extendedLanguageRange_3: Converter<ExtendedLanguageRange, unknown>;
+
+/**
+ * @public
+ */
+declare type ExtensionSingleton = Iana.LanguageTagExtensions.Model.ExtensionSingleton;
+
+/**
+ * @public
+ */
+declare const extensionSingleton: Converter<Model_2.ExtensionSingleton, unknown>;
+
+/**
+ * @public
+ */
+declare type ExtensionSingleton_2 = Brand<string, 'ExtensionSingleton'>;
+
+/**
+ * @public
+ */
+declare const extensionSingleton_2: RegExpValidationHelpers<Model_2.ExtensionSingleton>;
+
+/**
+ * @public
+ */
+declare const extensionSingleton_3: RegExpValidationHelpers<Iana.LanguageTagExtensions.Model.ExtensionSingleton, unknown>;
+
+/**
+ * @public
+ */
+declare type ExtensionSubtag = Brand<string, 'ExtensionSubtag'>;
+
+/**
+ * @internal
+ */
+declare const extensionSubtag: Converter<ExtensionSubtag, unknown>;
+
+/**
+ * @public
+ */
+declare const extensionSubtag_2: RegExpValidationHelpers<Model_8.ExtensionSubtag, unknown>;
+
+/**
+ * @internal
+ */
+declare const extlangPrefix: Conversion.Converter<LanguageSubtag, unknown>;
+
+/**
+ * Extlang subtag in the IANA language subtag registry.
+ * @public
+ */
+declare type ExtLangSubtag = Brand<string, 'ExtLangSubtag'>;
+
+/**
+ * @public
+ */
+declare const extlangSubtag: Conversion.Converter<ExtLangSubtag, unknown>;
+
+/**
+ * @public
+ */
+declare const extlangSubtag_2: RegExpValidationHelpers<ExtLangSubtag, unknown>;
+
+/**
+ * @internal
+ */
+declare type ExtLangSubtagRegistryEntry = IRegistrySubtagEntry<'extlang', ExtLangSubtag>;
+
+/**
+ * @public
+ */
+declare class ExtLangSubtagScope extends SubtagScope<'extlang', ExtLangSubtag, Items.IRegisteredExtLang> {
+    constructor();
+}
+
+/**
+ * Converter for the file date record found at the start of a registry file.
+ * @public
+ */
+declare const fileDateEntry: Conversion.ObjectConverter<IFileDateEntry, unknown>;
+
+/**
+ * Legacy language tag registered as grandfathered in the IANA language subtag registry.
+ * @public
+ */
+declare type GrandfatheredTag = Brand<string, 'GrandfatheredTag'>;
+
+/**
+ * @public
+ */
+declare const grandfatheredTag: Conversion.Converter<GrandfatheredTag, unknown>;
+
+/**
+ * @public
+ */
+declare const grandfatheredTag_2: TagValidationHelpers<GrandfatheredTag, unknown>;
+
+/**
+ * @internal
+ */
+declare type GrandfatheredTagRegistryEntry = IRegistryTagEntry<'grandfathered', GrandfatheredTag>;
+
+/**
+ * @public
+ */
+declare class GrandfatheredTagScope extends TagScope<'grandfathered', GrandfatheredTag, Items.IRegisteredGrandfatheredTag> {
+    constructor();
+}
+
+declare namespace Helpers {
+    export {
+        TagValidationHelpers
+    }
+}
+
+declare namespace Iana {
+    export {
+        DefaultRegistries,
+        Converters,
+        Jar_2 as Jar,
+        Model_4 as Model,
+        LanguageSubtags_4 as LanguageSubtags,
+        LanguageTagExtensions_2 as LanguageTagExtensions,
+        Validate_3 as Validate,
+        nowAsYearMonthDay,
+        LanguageRegistries
+    }
+}
+export { Iana }
+
+/**
+ * @public
+ */
+declare interface ICountryOrArea {
+    name: string;
+    code: Iana.Model.UnM49RegionCode;
+    tier: 'area';
+    parent: Region;
+    isoAlpha2?: Iana.Model.IsoAlpha2RegionCode;
+    isoAlpha3?: Iana.Model.IsoAlpha3RegionCode;
+    leastDevelopedCountry: boolean;
+    landlockedDevelopingCountry: boolean;
+    smallIslandDevelopingState: boolean;
+}
+
+/**
+ * A dated collection of registry entries of a specified templated type.
+ * @public
+ */
+declare interface IDatedRegistry<T> {
+    fileDate: YearMonthDaySpec_2;
+    entries: T[];
+}
+
+/**
+ * @public
+ */
+declare interface IExtensionSubtagValue {
+    readonly singleton: ExtensionSingleton;
+    readonly value: ExtensionSubtag;
+}
+
+/**
+ * File date record entry typically placed at the head of a registry
+ * file.
+ * @internal
+ */
+declare interface IFileDateEntry extends RecordJar.JarRecord {
+    'File-Date': YearMonthDaySpec_2;
+}
+
+/**
+ * @public
+ */
+declare interface IGlobalRegion {
+    name: string;
+    code: Iana.Model.UnM49RegionCode;
+    tier: 'global';
+    regions: IIntermediateRegion[];
+    areas: ICountryOrArea[];
+}
+
+/**
+ * @public
+ */
+declare interface IIntermediateRegion {
+    name: string;
+    code: Iana.Model.UnM49RegionCode;
+    tier: RegionTier;
+    parent: Region;
+    regions: IIntermediateRegion[];
+    areas: ICountryOrArea[];
+}
+
+/**
+ * Options for {@link Bcp47.choose | language tag list filter} functions.
+ * @public
+ */
+declare interface ILanguageChooserOptions {
+    /**
+     * Indicates whether to return the matching language from the
+     * desired list or the available list. Default is `'availableLanguage'`.
+     */
+    use?: 'desiredLanguage' | 'availableLanguage';
+    /**
+     * Indicates how to filter the language list - `'primaryLanguage'`
+     * indicates the each primary language should appear only once in
+     * the list in its most similar form.  A filter value of `'none'`
+     * reports all matching variants of any primary language in order
+     * of similarity.  Default is `'primaryLanguage'`
+     */
+    filter?: 'primaryLanguage' | 'none';
+    /**
+     * An optional {@link Bcp47.LanguageSpec | language specification}
+     * indicating a language to be returned if the filter call would
+     * otherwise return an empty list (i.e. no languages match).
+     */
+    ultimateFallback?: string | ISubtags | LanguageTag;
+}
+
+/**
+ * @public
+ */
+declare interface ILanguageOverride {
+    language: Iana.LanguageSubtags.LanguageSubtag;
+    preferredRegion?: Iana.LanguageSubtags.RegionSubtag;
+    defaultAffinity?: string;
+    affinity?: Map<Iana.LanguageSubtags.RegionSubtag, string>;
+}
+
+/**
+ * @internal
+ */
+declare interface ILanguageOverrideRecord {
+    language: Iana.LanguageSubtags.LanguageSubtag;
+    preferredRegion?: Iana.LanguageSubtags.RegionSubtag;
+    defaultAffinity?: string;
+    affinity?: Record<string, Iana.LanguageSubtags.RegionSubtag[]>;
+}
+
+/**
+ * @internal
+ */
+declare interface ILanguageTagExtension {
+    identifier: ExtensionSingleton_2;
+    description: string[];
+    comments: string[];
+    added: YearMonthDaySpec_2;
+    rfc: string;
+    authority: string;
+    contactEmail: string;
+    mailingList: string;
+    url: string;
+}
+
+/**
+ * Initialization options for parsing or creation of {@link Bcp47.LanguageTag | language tag} objects.
+ * @public
+ */
+declare interface ILanguageTagInitOptions {
+    /**
+     * Desired {@link Bcp47.TagValidity | validity level} (optional).
+     */
+    validity?: TagValidity;
+    /**
+     * Desired {@link Bcp47.TagNormalization | normalization level} (optional).
+     */
+    normalization?: TagNormalization;
+    /**
+     * The {@link Iana.LanguageRegistries | IANA language subtag and extension registries} to
+     * be used for the request (optional).
+     */
+    iana?: Iana.LanguageRegistries;
+}
+
+/**
+ * @internal
+ */
+declare interface IM49CsvRow {
+    globalCode: Iana.Model.UnM49RegionCode;
+    globalName: string;
+    regionCode?: Iana.Model.UnM49RegionCode;
+    regionName?: string;
+    subRegionCode?: Iana.Model.UnM49RegionCode;
+    subRegionName?: string;
+    intermediateRegionCode?: Iana.Model.UnM49RegionCode;
+    intermediateRegionName?: string;
+    countryOrArea: string;
+    m49Code: Iana.Model.UnM49RegionCode;
+    isoAlpha2RegionCode?: Iana.Model.IsoAlpha2RegionCode;
+    isoAlpha3RegionCode?: Iana.Model.IsoAlpha3RegionCode;
+    leastDevelopedCountry: boolean;
+    landLockedDevelopingCountry: boolean;
+    smallIslandDevelopingState: boolean;
+}
+
+/**
+ * @public
+ */
+declare type IntermediateRegionTier = 'region' | 'subRegion' | 'intermediateRegion';
+
+/**
+ * @internal
+ */
+declare interface IRegExpValidationHelperConstructorParams<T extends string, TC = unknown> {
+    description: string;
+    wellFormed: RegExp;
+    canonical: RegExp;
+    toCanonical?: Normalizer<T, TC>;
+}
+
+/**
+ * Represents a single extension subtag with corresponding registry data,
+ * if present.
+ * @public
+ */
+declare interface IRegisteredExtensionValue extends IExtensionSubtagValue {
+    /**
+     * The language extensions registry entry for the associated subtag,
+     * or `undefined` if the extension is not registered.
+     */
+    registry?: Iana.LanguageTagExtensions.Model.ILanguageTagExtension;
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredExtLang extends IRegisteredSubtag<'extlang', ExtLangSubtag> {
+    readonly type: 'extlang';
+    readonly subtag: ExtLangSubtag;
+    readonly preferredValue: ExtendedLanguageRange;
+    readonly prefix: LanguageSubtag;
+    readonly description: string[];
+    readonly added: Model.YearMonthDaySpec;
+    readonly comments?: string[];
+    readonly deprecated?: Model.YearMonthDaySpec;
+    readonly macrolanguage?: LanguageSubtag;
+    readonly scope?: Model.RegistryEntryScope;
+    readonly suppressScript?: ScriptSubtag;
+}
+
+/**
+ * Represents a single extlang subtag with corresponding registry data,
+ * if present.
+ * @public
+ */
+declare interface IRegisteredExtLangValue {
+    /**
+     * A {@link Iana.LanguageSubtags.ExtLangSubtag | extlang subtag} from
+     * the original language tag.
+     */
+    subtag: Iana.LanguageSubtags.ExtLangSubtag;
+    /**
+     * The {@link Iana.LanguageSubtag.Model.RegisteredExtLang | IANA subtag registry entry}
+     * for this subtag, or `undefined` if the subtag is not registered.
+     */
+    registry?: Iana.LanguageSubtags.Model.IRegisteredExtLang;
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredGrandfatheredTag extends IRegisteredTag<'grandfathered', GrandfatheredTag> {
+    readonly type: 'grandfathered';
+    readonly tag: GrandfatheredTag;
+    readonly description: string[];
+    readonly added: Model.YearMonthDaySpec;
+    readonly comments?: string[];
+    readonly deprecated?: Model.YearMonthDaySpec;
+    readonly preferredValue?: ExtendedLanguageRange;
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredLanguage extends IRegisteredSubtagWithRange<'language', LanguageSubtag> {
+    readonly type: 'language';
+    readonly subtag: LanguageSubtag;
+    readonly description: string[];
+    readonly added: Model.YearMonthDaySpec;
+    readonly comments?: string[];
+    readonly deprecated?: Model.YearMonthDaySpec;
+    readonly macrolanguage?: LanguageSubtag;
+    readonly preferredValue?: LanguageSubtag;
+    readonly scope?: Model.RegistryEntryScope;
+    readonly suppressScript?: ScriptSubtag;
+    readonly subtagRangeEnd?: LanguageSubtag;
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredRedundantTag extends IRegisteredTag<'redundant', RedundantTag> {
+    readonly type: 'redundant';
+    readonly tag: RedundantTag;
+    readonly description: string[];
+    readonly added: Model.YearMonthDaySpec;
+    readonly comments?: string[];
+    readonly deprecated?: Model.YearMonthDaySpec;
+    readonly preferredValue?: ExtendedLanguageRange;
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredRegion extends IRegisteredSubtagWithRange<'region', RegionSubtag> {
+    readonly type: 'region';
+    readonly subtag: RegionSubtag;
+    readonly description: string[];
+    readonly added: Model.YearMonthDaySpec;
+    readonly comments?: string[];
+    readonly deprecated?: Model.YearMonthDaySpec;
+    readonly preferredValue?: RegionSubtag;
+    readonly subtagRangeEnd?: RegionSubtag;
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredScript extends IRegisteredSubtagWithRange<'script', ScriptSubtag> {
+    readonly type: 'script';
+    readonly subtag: ScriptSubtag;
+    readonly description: string[];
+    readonly added: Model.YearMonthDaySpec;
+    readonly comments?: string[];
+    readonly deprecated?: Model.YearMonthDaySpec;
+    readonly preferredValue?: ScriptSubtag;
+    readonly subtagRangeEnd?: ScriptSubtag;
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredSubtag<TTYPE extends Model.RegistryEntryType, TTAG extends string> {
+    readonly type: TTYPE;
+    readonly subtag: TTAG;
+    readonly description: string[];
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredSubtagWithRange<TTYPE extends Model.RegistryEntryType, TTAG extends string> extends IRegisteredSubtag<TTYPE, TTAG> {
+    readonly type: TTYPE;
+    readonly subtag: TTAG;
+    readonly description: string[];
+    readonly subtagRangeEnd?: TTAG;
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredTag<TTYPE extends Model.RegistryEntryType, TTAG extends string> {
+    readonly type: TTYPE;
+    readonly tag: TTAG;
+    readonly description: string[];
+}
+
+/**
+ * @public
+ */
+declare interface IRegisteredVariant extends IRegisteredSubtag<'variant', VariantSubtag> {
+    readonly type: 'variant';
+    readonly subtag: VariantSubtag;
+    readonly description: string[];
+    readonly added: Model.YearMonthDaySpec;
+    readonly comments?: string[];
+    readonly deprecated?: Model.YearMonthDaySpec;
+    readonly preferredValue?: VariantSubtag;
+    readonly prefix?: ExtendedLanguageRange[];
+}
+
+/**
+ * Represents a single variant subtag with corresponding registry data,
+ * if present.
+ * @public
+ */
+declare interface IRegisteredVariantValue {
+    /**
+     * A {@link Iana.LanguageSubtags.VariantSubtag | variant subtag} from
+     * the original language tag.
+     */
+    subtag: Iana.LanguageSubtags.VariantSubtag;
+    /**
+     * The {@link Iana.LanguageSubtag.Model.RegisteredVariant | IANA subtag registry entry}
+     * for this subtag, or `undefined` if the subtag is not registered.
+     */
+    registry?: Iana.LanguageSubtags.Model.IRegisteredVariant;
+}
+
+/**
+ * @internal
+ */
+declare interface IRegistryEntryBase<TTYPE extends RegistryEntryType = RegistryEntryType> {
+    Type: TTYPE;
+    Description: string[];
+    Added: YearMonthDaySpec;
+    Deprecated?: YearMonthDaySpec;
+    'Suppress-Script'?: ScriptSubtag;
+    Macrolanguage?: LanguageSubtag;
+    'Preferred-Value'?: string;
+    Prefix?: string[];
+    Scope?: RegistryEntryScope;
+    Comments?: string[];
+}
+
+/**
+ * @internal
+ */
+declare interface IRegistrySubtagEntry<TTYPE extends RegistryEntryType = RegistryEntryType, TSUBTAG extends string = string> extends IRegistryEntryBase<TTYPE> {
+    Subtag: TSUBTAG | TSUBTAG[];
+}
+
+/**
+ * @internal
+ */
+declare interface IRegistryTagEntry<TTYPE extends RegistryEntryType = RegistryEntryType, TTAG extends string = string> extends IRegistryEntryBase<TTYPE> {
+    Tag: TTAG | TTAG[];
+}
+
+/**
+ * Represents an ISO 3166 Alpha-2 region code.
+ * @public
+ */
+declare type IsoAlpha2RegionCode = Brand<string, 'IsoAlpha2RegionCode'>;
+
+/**
+ * Validating converter from string {@link Iana.Model.IsoAlpha2RegionCode}.
+ * @public
+ */
+declare const isoAlpha2RegionCode: Converter<IsoAlpha2RegionCode, unknown>;
+
+/**
+ * @public
+ */
+declare const isoAlpha2RegionCode_2: RegExpValidationHelpers<Model_5.IsoAlpha2RegionCode, unknown>;
+
+/**
+ * Represents an ISO 3166 Alpha-3 region code.
+ * @public
+ */
+declare type IsoAlpha3RegionCode = Brand<string, 'IsoAlpha3RegionCode'>;
+
+/**
+ * Validating converter from string {@link Iana.Model.IsoAlpha3RegionCode}.
+ * @public
+ */
+declare const isoAlpha3RegionCode: Converter<IsoAlpha3RegionCode, unknown>;
+
+/**
+ * @public
+ */
+declare const isoAlpha3RegionCode_2: RegExpValidationHelpers<Model_5.IsoAlpha3RegionCode, unknown>;
+
+/**
+ * @public
+ */
+declare interface ISubtags {
+    primaryLanguage?: Iana.LanguageSubtags.LanguageSubtag;
+    extlangs?: Iana.LanguageSubtags.ExtLangSubtag[];
+    script?: Iana.LanguageSubtags.ScriptSubtag;
+    region?: Iana.LanguageSubtags.RegionSubtag;
+    variants?: Iana.LanguageSubtags.VariantSubtag[];
+    extensions?: IExtensionSubtagValue[];
+    privateUse?: Iana.LanguageSubtags.ExtendedLanguageRange[];
+    grandfathered?: Iana.LanguageSubtags.GrandfatheredTag;
+}
+
+/**
+ * @public
+ */
+declare interface ITagNormalizer {
+    readonly normalization: TagNormalization;
+    processSubtags(subtags: ISubtags): Result<ISubtags>;
+}
+
+/**
+ * @public
+ */
+declare interface ITagValidator {
+    readonly validity: TagValidity;
+    validateSubtags(subtags: ISubtags): Result<true>;
+}
+
+declare namespace Items {
+    export {
+        IRegisteredSubtag,
+        IRegisteredSubtagWithRange,
+        IRegisteredTag,
+        RegisteredTagOrSubtag,
+        IRegisteredLanguage,
+        IRegisteredExtLang,
+        IRegisteredScript,
+        IRegisteredRegion,
+        IRegisteredVariant,
+        IRegisteredGrandfatheredTag,
+        IRegisteredRedundantTag,
+        RegisteredSubtagItem,
+        RegisteredTagItem,
+        RegisteredItem,
+        RegistryFile_2 as RegistryFile
+    }
+}
+
+/**
+ * Initializer for {@link Utils.ValidationHelpers | validation helpers}.
+ * @public
+ */
+declare interface IValidationHelpersConstructorParams<T extends string, TC = unknown> {
+    description: string;
+    isWellFormed: Validation.TypeGuardWithContext<T, TC>;
+    isCanonical: Validation.TypeGuardWithContext<T, TC>;
+    toCanonical?: Normalizer<T, TC>;
+}
+
+declare namespace Jar {
+    export {
+        datedRegistryFromJarRecords,
+        fileDateEntry
+    }
+}
+
+declare namespace Jar_2 {
+    export {
+        Converters_2 as Converters,
+        LanguageSubtags_2 as LanguageSubtags,
+        Model_3 as Model
+    }
+}
+
+declare namespace Jar_3 {
+    export {
+        IFileDateEntry
+    }
+}
+
+declare namespace JarConverters {
+    export {
+        loadJsonSubtagRegistryFileSync,
+        loadTxtSubtagRegistryFileSync,
+        registeredLanguage_2 as registeredLanguage,
+        registeredExtLang_2 as registeredExtLang,
+        registeredScript_2 as registeredScript,
+        registeredRegion_2 as registeredRegion,
+        registeredVariant_2 as registeredVariant,
+        registeredGrandfatheredTag_2 as registeredGrandfatheredTag,
+        registeredRedundantTag_2 as registeredRedundantTag,
+        registeredItem_2 as registeredItem,
+        registryFile_2 as registryFile
+    }
+}
+
+declare namespace JarConverters_2 {
+    export {
+        loadJsonLanguageTagExtensionsRegistryFileSync,
+        loadTxtLanguageTagExtensionsRegistryFileSync,
+        languageTagExtension_2 as languageTagExtension,
+        languageTagExtensions_2 as languageTagExtensions
+    }
+}
+
+/**
+ * @public
+ */
+declare class LanguageRegistries {
+    readonly subtags: LanguageSubtagRegistry;
+    readonly extensions: LanguageTagExtensionRegistry;
+    private constructor();
+    static load(root: string): Result<LanguageRegistries>;
+    static loadDefault(): Result<LanguageRegistries>;
+}
+
+/**
+ * Returns all of the data in the IANA language subtags registry for
+ * a set of supplied {@link Bcp47.Subtags | subtags}.
+ * @public
+ */
+declare class LanguageRegistryData {
+    /**
+     * @internal
+     */
+    protected _iana: Iana.LanguageRegistries;
+    /**
+     * @internal
+     */
+    protected _subtags: ISubtags;
+    /**
+     * @internal
+     */
+    protected _primaryLanguage?: Iana.LanguageSubtags.Model.IRegisteredLanguage | false;
+    /**
+     * @internal
+     */
+    protected _extlangs?: IRegisteredExtLangValue[] | false;
+    /**
+     * @internal
+     */
+    protected _script?: Iana.LanguageSubtags.Model.IRegisteredScript | false;
+    /**
+     * @internal
+     */
+    protected _effectiveScript?: Iana.LanguageSubtags.Model.IRegisteredScript | false;
+    /**
+     * @internal
+     */
+    protected _region?: Iana.LanguageSubtags.Model.IRegisteredRegion | false;
+    /**
+     * @internal
+     */
+    protected _variants?: IRegisteredVariantValue[] | false;
+    /**
+     * @internal
+     */
+    protected _extensions?: IRegisteredExtensionValue[] | false;
+    /**
+     * @internal
+     */
+    protected _grandfathered?: Iana.LanguageSubtags.Model.IRegisteredGrandfatheredTag | false;
+    /**
+     * Constructs a new {@link Bcp47.LanguageTagRegistryData | Bcp47.LanguageTagRegistryData}
+     * from a supplied {@link Bcp47.Subtags | subtags} and {@link Iana.LanguageRegistries | language registries}.
+     * @public
+     */
+    constructor(subtags: ISubtags, iana: Iana.LanguageRegistries);
+    /**
+     * Registry data associated with the primary language subtag of the language tag from
+     * which this {@link Bcp47.LanguageTagRegistryData | Bcp47.LanguageTagRegistryData}
+     * was constructed, or `undefined` if the primary language is missing or invalid.
+     * @public
+     */
+    get primaryLanguage(): Iana.LanguageSubtags.Model.IRegisteredLanguage | undefined;
+    /**
+     * Registry data associated with the extlang subtag of the language tag from
+     * which this {@link Bcp47.LanguageTagRegistryData | Bcp47.LanguageTagRegistryData}
+     * was constructed, or `undefined` if extlang is missing or invalid.
+     * @public
+     */
+    get extlangs(): IRegisteredExtLangValue[] | undefined;
+    /**
+     * Registry data associated with the script of the language tag from
+     * which this {@link Bcp47.LanguageTagRegistryData | Bcp47.LanguageTagRegistryData}
+     * was constructed, or `undefined` if the script cannot be determined.
+     *
+     * @public
+     */
+    get script(): Iana.LanguageSubtags.Model.IRegisteredScript | undefined;
+    /**
+     * Registry data associated with the script of the language tag from
+     * which this {@link Bcp47.LanguageTagRegistryData | Bcp47.LanguageTagRegistryData}
+     * was constructed, or `undefined` if the script cannot be determined.
+     *
+     * Note that effectiveScript will default to the registry `Suppress-Script` value of the
+     * primary language if no script subtag is present.
+     * @public
+     */
+    get effectiveScript(): Iana.LanguageSubtags.Model.IRegisteredScript | undefined;
+    /**
+     * Registry data associated with the region subtag of the language tag from
+     * which this {@link Bcp47.LanguageTagRegistryData | Bcp47.LanguageTagRegistryData}
+     * was constructed, or `undefined` if the region is missing or invalid.
+     * @public
+     */
+    get region(): Iana.LanguageSubtags.Model.IRegisteredRegion | undefined;
+    /**
+     * Registry data associated with the variant subtags of the language tag from
+     * which this {@link Bcp47.LanguageTagRegistryData | Bcp47.LanguageTagRegistryData}
+     * was constructed, or `undefined` if variant subtags are missing or invalid.
+     * @public
+     */
+    get variants(): IRegisteredVariantValue[] | undefined;
+    /**
+     * Registry data associated with the extension subtags of the language tag from
+     * which this {@link Bcp47.LanguageTagRegistryData | Bcp47.LanguageTagRegistryData}
+     * was constructed, or `undefined` if extension subtags are missing or invalid.
+     * @public
+     */
+    get extensions(): IRegisteredExtensionValue[] | undefined;
+    /**
+     * Registry data for grandfathered tags, or `undefined` if the tag is not recognized
+     * as a grandfathered tag.
+     * @public
+     */
+    get grandfathered(): Iana.LanguageSubtags.Model.IRegisteredGrandfatheredTag | undefined;
+    /**
+     * @returns A string representation of the subtags from which this
+     * {@link Bcp47.LanguageTagRegistryData | Bcp47.LanguageTagRegistryData}
+     * was created.
+     * @public
+     */
+    toString(): string;
+}
+
+/**
+ * Helper to compare two language tags to determine how closely related they are,
+ * applying normalization and language semantics as appropriate.
+ * @public
+ */
+declare class LanguageSimilarityMatcher {
+    iana: Iana.LanguageRegistries;
+    unsd: Unsd.RegionCodes;
+    overrides: OverridesRegistry;
+    constructor(iana?: Iana.LanguageRegistries);
+    matchLanguageTags(t1: LanguageTag, t2: LanguageTag): number;
+    matchPrimaryLanguage(lt1: LanguageTag, lt2: LanguageTag): number;
+    matchExtlang(lt1: LanguageTag, lt2: LanguageTag): number;
+    matchScript(lt1: LanguageTag, lt2: LanguageTag): number;
+    matchRegion(lt1: LanguageTag, lt2: LanguageTag): number;
+    matchVariants(lt1: LanguageTag, lt2: LanguageTag): number;
+    matchExtensions(lt1: LanguageTag, lt2: LanguageTag): number;
+    matchPrivateUseTags(lt1: LanguageTag, lt2: LanguageTag): number;
+}
+
+/**
+ * Any of the possible ways to represent a language - as a `string`,
+ * parsed {@link Bcp47.Subtags | subtags} or an instantiated
+ * {@link Bcp47.LanguageTag | language tag}.
+ * @public
+ */
+declare type LanguageSpec = string | ISubtags | LanguageTag;
+
+/**
+ * Primary language subtag in the IANA language subtag registry.
+ * @public
+ */
+declare type LanguageSubtag = Brand<string, 'LanguageSubtag'>;
+
+/**
+ * @public
+ */
+declare const languageSubtag: Conversion.Converter<LanguageSubtag, unknown>;
+
+/**
+ * @public
+ */
+declare const languageSubtag_2: RegExpValidationHelpers<LanguageSubtag, unknown>;
+
+/**
+ * @public
+ */
+declare class LanguageSubtagRegistry {
+    readonly fileDate: YearMonthDaySpec;
+    readonly languages: Scope.LanguageSubtagScope;
+    readonly extlangs: Scope.ExtLangSubtagScope;
+    readonly scripts: Scope.ScriptSubtagScope;
+    readonly regions: Scope.RegionSubtagScope;
+    readonly variants: Scope.VariantSubtagScope;
+    readonly collections: Scope.LanguageSubtagScope;
+    readonly macrolanguages: Scope.LanguageSubtagScope;
+    readonly privateUse: Scope.LanguageSubtagScope;
+    readonly special: Scope.LanguageSubtagScope;
+    readonly grandfathered: Scope.GrandfatheredTagScope;
+    readonly redundant: Scope.RedundantTagScope;
+    /**
+     * @internal
+     */
+    protected readonly _all: RegisteredItem[];
+    /**
+     * @param registry - The contents of the registry file
+     * from which the data is loaded.
+     * @internal
+     */
+    protected constructor(registry: RegistryFile_2);
+    static create(registry: RegistryFile_2): Result<LanguageSubtagRegistry>;
+    static createFromJson(from: unknown): Result<LanguageSubtagRegistry>;
+    static loadDefault(): Result<LanguageSubtagRegistry>;
+    static load(root: string): Result<LanguageSubtagRegistry>;
+    static loadJsonRegistryFile(root: string): Result<LanguageSubtagRegistry>;
+    static loadTxtRegistryFile(root: string): Result<LanguageSubtagRegistry>;
+}
+
+/**
+ * @internal
+ */
+declare type LanguageSubtagRegistryEntry = IRegistrySubtagEntry<'language', LanguageSubtag>;
+
+declare namespace LanguageSubtags {
+    export {
+        rangeOfTags,
+        tagOrRange,
+        tagOrStartOfTagRange,
+        endOfTagRangeOrUndefined,
+        languageSubtag,
+        extlangSubtag,
+        scriptSubtag,
+        regionSubtag,
+        variantSubtag,
+        grandfatheredTag,
+        redundantTag,
+        extendedLanguageRange,
+        extlangPrefix
+    }
+}
+
+declare namespace LanguageSubtags_2 {
+    export {
+        Converters_3 as Converters,
+        Tags,
+        Model as Registry
+    }
+}
+
+declare namespace LanguageSubtags_3 {
+    export {
+        Model as Registry,
+        Tags_2 as Tags
+    }
+}
+
+declare namespace LanguageSubtags_4 {
+    export {
+        LanguageSubtagRegistry,
+        Converters_4 as Converters,
+        JarConverters,
+        Items as Model,
+        Validate,
+        ExtLangSubtag,
+        ExtendedLanguageRange,
+        GrandfatheredTag,
+        LanguageSubtag,
+        RedundantTag,
+        RegionSubtag,
+        ScriptSubtag,
+        VariantSubtag,
+        RegistryEntryScope,
+        RegistryEntryType
+    }
+}
+
+/**
+ * @public
+ */
+declare class LanguageSubtagScope extends SubtagScopeWithRange<'language', LanguageSubtag, Items.IRegisteredLanguage> {
+    constructor();
+}
+
+/**
+ * Represents a single BCP-47 language tag.
+ * @public
+ */
+declare class LanguageTag {
+    /**
+     * The individual {@link Bcp47.Subtags | subtags} for
+     * this language tag.
+     */
+    readonly subtags: Readonly<ISubtags>;
+    /**
+     * A string representation of this language tag.
+     */
+    readonly tag: string;
+    /**
+     * Details about this language tag from the IANA language
+     * registries.
+     */
+    readonly registry: LanguageRegistryData;
+    /**
+     * @internal
+     */
+    protected readonly _iana: Iana.LanguageRegistries;
+    /**
+     * @internal
+     */
+    protected _validity: TagValidity;
+    /**
+     * @internal
+     */
+    protected _normalization: TagNormalization;
+    /**
+     * @internal
+     */
+    protected _isValid: undefined | boolean;
+    /**
+     * @internal
+     */
+    protected _isStrictlyValid: undefined | boolean;
+    /**
+     * @internal
+     */
+    protected _isCanonical: undefined | boolean;
+    /**
+     * @internal
+     */
+    protected _isPreferred: undefined | boolean;
+    /**
+     * @internal
+     */
+    protected _suppressedScript: undefined | Iana.LanguageSubtags.ScriptSubtag | false;
+    /**
+     * Constructs a {@link Bcp47.LanguageTag | LanguageTag }.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } from
+     * which the tag is constructed.
+     * @param validity - Known {@link Bcp47.TagValidity | validation level} of the
+     * supplied subtags.
+     * @param normalization - Known {@link Bcp47.TagNormalization | normalization level}
+     * of the supplied subtags.
+     * @param iana - The {@link Iana.LanguageRegistries} used to validate and normalize
+     * this tag.
+     * @internal
+     */
+    protected constructor(subtags: ISubtags, validity: TagValidity, normalization: TagNormalization, iana: Iana.LanguageRegistries);
+    /**
+     * The effective script of this language tag, if known.
+     * The effective script is the script subtag in the tag itself,
+     * if present, or the `Suppress-Script` defined in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | IANA subtag registry}
+     * for the primary language of this tag.  Can be `undefined`
+     * if neither the tag nor the IANA registry define a script.
+     */
+    get effectiveScript(): Iana.LanguageSubtags.ScriptSubtag | undefined;
+    /**
+     * Determines if this tag represents the special `undetermined` language.
+     */
+    get isUndetermined(): boolean;
+    /**
+     * Whether this language tag is valid.
+     */
+    get isValid(): boolean;
+    /**
+     * Whether if this language tag is strictly valid.
+     */
+    get isStrictlyValid(): boolean;
+    /**
+     * Whether this language tag is in canonical form.
+     */
+    get isCanonical(): boolean;
+    /**
+     * Whether this language tag is in preferred form.
+     */
+    get isPreferred(): boolean;
+    /**
+     * Whether this language tag is a grandfathered tag.
+     */
+    get isGrandfathered(): boolean;
+    /**
+     * Gets a text description of this tag.
+     */
+    get description(): string;
+    /**
+     * Creates a new {@link Bcp47.LanguageTag | language tag} from a supplied `string` tag
+     * using optional configuration, if supplied.
+     * @param tag - The `string` tag from which the {@link Bcp47.LanguageTag | language tag}
+     * is te be constructed.
+     * @param options - (optional) set of {@link Bcp47.LanguageTagInitOptions | init options}
+     * to guide the validation and normalization of this tag.
+     * @returns `Success` with the new {@link Bcp47.LanguageTag | language tag} or `Failure`
+     * with details if an error occurs.
+     */
+    static createFromTag(tag: string, options?: ILanguageTagInitOptions): Result<LanguageTag>;
+    /**
+     * Creates a new {@link Bcp47.LanguageTag | language tag} from a supplied
+     * {@link Bcp47.Subtags | subtags} using optional configuration,
+     * if supplied.
+     * @param tag - The {@link Bcp47.Subtags | subtags} from which the
+     * {@link Bcp47.LanguageTag | language tag} is te be constructed.
+     * @param options - (optional) set of {@link Bcp47.LanguageTagInitOptions | init options}
+     * to guide the validation and normalization of this tag.
+     * @returns `Success` with the new {@link Bcp47.LanguageTag | language tag} or `Failure`
+     * with details if an error occurs.
+     */
+    static createFromSubtags(subtags: ISubtags, options?: ILanguageTagInitOptions): Result<LanguageTag>;
+    /**
+     * Creates a new {@link Bcp47.LanguageTag | language tag} from a supplied `string`
+     * tag or {@link Bcp47.Subtags | subtags} using optional configuration,
+     * if supplied.
+     * @param from - The `string` tag or {@link Bcp47.Subtags | subtags} from
+     * which the {@link Bcp47.LanguageTag | language tag} is te be constructed.
+     * @param options - (optional) set of {@link Bcp47.LanguageTagInitOptions | init options}
+     * to guide the validation and normalization of this tag.
+     * @returns `Success` with the new {@link Bcp47.LanguageTag | language tag} or `Failure`
+     * with details if an error occurs.
+     */
+    static create(from: string | ISubtags, options?: ILanguageTagInitOptions): Result<LanguageTag>;
+    /**
+     * Constructs a new {@link Bcp47.LanguageTag | language tag} by applying appropriate transformations
+     * to as supplied {@link Bcp47.Subtags | Bcp47.Subtags}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags} which represent the tag.
+     * @param fromValidity - The {@link Bcp47.TagValidity | validation level} of the supplied subtags.
+     * @param fromNormalization - The {@link Bcp47.TagNormalization | normalization level} fo the
+     * supplied subtags.
+     * @param partialOptions - Any {@link Bcp47.LanguageTagInitOptions | initialization options}.
+     * @returns `Success` with the corresponding {@link Bcp47.LanguageTag | language tag} or `Failure`
+     * with details if an error occurs.
+     * @internal
+     */
+    protected static _createTransformed(subtags: ISubtags, fromValidity: TagValidity, fromNormalization: TagNormalization, partialOptions?: ILanguageTagInitOptions): Result<LanguageTag>;
+    /**
+     * Gets a fully-specified {@link Bcp47.LanguageTagInitOptions} from partial or undefined
+     * options, substituting defaults as appropriate.
+     * @param options - The {@link Bcp47.LanguageTagInitOptions} to be expanded, or `undefined`
+     * for default options.
+     * @returns Fully-specified {@link Bcp47.LanguageTagInitOptions | init options}.
+     * @internal
+     */
+    protected static _getOptions(options?: ILanguageTagInitOptions): Required<ILanguageTagInitOptions>;
+    /**
+     * Returns the `Suppress-Script` value defined for the primary language of this tag,
+     * regardless of whether a different script is defined in this subtag.
+     * @returns The suppress-script defined for the primary language, or undefined if
+     * the primary language is invalid or has no defined suppressed script.
+     */
+    getSuppressedScript(): Iana.LanguageSubtags.ScriptSubtag | undefined;
+    /**
+     * Gets a confirmed valid representation of this language tag.
+     * @returns `Success` with a valid representation of this {@link Bcp47.LanguageTag | language tag},
+     * or `Failure` with details if the tag cannot be validated.
+     */
+    toValid(): Result<LanguageTag>;
+    /**
+     * Gets a confirmed strictly valid representation of this language tag.
+     * @returns `Success` with a strictly valid representation of this {@link Bcp47.LanguageTag | language tag},
+     * or `Failure` with details if the tag cannot be strictly validated.
+     */
+    toStrictlyValid(): Result<LanguageTag>;
+    /**
+     * Gets a confirmed canonical representation of this language tag.
+     * @returns `Success` with a canonical representation of this {@link Bcp47.LanguageTag | language tag},
+     * or `Failure` with details if the tag cannot be normalized to canonical form.
+     */
+    toCanonical(): Result<LanguageTag>;
+    /**
+     * Gets a confirmed preferred representation of this language tag.
+     * @returns `Success` with a preferred representation of this {@link Bcp47.LanguageTag | language tag},
+     * or `Failure` with details if the tag cannot be normalized to preferred form.
+     */
+    toPreferred(): Result<LanguageTag>;
+    /**
+     * Gets a string representation of this language tag.
+     * @returns A string representation of this language tag.
+     */
+    toString(): string;
+}
+
+/**
+ * @internal
+ */
+declare const languageTagExtension: Converter<Model_2.ILanguageTagExtension, unknown>;
+
+/**
+ * @internal
+ */
+declare const languageTagExtension_2: Converter<Model_2.ILanguageTagExtension, unknown>;
+
+/**
+ * @public
+ */
+declare class LanguageTagExtensionRegistry {
+    readonly fileDate: YearMonthDaySpec_2;
+    readonly extensions: TagExtensionsScope;
+    /**
+     * @internal
+     */
+    protected readonly _all: Model_2.ILanguageTagExtension[];
+    /**
+     * Constructs an {@link Iana.LanguageTagExtensions.LanguageTagExtensionRegistry}.
+     * @param registry - Registry file from which the registry is to be constructed.
+     * @internal
+     */
+    protected constructor(registry: Model_2.LanguageTagExtensions);
+    static create(registry: Model_2.LanguageTagExtensions): Result<LanguageTagExtensionRegistry>;
+    static createFromJson(from: unknown): Result<LanguageTagExtensionRegistry>;
+    static loadDefault(): Result<LanguageTagExtensionRegistry>;
+    static load(path: string): Result<LanguageTagExtensionRegistry>;
+    static loadJsonRegistryFile(path: string): Result<LanguageTagExtensionRegistry>;
+    static loadTxtRegistryFile(path: string): Result<LanguageTagExtensionRegistry>;
+}
+
+/**
+ * @internal
+ */
+declare interface LanguageTagExtensionRegistryEntry {
+    Identifier: ExtensionSingleton_2;
+    Description: string[];
+    Comments: string[];
+    Added: YearMonthDaySpec_2;
+    RFC: string;
+    Authority: string;
+    Contact_Email: string;
+    Mailing_List: string;
+    URL: string;
+}
+
+/**
+ * @internal
+ */
+declare type LanguageTagExtensions = IDatedRegistry<ILanguageTagExtension>;
+
+/**
+ * @internal
+ */
+declare const languageTagExtensions: Converter<IDatedRegistry<Model_2.ILanguageTagExtension>, unknown>;
+
+declare namespace LanguageTagExtensions_2 {
+    export {
+        LanguageTagExtensionRegistry,
+        Converters_5 as Converters,
+        JarConverters_2 as JarConverters,
+        Model_2 as Model,
+        Validate_2 as Validate
+    }
+}
+
+/**
+ * @internal
+ */
+declare const languageTagExtensions_2: Converter<IDatedRegistry<Model_2.ILanguageTagExtension>, unknown>;
+
+/**
+ * Loads language tag extensions registry data from a JSON-formatted file.
+ * @param path - String path from which registry data is to be read.
+ * @returns `Success` with the loaded language tag extension data
+ * or `Failure` with details if an error occurs.
+ * @internal
+ */
+declare function loadJsonLanguageTagExtensionsRegistryFileSync(path: string): Result<Model_2.LanguageTagExtensions>;
+
+/**
+ * Loads a JSON-format language subtag registry file.
+ * @param path - The string path from which the registry is to be loaded.
+ * @returns `Success` with the resulting {@link Iana.LanguageSubtags.Model.RegistryFile | registry file}
+ * or `Failure` with details if an error occurs.
+ * @internal
+ */
+declare function loadJsonSubtagRegistryFileSync(path: string): Result<Items.RegistryFile>;
+
+/**
+ * @public
+ * @param path - String path from which file is to be loaded.
+ * @returns `Success` with the resulting {@link Iana.LanguageSubtags.Model.RegistryFile | registry file}
+ * or `Failure` with details if an error occurs.
+ */
+declare function loadLanguageSubtagsJsonFileSync(path: string): Result<Items.RegistryFile>;
+
+/**
+ * @internal
+ * @param path - path from which the extensions registry is to be loaded.
+ * @returns `Success` with the loaded language tag extensions data, o
+ * or `Failure` with details if an error occurs.
+ */
+declare function loadLanguageTagExtensionsJsonFileSync(path: string): Result<Model_2.LanguageTagExtensions>;
+
+/**
+ * Loads a UNSD M.49 registry text (csv) file.
+ * @param csvPath - The path from which the file is to be loaded.
+ * @returns `Success` with the parsed file contents or `Failure` with
+ * details if an error occurs.
+ * @internal
+ */
+declare function loadM49csvFileSync(csvPath: string): Result<Model_6.IM49CsvRow[]>;
+
+/**
+ * Loads language tag extensions registry data from a text (JAR-formatted) file.
+ * @param path - String path from which registry data is to be read.
+ * @returns `Success` with the loaded language tag extension data
+ * or `Failure` with details if an error occurs.
+ * @internal
+ */
+declare function loadTxtLanguageTagExtensionsRegistryFileSync(path: string): Result<Model_2.LanguageTagExtensions>;
+
+/**
+ * Loads a text (JAR) format language subtag registry file.
+ * @param path - The string path from which the registry is to be loaded.
+ * @returns `Success` with the resulting {@link Iana.LanguageSubtags.Model.RegistryFile | registry file}
+ * or `Failure` with details if an error occurs.
+ * @internal
+ */
+declare function loadTxtSubtagRegistryFileSync(path: string): Result<Items.RegistryFile>;
+
+/**
+ * @internal
+ */
+declare const m49CsvFile: Converter<Model_6.IM49CsvRow[], unknown>;
+
+/**
+ * @internal
+ */
+declare const m49CsvRow: Converter<Model_6.IM49CsvRow, unknown>;
+
+declare namespace Model {
+    export {
+        RegistryEntryType,
+        allRegistryEntryTypes,
+        RegistryEntryScope,
+        allRegistryEntryScopes,
+        YearMonthDaySpec,
+        IRegistrySubtagEntry,
+        IRegistryTagEntry,
+        LanguageSubtagRegistryEntry,
+        ExtLangSubtagRegistryEntry,
+        ScriptSubtagRegistryEntry,
+        RegionSubtagRegistryEntry,
+        VariantSubtagRegistryEntry,
+        GrandfatheredTagRegistryEntry,
+        RedundantTagRegistryEntry,
+        RegistryEntry,
+        RegistryFile
+    }
+}
+
+declare namespace Model_2 {
+    export {
+        ExtensionSingleton_2 as ExtensionSingleton,
+        LanguageTagExtensionRegistryEntry,
+        ILanguageTagExtension,
+        LanguageTagExtensions
+    }
+}
+
+declare namespace Model_3 {
+    export {
+        LanguageSubtags_3 as LanguageSubtags,
+        IFileDateEntry
+    }
+}
+
+declare namespace Model_4 {
+    export {
+        Jar_3 as Jar,
+        IsoAlpha2RegionCode,
+        IsoAlpha3RegionCode,
+        UnM49RegionCode,
+        YearMonthDaySpec_2 as YearMonthDaySpec,
+        IDatedRegistry
+    }
+}
+
+declare namespace Model_5 {
+    export {
+        IsoAlpha2RegionCode,
+        IsoAlpha3RegionCode,
+        UnM49RegionCode,
+        YearMonthDaySpec_2 as YearMonthDaySpec,
+        IDatedRegistry
+    }
+}
+
+declare namespace Model_6 {
+    export {
+        IM49CsvRow
+    }
+}
+
+declare namespace Model_7 {
+    export {
+        ILanguageOverrideRecord
+    }
+}
+
+declare namespace Model_8 {
+    export {
+        ExtensionSubtag,
+        PrivateUseSubtag,
+        PrivateUsePrefix,
+        ExtensionSingleton
+    }
+}
+
+/**
+ * A function which accepts a value of the expected type and reformats it to match
+ * the canonical presentation form.
+ * @public
+ */
+declare type Normalizer<T extends string, TC = unknown> = (val: T, context?: TC) => Result<T>;
+
+/**
+ * Normalization helpers for BCP-47 language tags.
+ * @public
+ */
+declare class NormalizeTag {
+    /**
+     * @internal
+     */
+    private static _normalizers;
+    /**
+     * Converts a BCP-47 language tag to canonical form.  Canonical form uses the recommended capitalization rules
+     * specified in {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | RFC 5646} but are not
+     * otherwise modified.
+     *
+     * @param subtags - The individual {@link Bcp47.Subtags | subtags} to be normalized.
+     * @returns `Success` with the normalized equivalent {@link Bcp47.Subtags | subtags},
+     * or `Failure` with details if an error occurs.
+     */
+    static toCanonical(subtags: ISubtags): Result<ISubtags>;
+    /**
+     * Converts a BCP-47 language tag to preferred form.  Preferred form uses the recommended capitalization rules
+     * specified in {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | RFC 5646} and also
+     * applies additional preferred values specified in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | language subtag registry}:
+     * extraneous (suppressed) script tags are removed, deprecated language, extlang, script or region tags are replaced
+     * with up-to-date preferred values, and grandfathered or redundant tags with a defined preferred-value are replaced
+     * in their entirety with the new preferred value.
+     * @param subtags - The individual {@link Bcp47.Subtags | subtags} to be normalized.
+     * @returns `Success` with the normalized equivalent {@link Bcp47.Subtags | subtags},
+     * or `Failure` with details if an error occurs.
+     */
+    static toPreferred(subtags: ISubtags): Result<ISubtags>;
+    /**
+     * Chooses an appropriate default tag normalizer given desired and optional current
+     * {@link Bcp47.TagNormalization | normalization level}.
+     * @param wantNormalization - The desired {@link Bcp47.TagNormalization | normalization level}.
+     * @param haveNormalization - (optional) The current {@link Bcp47.TagNormalization | normalization level}.
+     * @returns An appropriate {@link Bcp47.TagNormalizer | tag normalizer} or `undefined` if no additional
+     * normalization is necessary.
+     * @internal
+     */
+    static chooseNormalizer(wantNormalization: TagNormalization, haveNormalization?: TagNormalization): ITagNormalizer | undefined;
+    /**
+     * Normalizes supplied {@link Bcp47.Subtags | subtags} to a requested
+     * {@link Bcp47.TagNormalization | normalization level}, if necessary.  If
+     * no normalization is necessary, returns the supplied subtags.
+     * @param subtags - The {@link Bcp47.Subtags | subtags} to be normalized.
+     * @param wantNormalization - The desired {@link Bcp47.TagNormalization | normalization level}.
+     * @param haveNormalization - (optional) The current {@link Bcp47.TagNormalization | normalization level}.
+     * @returns `Success` with the normalized {@link Bcp47.Subtags | subtags}, or
+     * `Failure` with details if an error occurs.
+     */
+    static normalizeSubtags(subtags: ISubtags, wantNormalization: TagNormalization, haveNormalization?: TagNormalization): Result<ISubtags>;
+}
+
+/**
+ * Gets the current date as an {@link Iana.YearMonthDaySpec}.
+ * @public
+ */
+declare function nowAsYearMonthDay(): YearMonthDaySpec_2;
+
+declare namespace Overrides {
+    export {
+        OverridesRegistry,
+        DefaultRegistries_3 as DefaultRegistries
+    }
+}
+
+/**
+ * @public
+ */
+declare class OverridesRegistry {
+    readonly overrides: Map<Iana.LanguageSubtags.LanguageSubtag, ILanguageOverride>;
+    protected constructor();
+    static create(overrides: ILanguageOverride[]): Result<OverridesRegistry>;
+    static createFromJson(from: unknown): Result<OverridesRegistry>;
+    static loadDefault(): Result<OverridesRegistry>;
+    static loadJson(path: string): Result<OverridesRegistry>;
+    /**
+     * Converts a file {@link Bcp47.Overrides.Model.LanguageOverrideRecord | LanguageOverrideRecord }
+     * to a runtime {@link Bcp47.Overrides.LanguageOverride | LanguageOverride}.
+     * @param record - The {@link Bcp47.Overrides.Model.LanguageOverrideRecord | LanguageOverrideRecord } to
+     * be converted.
+     * @returns `Success` with the resulting {@link Bcp47.Overrides.LanguageOverride | LanguageOverride}
+     * or `Error` with details if an error occurs.
+     * @internal
+     */
+    protected static _overrideFromRecord(record: Model_7.ILanguageOverrideRecord): Result<ILanguageOverride>;
+}
+
+/**
+ * @internal
+ */
+declare type PrivateUsePrefix = Brand<string, 'PrivateUsePrefix'>;
+
+/**
+ * @internal
+ */
+declare const privateUsePrefix: Converter<PrivateUsePrefix, unknown>;
+
+/**
+ * @public
+ */
+declare const privateUsePrefix_2: RegExpValidationHelpers<Model_8.PrivateUsePrefix, unknown>;
+
+/**
+ * @internal
+ */
+declare type PrivateUseSubtag = Brand<string, 'PrivateUseSubtag'>;
+
+/**
+ * @internal
+ */
+declare function rangeOfTags<TTAG extends string>(tagConverter: Converter<TTAG>): Converter<TTAG[]>;
+
+/**
+ * Legacy language tag registered as redundant in the IANA language subtag registry.
+ * @public
+ */
+declare type RedundantTag = Brand<string, 'RedundantTag'>;
+
+/**
+ * @public
+ */
+declare const redundantTag: Conversion.Converter<RedundantTag, unknown>;
+
+/**
+ * @public
+ */
+declare const redundantTag_2: TagValidationHelpers<RedundantTag, unknown>;
+
+/**
+ * @internal
+ */
+declare type RedundantTagRegistryEntry = IRegistryTagEntry<'redundant', RedundantTag>;
+
+/**
+ * @public
+ */
+declare class RedundantTagScope extends TagScope<'redundant', RedundantTag, Items.IRegisteredRedundantTag> {
+    constructor();
+}
+
+/**
+ * @internal
+ */
+declare class RegExpValidationHelpers<T extends string, TC = unknown> extends ValidationHelpers<T, TC> {
+    readonly wellFormed: RegExp;
+    readonly canonical: RegExp;
+    constructor(params: IRegExpValidationHelperConstructorParams<T, TC>);
+}
+
+/**
+ * @public
+ */
+declare type Region = IGlobalRegion | IIntermediateRegion;
+
+/**
+ * @public
+ */
+declare class RegionCodes {
+    readonly regions: Regions;
+    readonly areas: Areas;
+    /**
+     * @internal
+     */
+    protected constructor();
+    static create(rows: Model_6.IM49CsvRow[]): Result<RegionCodes>;
+    static createFromJson(from: unknown): Result<RegionCodes>;
+    static loadDefault(): Result<RegionCodes>;
+    static loadCsv(path: string): Result<RegionCodes>;
+    tryGetRegionOrArea(code: Iana.Model.UnM49RegionCode): Region | ICountryOrArea | undefined;
+    getIsContained(container: Region, contained: ICountryOrArea | Region): boolean;
+    /**
+     * Imports a single parsed row of UN M.49 region code data
+     * @param row - The parsed row to be imported.
+     * @returns `Success` with `true` if the row was successfully
+     * imported, or `Failure` with details if an error occurs.
+     * @internal
+     */
+    protected _importRow(row: Model_6.IM49CsvRow): Result<true>;
+    /**
+     * Imports multiple parsed rows from UN M.49 region code data
+     * @param rows - The parsed rows to be imported.
+     * @returns `Success` with `true` if the rows were successfully
+     * imported, or `Failure` with details if an error occurs.
+     * @internal
+     */
+    protected _importRows(rows: Model_6.IM49CsvRow[]): Result<true>;
+}
+
+/**
+ * @public
+ */
+declare class Regions {
+    readonly global: IGlobalRegion;
+    /**
+     * @internal
+     */
+    protected readonly _regions: Map<Iana.Model.UnM49RegionCode, Region>;
+    constructor();
+    tryGetRegion(from: Iana.Model.UnM49RegionCode): Region | undefined;
+    getRegion(from: Iana.Model.UnM49RegionCode): Result<Region>;
+    getOrAddRegionChildRegion(tier: IntermediateRegionTier, parent: Region, code: Iana.Model.UnM49RegionCode | undefined, name: string | undefined): Result<Region>;
+    getAll(): Region[];
+}
+
+/**
+ * Region subtag in the IANA language subtag registry.
+ * @public
+ */
+declare type RegionSubtag = Brand<string, 'RegionSubtag'>;
+
+/**
+ * @public
+ */
+declare const regionSubtag: Conversion.Converter<RegionSubtag, unknown>;
+
+/**
+ * @public
+ */
+declare const regionSubtag_2: RegExpValidationHelpers<RegionSubtag, unknown>;
+
+/**
+ * @internal
+ */
+declare type RegionSubtagRegistryEntry = IRegistrySubtagEntry<'region', RegionSubtag>;
+
+/**
+ * @public
+ */
+declare class RegionSubtagScope extends SubtagScopeWithRange<'region', RegionSubtag, Items.IRegisteredRegion> {
+    constructor();
+}
+
+/**
+ * @public
+ */
+declare type RegionTier = 'global' | IntermediateRegionTier;
+
+/**
+ * @internal
+ */
+declare const regionTier: Converter<RegionTier, RegionTier[]>;
+
+/**
+ * @internal
+ */
+declare const registeredExtLang: Converter<Items.IRegisteredExtLang, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredExtLang_2: Converter<Items.IRegisteredExtLang, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredGrandfatheredTag: Converter<Items.IRegisteredGrandfatheredTag, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredGrandfatheredTag_2: Converter<Items.IRegisteredGrandfatheredTag, unknown>;
+
+/**
+ * @public
+ */
+declare type RegisteredItem = RegisteredSubtagItem | RegisteredTagItem;
+
+/**
+ * @internal
+ */
+declare const registeredItem: Converter<Items.RegisteredItem, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredItem_2: Converter<Items.RegisteredItem, unknown>;
+
+/**
+ * @internal
+ */
+declare abstract class RegisteredItemScope<TTYPE extends string, TKEY extends string, TITEM> {
+    protected readonly _items: Map<TKEY, TITEM>;
+    protected readonly _type: TTYPE;
+    protected readonly _validate: ValidationHelpers<TKEY>;
+    protected constructor(type: TTYPE, validate: ValidationHelpers<TKEY>);
+    getAllKeys(): TKEY[];
+    getAll(): TITEM[];
+    tryGet(want: string | undefined): TITEM | undefined;
+    tryGetCanonical(want: string | undefined): TITEM | undefined;
+    get(want: string | undefined): Result<TITEM>;
+    getCanonical(want: string | undefined): Result<TITEM | undefined>;
+    isWellFormed(val: unknown): val is TKEY;
+    isCanonical(val: unknown): val is TKEY;
+    toCanonical(val: unknown): Result<TKEY>;
+    toValidCanonical(val: unknown): Result<TKEY>;
+    isValid(val: unknown): val is TKEY;
+    isValidCanonical(val: unknown): val is TKEY;
+    verifyIsWellFormed(val: unknown): Result<TKEY>;
+    verifyIsValid(val: unknown): Result<TKEY>;
+    verifyIsCanonical(val: unknown): Result<TKEY>;
+    protected _validateKey(key: TKEY): Result<true>;
+    abstract add(entry: TITEM): Result<true>;
+    protected abstract _validateEntry(entry: TITEM): Result<true>;
+}
+
+/**
+ * @internal
+ */
+declare const registeredLanguage: Converter<Items.IRegisteredLanguage, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredLanguage_2: Converter<Items.IRegisteredLanguage, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredRedundantTag: Converter<Items.IRegisteredRedundantTag, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredRedundantTag_2: Converter<Items.IRegisteredRedundantTag, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredRegion: Converter<Items.IRegisteredRegion, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredRegion_2: Converter<Items.IRegisteredRegion, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredScript: Converter<Items.IRegisteredScript, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredScript_2: Converter<Items.IRegisteredScript, unknown>;
+
+/**
+ * @public
+ */
+declare type RegisteredSubtagItem = IRegisteredLanguage | IRegisteredExtLang | IRegisteredScript | IRegisteredRegion | IRegisteredVariant;
+
+/**
+ * @public
+ */
+declare type RegisteredTagItem = IRegisteredGrandfatheredTag | IRegisteredRedundantTag;
+
+/**
+ * @public
+ */
+declare type RegisteredTagOrSubtag<TTYPE extends Model.RegistryEntryType, TTAG extends string> = IRegisteredSubtag<TTYPE, TTAG> | IRegisteredSubtagWithRange<TTYPE, TTAG> | IRegisteredTag<TTYPE, TTAG>;
+
+/**
+ * @internal
+ */
+declare const registeredVariant: Converter<Items.IRegisteredVariant, unknown>;
+
+/**
+ * @internal
+ */
+declare const registeredVariant_2: Converter<Items.IRegisteredVariant, unknown>;
+
+declare namespace Registry {
+    export {
+        registryEntryType,
+        registryScopeType
+    }
+}
+
+/**
+ * @internal
+ */
+declare type RegistryEntry = LanguageSubtagRegistryEntry | ExtLangSubtagRegistryEntry | ScriptSubtagRegistryEntry | RegionSubtagRegistryEntry | VariantSubtagRegistryEntry | GrandfatheredTagRegistryEntry | RedundantTagRegistryEntry;
+
+/**
+ * @internal
+ */
+declare type RegistryEntryScope = 'collection' | 'macrolanguage' | 'private-use' | 'special';
+
+/**
+ * @internal
+ */
+declare type RegistryEntryType = 'extlang' | 'grandfathered' | 'language' | 'redundant' | 'region' | 'script' | 'variant';
+
+/**
+ * @internal
+ */
+declare const registryEntryType: Converter<Model.RegistryEntryType, Model.RegistryEntryType[]>;
+
+/**
+ * @internal
+ */
+declare type RegistryFile = IDatedRegistry<RegistryEntry>;
+
+/**
+ * @internal
+ */
+declare const registryFile: Converter<IDatedRegistry<Items.RegisteredItem>, unknown>;
+
+/**
+ * @public
+ */
+declare type RegistryFile_2 = IDatedRegistry<RegisteredItem>;
+
+/**
+ * @internal
+ */
+declare const registryFile_2: Converter<IDatedRegistry<Items.RegisteredItem>, unknown>;
+
+/**
+ * @internal
+ */
+declare const registryScopeType: Converter<Model.RegistryEntryScope, Model.RegistryEntryScope[]>;
+
+declare namespace Scope {
+    export {
+        LanguageSubtagScope,
+        ExtLangSubtagScope,
+        ScriptSubtagScope,
+        RegionSubtagScope,
+        VariantSubtagScope,
+        GrandfatheredTagScope,
+        RedundantTagScope
+    }
+}
+
+/**
+ * Script subtag in the IANA language subtag registry.
+ * @public
+ */
+declare type ScriptSubtag = Brand<string, 'ScriptSubtag'>;
+
+/**
+ * @public
+ */
+declare const scriptSubtag: Conversion.Converter<ScriptSubtag, unknown>;
+
+/**
+ * @public
+ */
+declare const scriptSubtag_2: RegExpValidationHelpers<ScriptSubtag, unknown>;
+
+/**
+ * @internal
+ */
+declare type ScriptSubtagRegistryEntry = IRegistrySubtagEntry<'script', ScriptSubtag>;
+
+/**
+ * @public
+ */
+declare class ScriptSubtagScope extends SubtagScopeWithRange<'script', ScriptSubtag, Items.IRegisteredScript> {
+    constructor();
+}
+
+/**
+ * Determine how similar two language tags are to each other.
+ *
+ * @param t1 - First tag to match, supplied as one of `string`, individual
+ * {@link Bcp47.Subtags | subtags}, or constructed
+ * {@link Bcp47.LanguageTag | language tag}.
+ * @param t2 - Second tag to match, supplied as one of `string`, individual
+ * {@link Bcp47.Subtags | subtags}, or constructed
+ * {@link Bcp47.LanguageTag | language tag}.
+ * @param options - (optional) A set of {@link Bcp47.LanguageTagInitOptions | language tag options}
+ * which control any necessary conversion or parsing.
+ * @returns A numeric value in the range 1.0 (exact match) to 0.0 (no match).
+ * @see For a set of common levels of similarity, see {@link Bcp47.tagSimilarity | similarity}.
+ * @public
+ */
+declare function similarity(t1: LanguageSpec, t2: LanguageSpec, options?: ILanguageTagInitOptions): Result<number>;
+
+declare namespace Subtags {
+    export {
+        Converters_7 as Converters,
+        Model_8 as Model,
+        Validate_4 as Validate
+    }
+}
+
+/**
+ * @internal
+ */
+declare class SubtagScope<TTYPE extends Model.RegistryEntryType, TTAG extends string, TITEM extends Items.IRegisteredSubtag<TTYPE, TTAG>> extends RegisteredItemScope<TTYPE, TTAG, TITEM> {
+    protected constructor(type: TTYPE, validate: ValidationHelpers<TTAG>);
+    add(entry: TITEM): Result<true>;
+    protected _validateEntry(entry: TITEM): Result<true>;
+}
+
+/**
+ * @internal
+ */
+declare class SubtagScopeWithRange<TTYPE extends Model.RegistryEntryType, TTAG extends string, TITEM extends Items.IRegisteredSubtagWithRange<TTYPE, TTAG>> extends SubtagScope<TTYPE, TTAG, TITEM> {
+    protected constructor(type: TTYPE, validate: ValidationHelpers<TTAG>);
+    add(entry: TITEM): Result<true>;
+    protected _validateEntry(entry: TITEM): Result<true>;
+    protected _validateRange(start: TTAG, end: TTAG): Result<true>;
+    protected _addRange(entry: TITEM): Result<true>;
+    protected _nextInRange(current: TTAG, end: TTAG): TTAG | undefined;
+}
+
+/**
+ * Converts {@link Bcp47.Subtags | subtags} to a string.
+ * @param subtags - The {@link Bcp47.Subtags | subtags} to be converted.
+ * @returns A string representing the supplied {@link Bcp47.Subtags | subtags}.
+ * @public
+ */
+declare function subtagsToString(subtags: ISubtags): string;
+
+/**
+ * Creates a new {@link Bcp47.LanguageTag | language tag} from a {@link Bcp47.LanguageSpec | language specifier}
+ *
+ * The supplied initializer must be at least
+ * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | well-formed according to RFC 5646}.
+ * Higher degrees of validation along with any normalizations may be optionally specified.
+ *
+ * @param from - The {@link Bcp47.LanguageSpec | language specifier} from which the tag is to
+ * be created.
+ * @param options - (optional) The {@link Bcp47.LanguageTagInitOptions | options} used to construct
+ * and validate the tag.
+ * @returns `Success` with a valid {@link Bcp47.LanguageTag | language tag} or `Failure` with details
+ * if an error occurs.
+ * @public
+ */
+declare function tag(from: LanguageSpec, options?: ILanguageTagInitOptions): Result<LanguageTag>;
+
+/**
+ * @public
+ */
+declare class TagExtensionsScope extends RegisteredItemScope<'language-tag-extension', Model_2.ExtensionSingleton, Model_2.ILanguageTagExtension> {
+    constructor();
+    add(entry: Model_2.ILanguageTagExtension): Result<true>;
+    /**
+     * Validates a single entry from a language tag extensions data file.
+     * @param entry - The language tag extensions registry entry to be
+     * validated.
+     * @returns `Success` with `true` if the entry is valid, `Failure` with
+     * details if an error occurs.
+     * @internal
+     */
+    protected _validateEntry(entry: Model_2.ILanguageTagExtension): Result<true>;
+}
+
+/**
+ * Describes the degree of normalization of a language tag.
+ * @public
+ */
+declare type TagNormalization = 'unknown' | 'none' | 'canonical' | 'preferred';
+
+/**
+ * @internal
+ */
+declare function tagOrRange<TTAG extends string>(tagConverter: Converter<TTAG>): Converter<TTAG | TTAG[]>;
+
+/**
+ * @internal
+ */
+declare function tagOrStartOfTagRange<TTAG extends string>(tagConverter: Converter<TTAG>): Converter<TTAG>;
+
+declare namespace Tags {
+    export {
+        LanguageSubtags as Converters,
+        Helpers,
+        Validators,
+        LanguageSubtag,
+        ExtLangSubtag,
+        ScriptSubtag,
+        RegionSubtag,
+        VariantSubtag,
+        GrandfatheredTag,
+        RedundantTag,
+        ExtendedLanguageRange
+    }
+}
+
+/**
+ * Creates an array of {@link Bcp47.LanguageTag | language tags} from an incoming array of
+ * {@link Bcp47.LanguageSpec | language specifiers}.
+ * @param from - The array of {@link Bcp47.LanguageSpec} to be converted.
+ * @param options - (optional) The {@link Bcp47.LanguageTagInitOptions | options} used to construct
+ * and validate any created tags.
+ * @returns `Success` with an array of {@link Bcp47.LanguageTag | language tags}, or `Failure`
+ * with details if an error occurs.
+ * @public
+ */
+declare function tags(from: LanguageSpec[], options?: ILanguageTagInitOptions): Result<LanguageTag[]>;
+
+declare namespace Tags_2 {
+    export {
+        LanguageSubtag,
+        ExtLangSubtag,
+        ScriptSubtag,
+        RegionSubtag,
+        VariantSubtag,
+        GrandfatheredTag,
+        RedundantTag,
+        ExtendedLanguageRange
+    }
+}
+
+/**
+ * @internal
+ */
+declare class TagScope<TTYPE extends Model.RegistryEntryType, TTAG extends string, TITEM extends Items.IRegisteredTag<TTYPE, TTAG>> extends RegisteredItemScope<TTYPE, TTAG, TITEM> {
+    protected constructor(type: TTYPE, validate: ValidationHelpers<TTAG>);
+    add(entry: TITEM): Result<true>;
+    protected _validateEntry(entry: TITEM): Result<true>;
+}
+
+/**
+ * Numeric representation of the quality of a language match.
+ * Range is 0 (no match) to 1 (exact match).
+ * @public
+ */
+declare type TagSimilarity = keyof typeof tagSimilarity;
+
+/**
+ * Common levels of match quality for a single language match.
+ * @public
+ */
+declare const tagSimilarity: {
+    exact: number;
+    variant: number;
+    region: number;
+    macroRegion: number;
+    neutralRegion: number;
+    preferredAffinity: number;
+    affinity: number;
+    preferredRegion: number;
+    sibling: number;
+    undetermined: number;
+    none: number;
+};
+
+/**
+ * @internal
+ */
+declare class TagValidationHelpers<T extends string, TC = unknown> extends ValidationHelpers<T, TC> {
+    readonly wellFormed: RegExp;
+    constructor(description: string);
+    static toCanonicalTag<T extends string>(val: T): Result<T>;
+}
+
+/**
+ * Describes the validation level of a particular tag.
+ * @public
+ */
+declare type TagValidity = 'unknown' | 'well-formed' | 'valid' | 'strictly-valid';
+
+/**
+ * Represents a UN M.49 numeric region code.
+ * @public
+ */
+declare type UnM49RegionCode = Brand<string, 'UnM49RegionCode'>;
+
+/**
+ * Validating converter from string {@link Iana.Model.UnM49RegionCode}.
+ * @public
+ */
+declare const unM49RegionCode: Converter<UnM49RegionCode, unknown>;
+
+/**
+ * @public
+ */
+declare const unM49RegionCode_2: RegExpValidationHelpers<Model_5.UnM49RegionCode, unknown>;
+
+declare namespace Unsd {
+    export {
+        DefaultRegistries_2 as DefaultRegistries,
+        RegionCodes,
+        Csv,
+        IntermediateRegionTier,
+        RegionTier,
+        IGlobalRegion,
+        IIntermediateRegion,
+        Region,
+        ICountryOrArea
+    }
+}
+export { Unsd }
+
+declare namespace Utils {
+    export {
+        Normalizer,
+        ValidationHelpers,
+        IValidationHelpersConstructorParams as ValidationHelpersConstructorParams
+    }
+}
+export { Utils }
+
+declare namespace Validate {
+    export {
+        languageSubtag_2 as languageSubtag,
+        extlangSubtag_2 as extlangSubtag,
+        scriptSubtag_2 as scriptSubtag,
+        regionSubtag_2 as regionSubtag,
+        variantSubtag_2 as variantSubtag,
+        grandfatheredTag_2 as grandfatheredTag,
+        redundantTag_2 as redundantTag,
+        extendedLanguageRange_2 as extendedLanguageRange
+    }
+}
+
+declare namespace Validate_2 {
+    export {
+        extensionSingleton_2 as extensionSingleton
+    }
+}
+
+declare namespace Validate_3 {
+    export {
+        yearMonthDateSpec,
+        isoAlpha2RegionCode_2 as isoAlpha2RegionCode,
+        isoAlpha3RegionCode_2 as isoAlpha3RegionCode,
+        unM49RegionCode_2 as unM49RegionCode
+    }
+}
+
+declare namespace Validate_4 {
+    export {
+        extensionSingleton_3 as extensionSingleton,
+        extensionSubtag_2 as extensionSubtag,
+        privateUsePrefix_2 as privateUsePrefix
+    }
+}
+
+/**
+ * Validation helpers for BCP-47 language tags.
+ * @public
+ */
+declare class ValidateTag {
+    private static _isCanonical?;
+    private static _isInPreferredForm?;
+    private static _validators;
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are in canonical form,
+     * meaning that they are at least well-formed as specified by
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646}, and
+     * all subtags are also
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | capitalized as recommended}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a language tag in canonical, false otherwise.
+     * @example `en-US` is in canonical form, `en-us` is not.
+     * @example `eng-US` is in canonical form, `eng-us` is not.
+     */
+    static isCanonical(subtags: ISubtags): boolean;
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * in preferred form. Preferred form is valid as specified by
+     * {@link  https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646} and
+     * also meets additional preferences specified in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | language subtag registry} -
+     * extraneous (suppressed) script tags, deprecated language, extlang, script or region tags or
+     * deprecated grandfathered or redundant tags (with a defined preferred-value) are not allowed.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a valid language tag in preferred form, false otherwise.
+     * @example `en-US` is in preferred form, `en-Latn-US` is not.
+     * @example `cmn` is in preferred form, `zh-cmn-Hans` is not.
+     */
+    static isInPreferredForm(subtags: ISubtags): boolean;
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * strictly valid.  A strictly valid tag is both
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | valid as defined in the RFC}
+     * and meets any other requirements such as
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-3.1.8 | prefix validity}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a strictly valid language tag, false otherwise.
+     * @example `ca-valencia` is strictly valid, `es-valencia` is not.
+     */
+    static isStrictlyValid(subtags: ISubtags): boolean;
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * valid as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},
+     * meaning that all subtags, or the tag itself for grandfathered tags, are defined in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | IANA language subtag registry}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a valid language tag, false otherwise.
+     * @example `en-US` is valid, `eng-US` is not.
+     */
+    static isValid(subtags: ISubtags): boolean;
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * well-formed as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},
+     * meaning that all subtags meet the grammar defined in the specification.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a well-formed language tag, false otherwise.
+     * @example `en-US` is valid, `english-US` is not.
+     * @public
+     */
+    static isWellFormed(subtags: ISubtags): boolean;
+    /**
+     * Chooses an appropriate default tag validator given desired and optional current
+     * {@link Bcp47.TagValidity | validation level}.
+     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.
+     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.
+     * @returns An appropriate {@link Bcp47.TagValidator | tag validator} or `undefined` if no
+     * additional validation is necessary.
+     * @internal
+     */
+    static chooseValidator(wantValidity: TagValidity, haveValidity?: TagValidity): ITagValidator | undefined;
+    /**
+     * Validates supplied {@link Bcp47.Subtags | subtags } to a requested
+     * {@link Bcp47.TagValidity | validity level}, if necessary.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to be validated.
+     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.
+     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.
+     * @returns `Success` with the validated {@link Bcp47.Subtags | subtags }, or
+     * `Failure` with details if an error occurs.
+     * @public
+     */
+    static validateSubtags(subtags: ISubtags, wantValidity: TagValidity, haveValidity?: TagValidity): Result<boolean>;
+}
+
+/**
+ A collection of validation and normalization helpers for constrained string
+ types.
+ * @public
+ */
+declare class ValidationHelpers<T extends string, TC = unknown> {
+    /**
+     * Describes the group of tags validated by these helpers.
+     */
+    readonly description: string;
+    /**
+     * A `Converter` which converts `unknown` to the tag type
+     * validated by these helpers, if possible.
+     */
+    readonly converter: Converter<T, TC>;
+    /**
+     * Determines is a supplied tag is well-formed according to the
+     * lexical rules defined for the tag validated by these helpers.
+     */
+    readonly isWellFormed: Validation.TypeGuardWithContext<T, TC>;
+    /**
+     * Determines is a supplied tag is well-formed and uses canonical
+     * formatting, according to the lexical rules defined for the tag
+     * validated by these helpers.
+     */
+    readonly isCanonical: Validation.TypeGuardWithContext<T, TC>;
+    /**
+     * @internal
+     */
+    protected readonly _toCanonical?: Normalizer<T, TC>;
+    /**
+     * Constructs new {@link Utils.ValidationHelpers | validation helpers}
+     * from supplied initializers.
+     * @param init - The {@link Utils.ValidationHelpersConstructorParams | constructor params}
+     * used to initialize this {@link Utils.ValidationHelpers | validation helpers}.
+     */
+    constructor(init: IValidationHelpersConstructorParams<T, TC>);
+    /**
+     * Converts a supplied `unknown` to the canonical form of the tag
+     * validated by these helpers.
+     * @param from - The `unknown` to be converted.
+     * @param context - Optional context used in the conversion.
+     * @returns `Success` with the corresponding canonical value,
+     * or `Failure` with details if an error occurs.
+     */
+    toCanonical(from: unknown, context?: TC): Result<T>;
+    /**
+     * Determines if a supplied `unknown` is a well-formed representation
+     * of the tag validated by these helpers.
+     * @param from - The `unknown` to be validated.
+     * @param context - Optional context used in the validation.
+     * @returns `Success` with the validated value, or `Failure` with details
+     * if an error occurs.
+     */
+    verifyIsWellFormed(from: unknown, context?: TC): Result<T>;
+    /**
+     * Determines if a supplied `unknown` is a well-formed, canonical representation
+     * of the tag validated by these helpers.
+     * @param from - The `unknown` to be validated.
+     * @param context - Optional context used in the validation.
+     * @returns `Success` with the validated canonical value, or `Failure` with
+     * details if an error occurs.
+     */
+    verifyIsCanonical(from: unknown, context?: TC): Result<T>;
+}
+
+declare namespace Validators {
+    export {
+        languageSubtag_2 as languageSubtag,
+        extlangSubtag_2 as extlangSubtag,
+        scriptSubtag_2 as scriptSubtag,
+        regionSubtag_2 as regionSubtag,
+        variantSubtag_2 as variantSubtag,
+        grandfatheredTag_2 as grandfatheredTag,
+        redundantTag_2 as redundantTag,
+        extendedLanguageRange_2 as extendedLanguageRange
+    }
+}
+
+/**
+ * Variant subtag in the IANA language subtag registry.
+ * @public
+ */
+declare type VariantSubtag = Brand<string, 'VariantSubtag'>;
+
+/**
+ * @public
+ */
+declare const variantSubtag: Conversion.Converter<VariantSubtag, unknown>;
+
+/**
+ * @public
+ */
+declare const variantSubtag_2: RegExpValidationHelpers<VariantSubtag, unknown>;
+
+/**
+ * @internal
+ */
+declare type VariantSubtagRegistryEntry = IRegistrySubtagEntry<'variant', VariantSubtag>;
+
+/**
+ * @public
+ */
+declare class VariantSubtagScope extends SubtagScope<'variant', VariantSubtag, Items.IRegisteredVariant> {
+    constructor();
+}
+
+/**
+ * @public
+ */
+declare const yearMonthDateSpec: RegExpValidationHelpers<Model_5.YearMonthDaySpec, unknown>;
+
+/**
+ * @public
+ */
+declare type YearMonthDaySpec = Brand<string, 'YearMonthDaySpec'>;
+
+/**
+ * Validating converter from string {@link Iana.Model.YearMonthDaySpec}.
+ * @public
+ */
+declare const yearMonthDaySpec: Converter<YearMonthDaySpec_2, unknown>;
+
+/**
+ * Represents a date string in the format YYYY-MM-DD.
+ * @public
+ */
+declare type YearMonthDaySpec_2 = Brand<string, 'YearMonthDaySpec'>;
+
+export { }