@leyyo/common 1.0.0 → 1.0.2

package/dist/to/common-to-impl.d.ts

@@ -1,5 +1,5 @@
-import { CommonTo, CommonToSecure, TypeArrayOpt, TypeEnumOpt, TypeObjectOpt, TypeOpt } from "./index-types";
-import { Dict, KeyValue, OneOrMore } from "../aliases";
+import { CommonTo, CommonToSecure } from "./index-types";
+import { Dict, KeyValue, OneOrMore, ToTypeArrayOpt, ToTypeEnumOpt, ToTypeObjectOpt, ToTypeOpt } from "../shared";
 import { Leyyo } from "../leyyo";
 export declare class CommonToImpl implements CommonTo, CommonToSecure {
     private readonly _EXPECTED_ANY;
@@ -11,27 +11,27 @@ export declare class CommonToImpl implements CommonTo, CommonToSecure {
     private readonly _EXPECTED_NUMBER;
     private readonly _EXPECTED_STRING;
     private is;
-    private callback;
+    private fqn;
     private assertion;
     private _enumInMap;
     private _enumInArray;
     private _enumInAlteration;
-    runFn<T = unknown>(fn: Function, value: Function, opt?: TypeOpt): T;
-    runSave<T = unknown>(fn: Function, value: unknown, opt?: TypeOpt): T;
-    raiseInvalidValue<T = unknown>(value: unknown, expected: OneOrMore<string>, opt?: TypeOpt, params?: Dict): T;
-    any(value: unknown, opt?: TypeOpt): unknown;
-    array<T = unknown>(value: unknown, opt?: TypeArrayOpt): Array<T>;
-    boolean(value: unknown, opt?: TypeOpt): boolean;
-    clazz(value: unknown, opt?: TypeOpt): string;
-    date(value: unknown, opt?: TypeOpt): Date;
-    enumeration<T extends KeyValue = KeyValue>(value: unknown, opt?: TypeEnumOpt<T>): T;
-    float(value: unknown, opt?: TypeOpt): number | null;
-    func<T = Function>(value: unknown, opt?: TypeOpt): T | null;
-    integer(value: unknown, opt?: TypeOpt): number | null;
-    object<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
-    dict<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
-    string(value: unknown, opt?: TypeOpt): string;
-    text(value: unknown, opt?: TypeOpt): string;
+    runFn<T = unknown>(fn: Function, value: Function, opt?: ToTypeOpt): T;
+    runSave<T = unknown>(fn: Function, value: unknown, opt?: ToTypeOpt): T;
+    raiseInvalidValue<T = unknown>(value: unknown, expected: OneOrMore<string>, opt?: ToTypeOpt, params?: Dict): T;
+    any(value: unknown, opt?: ToTypeOpt): unknown;
+    array<T = unknown>(value: unknown, opt?: ToTypeArrayOpt): Array<T>;
+    boolean(value: unknown, opt?: ToTypeOpt): boolean;
+    clazz(value: unknown, opt?: ToTypeOpt): string;
+    date(value: unknown, opt?: ToTypeOpt): Date;
+    enumeration<T extends KeyValue = KeyValue>(value: unknown, opt?: ToTypeEnumOpt<T>): T;
+    float(value: unknown, opt?: ToTypeOpt): number | null;
+    func<T = Function>(value: unknown, opt?: ToTypeOpt): T | null;
+    integer(value: unknown, opt?: ToTypeOpt): number | null;
+    object<T = unknown>(value: unknown, opt?: ToTypeObjectOpt): Dict<T>;
+    dict<T = unknown>(value: unknown, opt?: ToTypeObjectOpt): Dict<T>;
+    string(value: unknown, opt?: ToTypeOpt): string;
+    text(value: unknown, opt?: ToTypeOpt): string;
     $init(leyyo: Leyyo): void;
     get $back(): CommonTo;
     get $secure(): CommonToSecure;

package/dist/to/common-to-impl.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonToImpl = void 0;
-const literals_1 = require("../literals");
-const error_1 = require("../error");
+const literal_1 = require("../literal");
+const exception_1 = require("../exception");
 // noinspection JSUnusedGlobalSymbols
 class CommonToImpl {
     constructor() {
@@ -137,7 +137,7 @@ class CommonToImpl {
             return fn(value);
         }
         catch (e) {
-            error_1.Exception.cast(e).raise(!(opt === null || opt === void 0 ? void 0 : opt.silent));
+            exception_1.Exception.cast(e).raise(!(opt === null || opt === void 0 ? void 0 : opt.silent));
         }
         return null;
     }
@@ -150,7 +150,7 @@ class CommonToImpl {
             indicator = 'type.invalid-value';
         }
         opt = Object.assign(Object.assign(Object.assign({}, opt), params), { expected, value });
-        new error_1.DeveloperException(indicator, opt)
+        new exception_1.DeveloperException(indicator, opt)
             .with(this)
             .raise(!(opt === null || opt === void 0 ? void 0 : opt.silent));
         return null;
@@ -201,7 +201,7 @@ class CommonToImpl {
                                 result.push(valueFn(v, clonedOpt));
                             }
                             catch (e) {
-                                error_1.Exception.cast(e).raise(!opt.silent);
+                                exception_1.Exception.cast(e).raise(!opt.silent);
                                 result.push(null);
                             }
                         });
@@ -226,10 +226,10 @@ class CommonToImpl {
                 if (value === '') {
                     return null;
                 }
-                if (literals_1.WeakTrueItems.includes(value)) {
+                if (literal_1.WeakTrueItems.includes(value)) {
                     return true;
                 }
-                if (literals_1.WeakFalseItems.includes(value)) {
+                if (literal_1.WeakFalseItems.includes(value)) {
                     return false;
                 }
                 return this.raiseInvalidValue(value, this._EXPECTED_BOOL, opt);
@@ -258,7 +258,7 @@ class CommonToImpl {
                 return value;
             case 'object':
             case 'function':
-                return this.callback.fqnName(value);
+                return this.fqn.name(value);
         }
         return this.raiseInvalidValue(value, this._EXPECTED_CLASS, opt);
     }
@@ -314,7 +314,7 @@ class CommonToImpl {
             mapType = 'array';
         }
         if (!mapType) {
-            throw new error_1.DeveloperException('type.invalid-enum-items', { map: opt.map });
+            throw new exception_1.DeveloperException('type.invalid-enum-items', { map: opt.map });
         }
         let v;
         switch (typeof value) {
@@ -475,7 +475,7 @@ class CommonToImpl {
                             result[keyOpt.fn(k, keyOpt)] = valueOpt.fn(v, valueOpt);
                         }
                         catch (e) {
-                            error_1.Exception.cast(e).raise(!opt.silent);
+                            exception_1.Exception.cast(e).raise(!opt.silent);
                             result[k] = null;
                         }
                     }
@@ -540,7 +540,7 @@ class CommonToImpl {
     // region secure
     $init(leyyo) {
         this.is = leyyo.is;
-        this.callback = leyyo.callback;
+        this.fqn = leyyo.fqn;
         this.assertion = leyyo.assertion;
     }
     get $back() {

package/dist/to/index-types.d.ts

@@ -1,50 +1,20 @@
-import { Dict, KeyValue, OneOrMore, ShiftMain, ShiftSecure } from "../aliases";
-import { Leyyo } from "../leyyo";
-import { AssertionOpt } from "../assertion";
+import { Dict, InitLike, KeyValue, OneOrMore, ShiftMain, ShiftSecure, ToTypeArrayOpt, ToTypeEnumOpt, ToTypeObjectOpt, ToTypeOpt } from "../shared";
 export interface CommonTo extends ShiftSecure<CommonToSecure> {
-    runFn<T = unknown>(fn: Function, value: Function, opt?: TypeOpt): T;
-    raiseInvalidValue<T = unknown>(value: unknown, expected: OneOrMore<string>, opt?: TypeOpt, params?: Dict): T;
-    any(value: unknown, opt?: TypeOpt): unknown;
-    array<T = unknown>(value: unknown, opt?: TypeArrayOpt): Array<T>;
-    boolean(value: unknown, opt?: TypeOpt): boolean;
-    clazz(value: unknown, opt?: TypeOpt): string;
-    date(value: unknown, opt?: TypeOpt): Date;
-    enumeration<T extends KeyValue = KeyValue>(value: unknown, opt?: TypeEnumOpt<T>): T;
-    float(value: unknown, opt?: TypeOpt): number | null;
-    func<T = Function>(value: unknown, opt?: TypeOpt): T | null;
-    integer(value: unknown, opt?: TypeOpt): number | null;
-    object<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
-    dict<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
-    string(value: unknown, opt?: TypeOpt): string;
-    text(value: unknown, opt?: TypeOpt): string;
+    runFn<T = unknown>(fn: Function, value: Function, opt?: ToTypeOpt): T;
+    raiseInvalidValue<T = unknown>(value: unknown, expected: OneOrMore<string>, opt?: ToTypeOpt, params?: Dict): T;
+    any(value: unknown, opt?: ToTypeOpt): unknown;
+    array<T = unknown>(value: unknown, opt?: ToTypeArrayOpt): Array<T>;
+    boolean(value: unknown, opt?: ToTypeOpt): boolean;
+    clazz(value: unknown, opt?: ToTypeOpt): string;
+    date(value: unknown, opt?: ToTypeOpt): Date;
+    enumeration<T extends KeyValue = KeyValue>(value: unknown, opt?: ToTypeEnumOpt<T>): T;
+    float(value: unknown, opt?: ToTypeOpt): number | null;
+    func<T = Function>(value: unknown, opt?: ToTypeOpt): T | null;
+    integer(value: unknown, opt?: ToTypeOpt): number | null;
+    object<T = unknown>(value: unknown, opt?: ToTypeObjectOpt): Dict<T>;
+    dict<T = unknown>(value: unknown, opt?: ToTypeObjectOpt): Dict<T>;
+    string(value: unknown, opt?: ToTypeOpt): string;
+    text(value: unknown, opt?: ToTypeOpt): string;
+}
+export interface CommonToSecure extends ShiftMain<CommonTo>, InitLike {
 }
-export interface CommonToSecure extends ShiftMain<CommonTo> {
-    $init(leyyo: Leyyo): void;
-}
-export interface TypeOpt extends AssertionOpt {
-    silent?: true;
-    children?: unknown;
-}
-export type TypeFnLambda<T = unknown, O extends TypeOpt = TypeOpt> = (value: unknown, opt?: O) => T;
-export interface TypeChildOpt<T = unknown> extends TypeOpt {
-    fn?: TypeFnLambda<T>;
-}
-export interface TypeArrayChildOpt<V extends TypeChildOpt = TypeChildOpt> extends Dict<TypeChildOpt> {
-    value?: V;
-}
-export interface TypeArrayOpt<V extends TypeChildOpt = TypeChildOpt> extends TypeOpt {
-    children?: TypeArrayChildOpt<V>;
-}
-export interface TypeDictChildOpt<K extends TypeChildOpt = TypeChildOpt, V extends TypeChildOpt = TypeChildOpt> extends Record<string, TypeChildOpt> {
-    key?: K;
-    value?: V;
-}
-export interface TypeObjectOpt<K extends TypeChildOpt = TypeChildOpt, V extends TypeChildOpt = TypeChildOpt> extends TypeOpt {
-    children?: TypeDictChildOpt<K, V>;
-}
-export interface TypeEnumOpt<E extends KeyValue = KeyValue> extends TypeOpt {
-    map: EnumerationMap<E>;
-    alt?: EnumerationAlt<E>;
-}
-export type EnumerationMap<E extends KeyValue = KeyValue> = Dict<E>;
-export type EnumerationAlt<E extends KeyValue = KeyValue> = Dict<E>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leyyo/common",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Common library",
   "keywords": [
     "common"

package/dist/callback/common-callback-impl.d.ts

@@ -1,31 +0,0 @@
-import { Arr } from "../aliases";
-import { CallbackWhenDefinedLambda, CommonCallback, CommonCallbackDefined, CommonCallbackSecure } from "./index-types";
-import { Leyyo } from "../leyyo";
-export declare class CommonCallbackImpl implements CommonCallback, CommonCallbackSecure {
-    private _waitingForCallbacks;
-    private _attachedCallbacks;
-    private _waitingForProviders;
-    private _definedProviders;
-    fqnName(value: any): string;
-    /**
-     * Default constructor
-     *
-     * Responsibilities
-     * - Create repositories => ie: callbacks
-     * - Trigger clear pending operation
-     * */
-    constructor();
-    $init(leyyo: Leyyo): void;
-    /**
-     * Clear jobs in the queue which named as pending
-     *
-     * Because the expected callback may not be defined
-     * */
-    private _clearPending;
-    get $secure(): CommonCallbackSecure;
-    attachCallback(name: string, fn: Function): void;
-    queueForCallback(name: string, ...args: Arr): boolean;
-    get $back(): CommonCallback;
-    whenProviderDefined<T extends CommonCallbackDefined = CommonCallbackDefined>(name: string, consumer: Function, callback: CallbackWhenDefinedLambda<T>): void;
-    defineProvider<T extends CommonCallbackDefined = CommonCallbackDefined>(name: string, producer: Function, instance: T): void;
-}

package/dist/callback/common-callback-impl.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommonCallbackImpl = void 0;
-const constants_1 = require("../constants");
-const error_1 = require("../error");
-const internal_1 = require("../internal");
-class CommonCallbackImpl {
-    fqnName(value) {
-        switch (typeof value) {
-            case "function":
-                return value.name;
-            case "object":
-                return value.constructor.name;
-            case "string":
-                return value;
-            default:
-                return null;
-        }
-    }
-    /**
-     * Default constructor
-     *
-     * Responsibilities
-     * - Create repositories => ie: callbacks
-     * - Trigger clear pending operation
-     * */
-    constructor() {
-        // clear after 1 minute
-        setTimeout(() => this._clearPending(), 60000);
-    }
-    $init(leyyo) {
-        this._waitingForCallbacks = leyyo.storage.newMap(`${internal_1.FQN_PCK}/waitingForCallbacks`);
-        this._attachedCallbacks = leyyo.storage.newMap(`${internal_1.FQN_PCK}/attachedCallbacks`);
-        this._waitingForProviders = leyyo.storage.newMap(`${internal_1.FQN_PCK}/waitingForProviders`);
-        this._definedProviders = leyyo.storage.newMap(`${internal_1.FQN_PCK}/definedProviders`);
-        // define itself temporarily for fqn name
-        this.defineProvider(constants_1.LY_ATTACHED_FQN, CommonCallbackImpl, {
-            proper: false,
-            name: this.fqnName,
-        });
-        // when new fqn provider is defined, replace temporary name method
-        this.whenProviderDefined(constants_1.LY_ATTACHED_FQN, CommonCallbackImpl, (ins) => {
-            if (typeof ins.name === 'function') {
-                this.fqnName = ins.name;
-            }
-        });
-    }
-    /**
-     * Clear jobs in the queue which named as pending
-     *
-     * Because the expected callback may not be defined
-     * */
-    _clearPending() {
-        for (const [name,] of this._waitingForCallbacks.entries()) {
-            const rec = this._attachedCallbacks.get(name);
-            if (rec && !rec.initialization) {
-                continue;
-            }
-            this._waitingForCallbacks.delete(name);
-            console.log(`callback.cleared.pending => {name: ${name}}`);
-        }
-    }
-    get $secure() {
-        return this;
-    }
-    attachCallback(name, fn) {
-        if (!name || typeof name !== 'string') {
-            throw new Error(`callback.invalid.name => {type: ${typeof name}}`);
-        }
-        // callback attached
-        this._attachedCallbacks.set(name, { fn });
-        // check waiting records, to be called
-        if (this._waitingForCallbacks.has(name)) {
-            this._waitingForCallbacks.get(name).forEach(item => {
-                fn(...item);
-            });
-            this._waitingForCallbacks.delete(name);
-        }
-    }
-    queueForCallback(name, ...args) {
-        if (!name || typeof name !== 'string') {
-            throw new Error(`callback.invalid.name => {type: ${typeof name}}`);
-        }
-        // callback already exists
-        if (this._attachedCallbacks.has(name)) {
-            const rec = this._attachedCallbacks.get(name);
-            rec.fn(...args);
-            return true;
-        }
-        // callback does not exist yet, so wait to be attached
-        if (this._waitingForCallbacks.has(name)) {
-            this._waitingForCallbacks.get(name).push(args);
-        }
-        else {
-            this._waitingForCallbacks.set(name, [args]);
-        }
-        return false;
-    }
-    get $back() {
-        return undefined;
-    }
-    whenProviderDefined(name, consumer, callback) {
-        if (!name || typeof name !== 'string') {
-            throw new error_1.DeveloperException(`callback.invalid.name`, { type: typeof name });
-        }
-        if (!this._waitingForProviders.has(name)) {
-            this._waitingForProviders.set(name, []);
-        }
-        if (this._definedProviders.has(name)) {
-            const ins = this._definedProviders.get(name);
-            if (ins.producer !== consumer) {
-                callback(ins);
-            }
-        }
-        this._waitingForProviders.get(name).push({ consumer, callback });
-    }
-    defineProvider(name, producer, instance) {
-        if (!name || typeof name !== 'string') {
-            throw new error_1.DeveloperException(`callback.invalid.name`, { type: typeof name });
-        }
-        const ins = Object.assign(Object.assign({}, instance), { producer });
-        this._definedProviders.set(name, ins);
-        if (instance.proper) {
-            if (this._waitingForProviders.has(name)) {
-                this._waitingForProviders.get(name).forEach(item => {
-                    if (item.consumer !== producer) {
-                        item.callback(instance);
-                    }
-                });
-            }
-        }
-    }
-}
-exports.CommonCallbackImpl = CommonCallbackImpl;

package/dist/callback/index-types.d.ts

@@ -1,75 +0,0 @@
-import { Arr, ShiftMain, ShiftSecure } from "../aliases";
-import { Leyyo } from "../leyyo";
-/**
- * Callback repository, it collects all jobs and fire them when callback is defined
- * */
-export interface CommonCallback extends ShiftSecure<CommonCallbackSecure> {
-    /**
-     * Attach a callback
-     *
-     * @param {string} name
-     * @param {Function} fn
-     *
-     * Notes:
-     * - name should be regular string
-     * - After attached, it should call all waiting calls in the queue
-     * */
-    attachCallback(name: string, fn: Function): void;
-    /**
-     * Add a call into queue, which to be executed by appropriate callback
-     *
-     * @param {string} name
-     * @param {Array<any>} args
-     * @returns {boolean} - callback exists?
-     *
-     * Notes:
-     * - name should be regular string
-     * */
-    queueForCallback(name: string, ...args: Arr): boolean;
-    fqnName(value: any): string;
-    /**
-     * Informs when callback is changed
-     *
-     * @param {string} name
-     * @param {Function} consumer
-     * @param {CallbackWhenDefinedLambda} callback
-     *
-     * Notes:
-     * - name should be regular string
-     * - callback should be regular function
-     * - name should not be already defined
-     * */
-    whenProviderDefined<T extends CommonCallbackDefined = CommonCallbackDefined>(name: string, consumer: Function, callback: CallbackWhenDefinedLambda<T>): void;
-    /**
-     * Defines a provider to replace temporary providers
-     *
-     * @param {string} name
-     * @param {Function} producer
-     * @param {Object} instance
-     *
-     * Notes:
-     * - name should be regular string
-     * */
-    defineProvider<T extends CommonCallbackDefined = CommonCallbackDefined>(name: string, producer: Function, instance: T): void;
-}
-export interface CommonCallbackSecure extends ShiftMain<CommonCallback> {
-    $init(leyyo: Leyyo): void;
-}
-export interface CallbackRec {
-    initialization?: true;
-    fn: Function;
-}
-export interface CommonCallbackDefinedInternal extends CommonCallbackDefined {
-    producer: Function;
-}
-export interface CommonCallbackDefined {
-    proper: boolean;
-}
-export interface CommonCallbackDefinedItem {
-    consumer: Function;
-    callback: CallbackWhenDefinedLambda;
-}
-export interface CommonFqnCb extends CommonCallbackDefined {
-    name(value: any): string;
-}
-export type CallbackWhenDefinedLambda<T extends CommonCallbackDefined = CommonCallbackDefined> = (instance: T) => void;

package/dist/callback/index.d.ts

@@ -1,2 +0,0 @@
-export * from './index-types';
-export * from './common-callback-impl';

package/dist/literals.d.ts

@@ -1,98 +0,0 @@
-/**
- * Weak True items
- * */
-export declare const PrimitiveItems: readonly ["string", "number", "bigint", "boolean"];
-/**
- * Weak True
- * */
-export type Primitive = typeof PrimitiveItems[number];
-/**
- * Weak True items
- * */
-export declare const RealValueItems: readonly ["string", "number", "bigint", "boolean", "object", "function"];
-/**
- * Weak True
- * */
-export type RealValue = typeof RealValueItems[number];
-/**
- * Weak True items
- * */
-export declare const KeyValueItems: readonly ["string", "number"];
-/**
- * Weak True items
- * */
-export declare const WeakTrueItems: readonly ["1", "true", "t", "yes", "y", "on"];
-/**
- * Weak True
- * */
-export type WeakTrue = typeof WeakTrueItems[number];
-/**
- * Weak False items
- * */
-export declare const WeakFalseItems: readonly ["0", "-1", "false", "f", "no", "n", "off"];
-/**
- * Weak False
- * */
-export type WeakFalse = typeof WeakFalseItems[number];
-/**
- * Weak Boolean
- * */
-export type WeakBoolean = WeakTrue & WeakFalse;
-/**
- * Http Method items
- * */
-export declare const HttpMethodItems: readonly ["delete", "get", "head", "link", "options", "patch", "post", "purge", "put", "unlink"];
-/**
- * Http Method
- * */
-export type HttpMethod = typeof HttpMethodItems[number];
-/**
- * Http Place items
- * */
-export declare const HttpPlaceItems: readonly ["query", "body", "header", "path"];
-/**
- * Http Place
- * */
-export type HttpPlace = typeof HttpPlaceItems[number];
-/**
- * Severity items
- * */
-export declare const SeverityItems: readonly ["debug", "error", "fatal", "info", "log", "trace", "warn"];
-/**
- * Severity for log and errors
- * */
-export type Severity = typeof SeverityItems[number];
-/**
- * Environment items
- * */
-export declare const EnvironmentItems: readonly ["automation", "development", "local", "production", "staging", "test"];
-/**
- * Environment
- * */
-export type Environment = typeof EnvironmentItems[number];
-/**
- * Country code items
- * */
-export declare const CountryCodeItems: readonly ["AD", "AE", "AF", "AG", "AI", "AL", "AM", "AN", "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AX", "AZ", "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BM", "BN", "BO", "BR", "BS", "BT", "BV", "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR", "CS", "CU", "CV", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE", "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", "GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GW", "GY", "HK", "HM", "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS", "IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA", "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "MG", "MH", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", "PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RU", "RW", "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "ST", "SV", "SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TO", "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF", "WS", "YE", "YT", "ZA", "ZM", "ZW"];
-/**
- * Country code
- * */
-export type CountryCode = typeof CountryCodeItems[number];
-/**
- * Language code items
- * */
-export declare const LanguageCodeItems: readonly ["af", "an", "ar", "as", "ast", "az", "be", "bg", "bn", "br", "bs", "ca", "ce", "ch", "co", "cr", "cs", "cv", "cy", "da", "de", "el", "en", "eo", "es", "et", "eu", "fa", "fi", "fj", "fo", "fr", "fur", "fy", "ga", "gd", "gl", "gu", "he", "hi", "hr", "hsb", "ht", "hu", "hy", "id", "is", "it", "iu", "ja", "ji", "ka", "kk", "km", "kn", "ko", "ks", "ky", "la", "lb", "lt", "lv", "mi", "mk", "ml", "mo", "mr", "ms", "mt", "my", "nb", "ne", "ng", "nl", "nn", "no", "nv", "oc", "om", "or", "pa", "pl", "pt", "qu", "rm", "ro", "ru", "sa", "sb", "sc", "sd", "sg", "si", "sk", "sl", "so", "sq", "sr", "sv", "sw", "sx", "sz", "ta", "te", "th", "tig", "tk", "tlh", "tn", "tr", "ts", "tt", "uk", "ur", "ve", "vi", "vo", "wa", "xh", "zh", "zu"];
-/**
- * Language codes
- * */
-export type LanguageCode = typeof LanguageCodeItems[number];
-/**
- * Locale code items
- * */
-export declare const LocaleCodeItems: readonly ["af", "an", "ar", "ar-ae", "ar-bh", "ar-dz", "ar-eg", "ar-iq", "ar-jo", "ar-kw", "ar-lb", "ar-ly", "ar-ma", "ar-om", "ar-qa", "ar-sa", "ar-sy", "ar-tn", "ar-ye", "as", "ast", "az", "be", "bg", "bn", "br", "bs", "ca", "ce", "ch", "co", "cr", "cs", "cv", "cy", "da", "de", "de-at", "de-ch", "de-de", "de-li", "de-lu", "el", "en", "en-au", "en-bz", "en-ca", "en-gb", "en-ie", "en-jm", "en-nz", "en-ph", "en-tt", "en-us", "en-za", "en-zw", "eo", "es", "es-ar", "es-bo", "es-cl", "es-co", "es-cr", "es-do", "es-ec", "es-es", "es-gt", "es-hn", "es-mx", "es-ni", "es-pa", "es-pe", "es-pr", "es-py", "es-sv", "es-uy", "es-ve", "et", "eu", "fa", "fa-ir", "fi", "fj", "fo", "fr", "fr-be", "fr-ca", "fr-ch", "fr-fr", "fr-lu", "fr-mc", "fur", "fy", "ga", "gd", "gd-ie", "gl", "gu", "he", "hi", "hr", "hsb", "ht", "hu", "hy", "id", "is", "it", "it-ch", "iu", "ja", "ji", "ka", "kk", "km", "kn", "ko", "ko-kp", "ko-kr", "ks", "ky", "la", "lb", "lt", "lv", "mi", "mk", "ml", "mo", "mr", "ms", "mt", "my", "nb", "ne", "ng", "nl", "nl-be", "nn", "no", "nv", "oc", "om", "or", "pa", "pa-in", "pa-pk", "pl", "pt", "pt-br", "qu", "rm", "ro", "ro-mo", "ru", "ru-mo", "sa", "sb", "sc", "sd", "sg", "si", "sk", "sl", "so", "sq", "sr", "sv", "sv-fi", "sv-sv", "sw", "sx", "sz", "ta", "te", "th", "tig", "tk", "tlh", "tn", "tr", "ts", "tt", "uk", "ur", "ve", "vi", "vo", "wa", "xh", "zh", "zh-cn", "zh-hk", "zh-sg", "zh-tw", "zu"];
-/**
- * Locale codes
- *
- * Pattern: [Language Code]-[Country Code]
- * */
-export type LocaleCode = typeof LocaleCodeItems[number];