@aidc-toolkit/core 1.0.23-beta → 1.0.25-beta

package/README.md

@@ -16,6 +16,14 @@ Unless required by applicable law or agreed to in writing, software distributed
 
 The AIDC Toolkit `core` package contains artefacts to support other AIDC Toolkit packages; it does not itself provide any of the functionality of the AIDC Toolkit. It is a required dependency for all AIDC Toolkit packages.
 
+## Types
+
+Generic types that go beyond TypeScript's utility types are defined here. The types are designed to provide even greater type safety.
+
+## Logger
+
+This is a simple wrapper around [tslog](https://tslog.js.org) to support command-line applications in the AIDC Toolkit build process.
+
 ## Internationalization
 
 All AIDC Toolkit packages require internationalization. The localization functionality in this package, built on the robust and popular [`i18next`](https://i18next.com) package, simplifies initialization and allows packages to share a common internationalization engine. Each package, up to and including the client application, is responsible for initializing internationalization for each of the AIDC Toolkit packages on which it depends.
@@ -27,12 +35,12 @@ All AIDC Toolkit packages require internationalization. The localization functio
 Packages install their resources as follows in `i18n.ts` or similar:
 
 ```typescript
-import { i18nAssertValidResources, i18nCoreInit, type I18nEnvironment } from "@aidc-toolkit/core";
+import { i18nCoreInit, type I18nEnvironment } from "@aidc-toolkit/core";
 import { dependency1Resources, i18nDependency1Init } from "@aidc-toolkit/dependency1";
 import { dependency2Resources, i18nDependency2Init } from "@aidc-toolkit/dependency2";
 import i18next, { type i18n, type Resource } from "i18next";
-import { localeStrings as enLocaleStrings } from "./en/locale-strings.js";
-import { localeStrings as frLocaleStrings } from "./fr/locale-strings.js";
+import { localeStrings as enLocaleStrings } from "./en/locale-strings";
+import { localeStrings as frLocaleStrings } from "./fr/locale-strings";
 
 export const packageNS = "aidct_package";
 
@@ -41,8 +49,6 @@ export const packageNS = "aidct_package";
  */
 export type PackageLocaleStrings = typeof enLocaleStrings;
 
-i18nAssertValidResources(enLocaleStrings, "fr", frLocaleStrings);
-
 /**
  * Package resources.
  */
@@ -82,7 +88,7 @@ The resource types are declared in `i18next.d.ts` or similar:
 ```typescript
 import type { Dependency1LocaleStrings } from "@aidc-toolkit/dependency1";
 import type { Dependency2LocaleStrings } from "@aidc-toolkit/dependency2";
-import type { PackageLocaleStrings } from "./i18n.js";
+import type { PackageLocaleStrings } from "./i18n";
 
 /**
  * Internationalization module.
@@ -104,13 +110,13 @@ declare module "i18next" {
 
 Support is available for the following environments:
 
-* [Command-line interface](#command-line-interface)
-    * Unit tests
-    * Batch applications
-* Web server - *NOT YET IMPLEMENTED*
-* [Web browser](#web-browser)
+- [Command-line interface](#command-line-interface)
+  - Unit tests
+  - Batch applications
+- Web server - **NOT YET IMPLEMENTED**
+- [Web browser](#web-browser)
 
-### Command-line interface
+### Command-Line Interface
 
 Initializing internationalization for a command-line interface application is straightforward:
 
@@ -118,14 +124,14 @@ Initializing internationalization for a command-line interface application is st
 await i18nPackageInit(I18nEnvironment.CLI);
 ```
 
-### Web browser
+### Web Browser
 
 Initializing internationalization for a web browser requires awaiting the fulfillment of the `Promise` returned by the call to the initialization function before rendering any content. For example, in the React framework, this may be accomplished with a component like this:
 
 ```typescript jsx
 import { I18nEnvironment } from "@aidc-toolkit/core";
 import { type ReactElement, type ReactNode, useEffect, useState } from "react";
-import { i18nPackageInit, i18nextPackage } from "./locale/i18n.ts";
+import { i18nPackageInit, i18nextPackage } from "./locale/i18n";
 
 /**
  * I18n wrapper properties.
@@ -169,8 +175,8 @@ The component would then wrap the application as follows:
 
 ```typescript jsx
 import { type ReactElement, StrictMode } from "react";
-import { App } from "./App.tsx";
-import { I18n } from "./I18n.tsx";
+import { App } from "./App";
+import { I18n } from "./I18n";
 
 /**
  * Index.

package/dist/index.cjs

@@ -0,0 +1,173 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  I18nEnvironments: () => I18nEnvironments,
+  LogLevels: () => LogLevels,
+  getLogger: () => getLogger,
+  i18nCoreInit: () => i18nCoreInit,
+  isNullish: () => isNullish,
+  omit: () => omit,
+  pick: () => pick,
+  propertyAs: () => propertyAs
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/type-helper.ts
+function omitOrPick(omitting, o, ...keys) {
+  return Object.fromEntries(Object.entries(o).filter(([key]) => keys.includes(key) !== omitting));
+}
+function omit(o, ...keys) {
+  return omitOrPick(true, o, ...keys);
+}
+function pick(o, ...keys) {
+  return omitOrPick(false, o, ...keys);
+}
+function propertyAs(o, key) {
+  return key in o ? {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Force cast.
+    [key]: o[key]
+  } : {};
+}
+function isNullish(argument) {
+  return argument === null || argument === void 0;
+}
+
+// src/logger.ts
+var import_tslog = require("tslog");
+var LogLevels = {
+  Silly: 0,
+  Trace: 1,
+  Debug: 2,
+  Info: 3,
+  Warn: 4,
+  Error: 5,
+  Fatal: 6
+};
+function getLogger(logLevel) {
+  let minLevel;
+  if (typeof logLevel === "string") {
+    if (logLevel in LogLevels) {
+      minLevel = LogLevels[logLevel];
+    } else {
+      throw new Error(`Unknown log level ${logLevel}`);
+    }
+  } else {
+    minLevel = logLevel ?? LogLevels.Info;
+  }
+  return new import_tslog.Logger({
+    minLevel
+  });
+}
+
+// src/locale/i18n.ts
+var import_i18next_browser_languagedetector = __toESM(require("i18next-browser-languagedetector"), 1);
+var import_i18next_cli_language_detector = __toESM(require("i18next-cli-language-detector"), 1);
+var I18nEnvironments = {
+  /**
+   * Command-line interface (e.g., unit tests).
+   */
+  CLI: 0,
+  /**
+   * Web server.
+   */
+  Server: 1,
+  /**
+   * Web browser.
+   */
+  Browser: 2
+};
+function toLowerCase(s) {
+  return s.split(" ").map((word) => /[a-z]/.test(word) ? word.toLowerCase() : word).join(" ");
+}
+async function i18nCoreInit(i18next, environment, debug, defaultNS, ...resources) {
+  if (!i18next.isInitialized) {
+    const mergedResource = {};
+    for (const resource of resources) {
+      for (const [language, resourceLanguage] of Object.entries(resource)) {
+        if (!(language in mergedResource)) {
+          mergedResource[language] = {};
+        }
+        const mergedResourceLanguage = mergedResource[language];
+        for (const [namespace, resourceKey] of Object.entries(resourceLanguage)) {
+          mergedResourceLanguage[namespace] = resourceKey;
+        }
+      }
+    }
+    let module2;
+    switch (environment) {
+      case I18nEnvironments.CLI:
+        module2 = import_i18next_cli_language_detector.default;
+        break;
+      case I18nEnvironments.Browser:
+        module2 = import_i18next_browser_languagedetector.default;
+        break;
+      default:
+        throw new Error("Not supported");
+    }
+    await i18next.use(module2).init({
+      debug,
+      resources: mergedResource,
+      fallbackLng: "en",
+      defaultNS
+    }).then(() => {
+      i18next.services.formatter?.add("toLowerCase", (value) => typeof value === "string" ? toLowerCase(value) : String(value));
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  I18nEnvironments,
+  LogLevels,
+  getLogger,
+  i18nCoreInit,
+  isNullish,
+  omit,
+  pick,
+  propertyAs
+});
+/*!
+ * Copyright © 2024-2025 Dolphin Data Development Ltd. and AIDC Toolkit
+ * contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/type-helper.ts","../src/logger.ts","../src/locale/i18n.ts"],"sourcesContent":["/*!\n * Copyright © 2024-2025 Dolphin Data Development Ltd. and AIDC Toolkit\n * contributors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport type * from \"./type\";\nexport * from \"./type-helper\";\nexport * from \"./logger\";\nexport * from \"./locale/i18n\";\n","/**\n * Create an object with omitted or picked entries.\n *\n * @template Omitting\n * Type representation of `omitting` parameter for return type determination.\n *\n * @template T\n * Object type.\n *\n * @template K\n * Object key type.\n *\n * @param omitting\n * True if omitting.\n *\n * @param o\n * Object.\n *\n * @param keys\n * Keys to omit or pick.\n *\n * @returns\n * Edited object.\n */\nfunction omitOrPick<Omitting extends boolean, T extends object, K extends keyof T>(omitting: Omitting, o: T, ...keys: K[]): Omitting extends true ? Omit<T, K> : Pick<T, K> {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Key and value types are known.\n    return Object.fromEntries(Object.entries(o).filter(([key]) => keys.includes(key as K) !== omitting)) as ReturnType<typeof omitOrPick<Omitting, T, K>>;\n}\n\n/**\n * Create an object with omitted entries.\n *\n * @template T\n * Object type.\n *\n * @template K\n * Object key type.\n *\n * @param o\n * Object.\n *\n * @param keys\n * Keys to omit.\n *\n * @returns\n * Edited object.\n */\nexport function omit<T extends object, K extends keyof T>(o: T, ...keys: K[]): Omit<T, K> {\n    return omitOrPick(true, o, ...keys);\n}\n\n/**\n * Create an object with picked entries.\n *\n * @template T\n * Object type.\n *\n * @template K\n * Object key type.\n *\n * @param o\n * Object.\n *\n * @param keys\n * Keys to pick.\n *\n * @returns\n * Edited object.\n */\nexport function pick<T extends object, K extends keyof T>(o: T, ...keys: K[]): Pick<T, K> {\n    return omitOrPick(false, o, ...keys);\n}\n\n/**\n * Cast a property as a more narrow type.\n *\n * @template T\n * Object type.\n *\n * @template K\n * Object key type.\n *\n * @template TAsType\n * Desired type.\n *\n * @param o\n * Object.\n *\n * @param key\n * Key of property to cast.\n *\n * @returns\n * Single-key object with property cast as desired type.\n */\nexport function propertyAs<T extends object, K extends keyof T, TAsType extends T[K]>(o: T, key: K): Readonly<Omit<T, K> extends T ? Partial<Record<K, TAsType>> : Record<K, TAsType>> {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type is determined by condition.\n    return (key in o ?\n        {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Force cast.\n            [key]: o[key] as TAsType\n        } :\n        {}\n    ) as ReturnType<typeof propertyAs<T, K, TAsType>>;\n}\n\n/**\n * Determine if argument is nullish. Application extension may pass `null` or `undefined` to missing parameters.\n *\n * @param argument\n * Argument.\n *\n * @returns\n * True if argument is undefined or null.\n */\nexport function isNullish(argument: unknown): argument is null | undefined {\n    return argument === null || argument === undefined;\n}\n","import { Logger } from \"tslog\";\n\n/**\n * Log levels.\n */\nexport const LogLevels = {\n    Silly: 0,\n    Trace: 1,\n    Debug: 2,\n    Info: 3,\n    Warn: 4,\n    Error: 5,\n    Fatal: 6\n} as const;\n\n/**\n * Log level key.\n */\nexport type LogLevelKey = keyof typeof LogLevels;\n\n/**\n * Log level.\n */\nexport type LogLevel = typeof LogLevels[LogLevelKey];\n\n/**\n * Get a simple logger with an optional log level.\n *\n * @param logLevel\n * Log level as enumeration value or string.\n *\n * @returns\n * Logger.\n */\nexport function getLogger(logLevel?: string | number): Logger<unknown> {\n    let minLevel: number;\n\n    if (typeof logLevel === \"string\") {\n        if (logLevel in LogLevels) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- String exists as a key.\n            minLevel = LogLevels[logLevel as LogLevelKey];\n        } else {\n            throw new Error(`Unknown log level ${logLevel}`);\n        }\n    } else {\n        minLevel = logLevel ?? LogLevels.Info;\n    }\n\n    return new Logger({\n        minLevel\n    });\n}\n","import type { i18n, LanguageDetectorModule, Resource } from \"i18next\";\nimport I18nextBrowserLanguageDetector from \"i18next-browser-languagedetector\";\nimport I18nextCLILanguageDetector from \"i18next-cli-language-detector\";\n\n/**\n * Locale strings type for generic manipulation.\n */\nexport interface LocaleResources {\n    [key: string]: LocaleResources | string;\n}\n\n/**\n * Internationalization operating environments.\n */\nexport const I18nEnvironments = {\n    /**\n     * Command-line interface (e.g., unit tests).\n     */\n    CLI: 0,\n\n    /**\n     * Web server.\n     */\n    Server: 1,\n\n    /**\n     * Web browser.\n     */\n    Browser: 2\n} as const;\n\n/**\n * Internationalization operating environment key.\n */\nexport type I18nEnvironmentKey = keyof typeof I18nEnvironments;\n\n/**\n * Internationalization operating environment.\n */\nexport type I18nEnvironment = typeof I18nEnvironments[I18nEnvironmentKey];\n\n/**\n * Convert a string to lower case, skipping words that are all upper case.\n *\n * @param s\n * String.\n *\n * @returns\n * Lower case string.\n */\nfunction toLowerCase(s: string): string {\n    // Words with no lower case letters are preserved as they are likely mnemonics.\n    return s.split(\" \").map(word => /[a-z]/.test(word) ? word.toLowerCase() : word).join(\" \");\n}\n\n/**\n * Initialize internationalization.\n *\n * @param i18next\n * Internationalization object. As multiple objects exists, this parameter represents the one for the module for which\n * internationalization is being initialized.\n *\n * @param environment\n * Environment in which the application is running.\n *\n * @param debug\n * Debug setting.\n *\n * @param defaultNS\n * Default namespace.\n *\n * @param resources\n * Resources.\n *\n * @returns\n * Void promise.\n */\nexport async function i18nCoreInit(i18next: i18n, environment: I18nEnvironment, debug: boolean, defaultNS: string, ...resources: Resource[]): Promise<void> {\n    // Initialization may be called more than once.\n    if (!i18next.isInitialized) {\n        const mergedResource: Resource = {};\n\n        // Merge resources.\n        for (const resource of resources) {\n            // Merge languages.\n            for (const [language, resourceLanguage] of Object.entries(resource)) {\n                if (!(language in mergedResource)) {\n                    mergedResource[language] = {};\n                }\n\n                const mergedResourceLanguage = mergedResource[language];\n\n                // Merge namespaces.\n                for (const [namespace, resourceKey] of Object.entries(resourceLanguage)) {\n                    mergedResourceLanguage[namespace] = resourceKey;\n                }\n            }\n        }\n\n        let module: Parameters<typeof i18next.use>[0];\n\n        switch (environment) {\n            case I18nEnvironments.CLI:\n                // TODO Refactor when https://github.com/neet/i18next-cli-language-detector/issues/281 resolved.\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Per above.\n                module = I18nextCLILanguageDetector as unknown as LanguageDetectorModule;\n                break;\n\n            case I18nEnvironments.Browser:\n                module = I18nextBrowserLanguageDetector;\n                break;\n\n            default:\n                throw new Error(\"Not supported\");\n        }\n\n        await i18next.use(module).init({\n            debug,\n            resources: mergedResource,\n            fallbackLng: \"en\",\n            defaultNS\n        }).then(() => {\n            // Add toLowerCase function.\n            i18next.services.formatter?.add(\"toLowerCase\", value => typeof value === \"string\" ? toLowerCase(value) : String(value));\n        });\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACwBA,SAAS,WAA0E,UAAoB,MAAS,MAA4D;AAExK,SAAO,OAAO,YAAY,OAAO,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,KAAK,SAAS,GAAQ,MAAM,QAAQ,CAAC;AACvG;AAoBO,SAAS,KAA0C,MAAS,MAAuB;AACtF,SAAO,WAAW,MAAM,GAAG,GAAG,IAAI;AACtC;AAoBO,SAAS,KAA0C,MAAS,MAAuB;AACtF,SAAO,WAAW,OAAO,GAAG,GAAG,IAAI;AACvC;AAuBO,SAAS,WAAsE,GAAM,KAA2F;AAEnL,SAAQ,OAAO,IACX;AAAA;AAAA,IAEI,CAAC,GAAG,GAAG,EAAE,GAAG;AAAA,EAChB,IACA,CAAC;AAET;AAWO,SAAS,UAAU,UAAiD;AACvE,SAAO,aAAa,QAAQ,aAAa;AAC7C;;;ACpHA,mBAAuB;AAKhB,IAAM,YAAY;AAAA,EACrB,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AAAA,EACP,OAAO;AACX;AAqBO,SAAS,UAAU,UAA6C;AACnE,MAAI;AAEJ,MAAI,OAAO,aAAa,UAAU;AAC9B,QAAI,YAAY,WAAW;AAEvB,iBAAW,UAAU,QAAuB;AAAA,IAChD,OAAO;AACH,YAAM,IAAI,MAAM,qBAAqB,QAAQ,EAAE;AAAA,IACnD;AAAA,EACJ,OAAO;AACH,eAAW,YAAY,UAAU;AAAA,EACrC;AAEA,SAAO,IAAI,oBAAO;AAAA,IACd;AAAA,EACJ,CAAC;AACL;;;AClDA,8CAA2C;AAC3C,2CAAuC;AAYhC,IAAM,mBAAmB;AAAA;AAAA;AAAA;AAAA,EAI5B,KAAK;AAAA;AAAA;AAAA;AAAA,EAKL,QAAQ;AAAA;AAAA;AAAA;AAAA,EAKR,SAAS;AACb;AAqBA,SAAS,YAAY,GAAmB;AAEpC,SAAO,EAAE,MAAM,GAAG,EAAE,IAAI,UAAQ,QAAQ,KAAK,IAAI,IAAI,KAAK,YAAY,IAAI,IAAI,EAAE,KAAK,GAAG;AAC5F;AAwBA,eAAsB,aAAa,SAAe,aAA8B,OAAgB,cAAsB,WAAsC;AAExJ,MAAI,CAAC,QAAQ,eAAe;AACxB,UAAM,iBAA2B,CAAC;AAGlC,eAAW,YAAY,WAAW;AAE9B,iBAAW,CAAC,UAAU,gBAAgB,KAAK,OAAO,QAAQ,QAAQ,GAAG;AACjE,YAAI,EAAE,YAAY,iBAAiB;AAC/B,yBAAe,QAAQ,IAAI,CAAC;AAAA,QAChC;AAEA,cAAM,yBAAyB,eAAe,QAAQ;AAGtD,mBAAW,CAAC,WAAW,WAAW,KAAK,OAAO,QAAQ,gBAAgB,GAAG;AACrE,iCAAuB,SAAS,IAAI;AAAA,QACxC;AAAA,MACJ;AAAA,IACJ;AAEA,QAAIA;AAEJ,YAAQ,aAAa;AAAA,MACjB,KAAK,iBAAiB;AAGlB,QAAAA,UAAS,qCAAAC;AACT;AAAA,MAEJ,KAAK,iBAAiB;AAClB,QAAAD,UAAS,wCAAAE;AACT;AAAA,MAEJ;AACI,cAAM,IAAI,MAAM,eAAe;AAAA,IACvC;AAEA,UAAM,QAAQ,IAAIF,OAAM,EAAE,KAAK;AAAA,MAC3B;AAAA,MACA,WAAW;AAAA,MACX,aAAa;AAAA,MACb;AAAA,IACJ,CAAC,EAAE,KAAK,MAAM;AAEV,cAAQ,SAAS,WAAW,IAAI,eAAe,WAAS,OAAO,UAAU,WAAW,YAAY,KAAK,IAAI,OAAO,KAAK,CAAC;AAAA,IAC1H,CAAC;AAAA,EACL;AACJ;","names":["module","I18nextCLILanguageDetector","I18nextBrowserLanguageDetector"]}

package/dist/index.d.cts

@@ -0,0 +1,230 @@
+import { Logger } from 'tslog';
+import { i18n, Resource } from 'i18next';
+
+/**
+ * Typed function, applicable to any function, stricter than {@linkcode Function}.
+ *
+ * @template TFunction
+ * Function type.
+ */
+type TypedFunction<TFunction extends (...args: Parameters<TFunction>) => ReturnType<TFunction>> = (...args: Parameters<TFunction>) => ReturnType<TFunction>;
+/**
+ * Typed synchronous function, applicable to any function that doesn't return a {@linkcode Promise}.
+ *
+ * @template TFunction
+ * Function type.
+ */
+type TypedSyncFunction<TFunction extends TypedFunction<TFunction>> = [ReturnType<TFunction>] extends [PromiseLike<unknown>] ? never : TypedFunction<TFunction>;
+/**
+ * Determine the fundamental promised type. This is stricter than `Awaited<Type>` in that it requires a {@linkcode
+ * Promise}.
+ *
+ * @template T
+ * Promised type.
+ */
+type PromisedType<T> = [T] extends [PromiseLike<infer TPromised>] ? TPromised : never;
+/**
+ * Typed asynchronous function, applicable to any function that returns a {@linkcode Promise}.
+ *
+ * @template TFunction
+ * Function type.
+ */
+type TypedAsyncFunction<TMethod extends (...args: Parameters<TMethod>) => PromiseLike<PromisedType<ReturnType<TMethod>>>> = (...args: Parameters<TMethod>) => Promise<PromisedType<ReturnType<TMethod>>>;
+/**
+ * Nullishable type. Extends a type by allowing `null` and `undefined`.
+ *
+ * @template T
+ * Type.
+ */
+type Nullishable<T> = T | null | undefined;
+/**
+ * Non-nullishable type. If T is an object type, it is spread and attributes within it are made non-nullishable.
+ * Equivalent to a deep `Required<T>` for an object and `NonNullable<T>` for any other type.
+ *
+ * @template T
+ * Type.
+ */
+type NonNullishable<T> = T extends object ? {
+    [P in keyof T]-?: NonNullishable<T[P]>;
+} : NonNullable<T>;
+/**
+ * Make some keys within a type optional.
+ *
+ * @template T
+ * Object type.
+ *
+ * @template K
+ * Object key type.
+ */
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Type to restrict property keys to those that are strings and that support a specified type.
+ *
+ * @template T
+ * Object type.
+ *
+ * @template P
+ * Object property type.
+ */
+type PropertyKeys<T, P> = {
+    [K in keyof T]: K extends string ? T[K] extends P ? K : never : never;
+}[keyof T];
+
+/**
+ * Create an object with omitted entries.
+ *
+ * @template T
+ * Object type.
+ *
+ * @template K
+ * Object key type.
+ *
+ * @param o
+ * Object.
+ *
+ * @param keys
+ * Keys to omit.
+ *
+ * @returns
+ * Edited object.
+ */
+declare function omit<T extends object, K extends keyof T>(o: T, ...keys: K[]): Omit<T, K>;
+/**
+ * Create an object with picked entries.
+ *
+ * @template T
+ * Object type.
+ *
+ * @template K
+ * Object key type.
+ *
+ * @param o
+ * Object.
+ *
+ * @param keys
+ * Keys to pick.
+ *
+ * @returns
+ * Edited object.
+ */
+declare function pick<T extends object, K extends keyof T>(o: T, ...keys: K[]): Pick<T, K>;
+/**
+ * Cast a property as a more narrow type.
+ *
+ * @template T
+ * Object type.
+ *
+ * @template K
+ * Object key type.
+ *
+ * @template TAsType
+ * Desired type.
+ *
+ * @param o
+ * Object.
+ *
+ * @param key
+ * Key of property to cast.
+ *
+ * @returns
+ * Single-key object with property cast as desired type.
+ */
+declare function propertyAs<T extends object, K extends keyof T, TAsType extends T[K]>(o: T, key: K): Readonly<Omit<T, K> extends T ? Partial<Record<K, TAsType>> : Record<K, TAsType>>;
+/**
+ * Determine if argument is nullish. Application extension may pass `null` or `undefined` to missing parameters.
+ *
+ * @param argument
+ * Argument.
+ *
+ * @returns
+ * True if argument is undefined or null.
+ */
+declare function isNullish(argument: unknown): argument is null | undefined;
+
+/**
+ * Log levels.
+ */
+declare const LogLevels: {
+    readonly Silly: 0;
+    readonly Trace: 1;
+    readonly Debug: 2;
+    readonly Info: 3;
+    readonly Warn: 4;
+    readonly Error: 5;
+    readonly Fatal: 6;
+};
+/**
+ * Log level key.
+ */
+type LogLevelKey = keyof typeof LogLevels;
+/**
+ * Log level.
+ */
+type LogLevel = typeof LogLevels[LogLevelKey];
+/**
+ * Get a simple logger with an optional log level.
+ *
+ * @param logLevel
+ * Log level as enumeration value or string.
+ *
+ * @returns
+ * Logger.
+ */
+declare function getLogger(logLevel?: string | number): Logger<unknown>;
+
+/**
+ * Locale strings type for generic manipulation.
+ */
+interface LocaleResources {
+    [key: string]: LocaleResources | string;
+}
+/**
+ * Internationalization operating environments.
+ */
+declare const I18nEnvironments: {
+    /**
+     * Command-line interface (e.g., unit tests).
+     */
+    readonly CLI: 0;
+    /**
+     * Web server.
+     */
+    readonly Server: 1;
+    /**
+     * Web browser.
+     */
+    readonly Browser: 2;
+};
+/**
+ * Internationalization operating environment key.
+ */
+type I18nEnvironmentKey = keyof typeof I18nEnvironments;
+/**
+ * Internationalization operating environment.
+ */
+type I18nEnvironment = typeof I18nEnvironments[I18nEnvironmentKey];
+/**
+ * Initialize internationalization.
+ *
+ * @param i18next
+ * Internationalization object. As multiple objects exists, this parameter represents the one for the module for which
+ * internationalization is being initialized.
+ *
+ * @param environment
+ * Environment in which the application is running.
+ *
+ * @param debug
+ * Debug setting.
+ *
+ * @param defaultNS
+ * Default namespace.
+ *
+ * @param resources
+ * Resources.
+ *
+ * @returns
+ * Void promise.
+ */
+declare function i18nCoreInit(i18next: i18n, environment: I18nEnvironment, debug: boolean, defaultNS: string, ...resources: Resource[]): Promise<void>;
+
+export { type I18nEnvironment, type I18nEnvironmentKey, I18nEnvironments, type LocaleResources, type LogLevel, type LogLevelKey, LogLevels, type NonNullishable, type Nullishable, type Optional, type PromisedType, type PropertyKeys, type TypedAsyncFunction, type TypedFunction, type TypedSyncFunction, getLogger, i18nCoreInit, isNullish, omit, pick, propertyAs };