@aidc-toolkit/gs1 0.9.7-beta → 0.9.8-beta

package/dist/index.d.cts

@@ -1,7 +1,646 @@
+import { $NormalizeIntoArray, $Dictionary } from './typescript/helpers.js';
+import { DefaultNamespace, FlatNamespace, InitOptions, Namespace, FormatFunction, Resource, TOptions, InterpolationOptions, ResourceLanguage, ResourceKey } from './typescript/options.js';
+import { TFunction, KeyPrefix } from './typescript/t.js';
+import { I18NEnvironment } from '@aidc-toolkit/core';
 import { CharacterSetCreator, StringValidation, StringValidator, CharacterSetValidation, Exclusion, TransformerInput, TransformerOutput } from '@aidc-toolkit/utility';
 import * as ts_mixer_dist_types_types_js from 'ts-mixer/dist/types/types.js';
 
+// Internal Helpers
+
+
+interface Interpolator {
+  init(options: InterpolationOptions, reset: boolean): undefined;
+  reset(): undefined;
+  resetRegExp(): undefined;
+  interpolate(str: string, data: object, lng: string, options: InterpolationOptions): string;
+  nest(str: string, fc: (...args: any[]) => any, options: InterpolationOptions): string;
+}
+
+declare class ResourceStore {
+  constructor(data: Resource, options: InitOptions);
+
+  public data: Resource;
+
+  public options: InitOptions;
+
+  /**
+   * Gets fired when resources got added or removed
+   */
+  on(event: 'added' | 'removed', callback: (lng: string, ns: string) => void): void;
+
+  /**
+   * Remove event listener
+   * removes all callback when callback not specified
+   */
+  off(event: 'added' | 'removed', callback?: (lng: string, ns: string) => void): void;
+}
+
+interface Formatter {
+  init(services: Services, i18nextOptions: InitOptions): void;
+  add(name: string, fc: (value: any, lng: string | undefined, options: any) => string): void;
+  addCached(
+    name: string,
+    fc: (lng: string | undefined, options: any) => (value: any) => string,
+  ): void;
+  format: FormatFunction;
+}
+
+interface Services {
+  backendConnector: any;
+  i18nFormat: any;
+  interpolator: Interpolator;
+  languageDetector: any;
+  languageUtils: any;
+  logger: any;
+  pluralResolver: any;
+  resourceStore: ResourceStore;
+  formatter?: Formatter;
+}
+
+type ModuleType =
+  | 'backend'
+  | 'logger'
+  | 'languageDetector'
+  | 'postProcessor'
+  | 'i18nFormat'
+  | 'formatter'
+  | '3rdParty';
+
+interface Module {
+  type: ModuleType;
+}
+
+type CallbackError = Error | string | null | undefined;
+type ReadCallback = (
+  err: CallbackError,
+  data: ResourceKey | boolean | null | undefined,
+) => void;
+type MultiReadCallback = (err: CallbackError, data: Resource | null | undefined) => void;
+
+/**
+ * Used to load data for i18next.
+ * Can be provided as a singleton or as a prototype constructor (preferred for supporting multiple instances of i18next).
+ * For singleton set property `type` to `'backend'` For a prototype constructor set static property.
+ */
+interface BackendModule<Options = object> extends Module {
+  type: 'backend';
+  init(services: Services, backendOptions: Options, i18nextOptions: InitOptions): void;
+  read(language: string, namespace: string, callback: ReadCallback): void;
+  /** Save the missing translation */
+  create?(
+    languages: readonly string[],
+    namespace: string,
+    key: string,
+    fallbackValue: string,
+  ): void;
+  /** Load multiple languages and namespaces. For backends supporting multiple resources loading */
+  readMulti?(
+    languages: readonly string[],
+    namespaces: readonly string[],
+    callback: MultiReadCallback,
+  ): void;
+  /** Store the translation. For backends acting as cache layer */
+  save?(language: string, namespace: string, data: ResourceLanguage): void;
+}
+
+/**
+ * Used to detect language in user land.
+ * Can be provided as a singleton or as a prototype constructor (preferred for supporting multiple instances of i18next).
+ * For singleton set property `type` to `'languageDetector'` For a prototype constructor set static property.
+ */
+interface LanguageDetectorModule extends Module {
+  type: 'languageDetector';
+  init?(services: Services, detectorOptions: object, i18nextOptions: InitOptions): void;
+  /** Must return detected language */
+  detect(): string | readonly string[] | undefined;
+  cacheUserLanguage?(lng: string): void;
+}
+
+/**
+ * Used to detect language in user land.
+ * Can be provided as a singleton or as a prototype constructor (preferred for supporting multiple instances of i18next).
+ * For singleton set property `type` to `'languageDetector'` For a prototype constructor set static property.
+ */
+interface LanguageDetectorAsyncModule extends Module {
+  type: 'languageDetector';
+  /** Set to true to enable async detection */
+  async: true;
+  init?(services: Services, detectorOptions: object, i18nextOptions: InitOptions): void;
+  /** Must call callback passing detected language or return a Promise */
+  detect(
+    callback: (lng: string | readonly string[] | undefined) => void | undefined,
+  ): void | Promise<string | readonly string[] | undefined>;
+  cacheUserLanguage?(lng: string): void | Promise<void>;
+}
+
+/**
+ * Override the built-in console logger.
+ * Do not need to be a prototype function.
+ */
+interface LoggerModule extends Module {
+  type: 'logger';
+  log(...args: any[]): void;
+  warn(...args: any[]): void;
+  error(...args: any[]): void;
+}
+
+interface I18nFormatModule extends Module {
+  type: 'i18nFormat';
+}
+
+interface FormatterModule extends Module, Formatter {
+  type: 'formatter';
+}
+
+interface ThirdPartyModule extends Module {
+  type: '3rdParty';
+  init(i18next: i18n): void;
+}
+
+interface Modules {
+  backend?: BackendModule;
+  logger?: LoggerModule;
+  languageDetector?: LanguageDetectorModule | LanguageDetectorAsyncModule;
+  i18nFormat?: I18nFormatModule;
+  formatter?: FormatterModule;
+  external: ThirdPartyModule[];
+}
+
+// helper to identify class https://stackoverflow.com/a/45983481/2363935
+interface Newable<T> {
+  new (...args: any[]): T;
+}
+interface NewableModule<T extends Module> extends Newable<T> {
+  type: T['type'];
+}
+
+type Callback = (error: any, t: TFunction) => void;
+
+/**
+ * Uses similar args as the t function and returns true if a key exists.
+ */
+interface ExistsFunction<
+  TKeys extends string = string,
+  TInterpolationMap extends object = $Dictionary,
+> {
+  (key: TKeys | TKeys[], options?: TOptions<TInterpolationMap>): boolean;
+}
+
+interface CloneOptions extends InitOptions {
+  /**
+   * Will create a new instance of the resource store and import the existing translation resources.
+   * This way it will not shared the resource store instance.
+   * @default false
+   */
+  forkResourceStore?: boolean;
+}
+
+interface CustomInstanceExtensions {}
+
+// Used just here to exclude `DefaultNamespace` which can be both string or array from `FlatNamespace`
+// in TFunction declaration below.
+// Due to this only very special usage I'm not moving this inside helpers.
+type InferArrayValuesElseReturnType<T> = T extends (infer A)[] ? A : T;
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+interface i18n extends CustomInstanceExtensions {
+  // Expose parameterized t in the i18next interface hierarchy
+  t: TFunction<
+    [
+      ...$NormalizeIntoArray<DefaultNamespace>,
+      ...Exclude<FlatNamespace, InferArrayValuesElseReturnType<DefaultNamespace>>[],
+    ]
+  >;
+
+  /**
+   * The default of the i18next module is an i18next instance ready to be initialized by calling init.
+   * You can create additional instances using the createInstance function.
+   *
+   * @param options - Initial options.
+   * @param callback - will be called after all translations were loaded or with an error when failed (in case of using a backend).
+   */
+  init(callback?: Callback): Promise<TFunction>;
+  init<T>(options: InitOptions<T>, callback?: Callback): Promise<TFunction>;
+
+  loadResources(callback?: (err: any) => void): void;
+
+  /**
+   * The use function is there to load additional plugins to i18next.
+   * For available module see the plugins page and don't forget to read the documentation of the plugin.
+   *
+   * @param module Accepts a class or object
+   */
+  use<T extends Module>(module: T | NewableModule<T> | Newable<T>): this;
+
+  /**
+   * List of modules used
+   */
+  modules: Modules;
+
+  /**
+   * Internal container for all used plugins and implementation details like languageUtils, pluralResolvers, etc.
+   */
+  services: Services;
+
+  /**
+   * Internal container for translation resources
+   */
+  store: ResourceStore;
+
+  /**
+   * Uses similar args as the t function and returns true if a key exists.
+   */
+  exists: ExistsFunction;
+
+  /**
+   * Returns a resource data by language.
+   */
+  getDataByLanguage(lng: string): { [key: string]: { [key: string]: string } } | undefined;
+
+  /**
+   * Returns a t function that defaults to given language or namespace.
+   * Both params could be arrays of languages or namespaces and will be treated as fallbacks in that case.
+   * On the returned function you can like in the t function override the languages or namespaces by passing them in options or by prepending namespace.
+   *
+   * Accepts optional keyPrefix that will be automatically applied to returned t function.
+   */
+  getFixedT<
+    Ns extends Namespace | null = DefaultNamespace,
+    TKPrefix extends KeyPrefix<ActualNs> = undefined,
+    ActualNs extends Namespace = Ns extends null ? DefaultNamespace : Ns,
+  >(
+    ...args:
+      | [lng: string | readonly string[], ns?: Ns, keyPrefix?: TKPrefix]
+      | [lng: null, ns: Ns, keyPrefix?: TKPrefix]
+  ): TFunction<ActualNs, TKPrefix>;
+
+  /**
+   * Changes the language. The callback will be called as soon translations were loaded or an error occurs while loading.
+   * HINT: For easy testing - setting lng to 'cimode' will set t function to always return the key.
+   */
+  changeLanguage(lng?: string, callback?: Callback): Promise<TFunction>;
+
+  /**
+   * Is set to the current detected or set language.
+   * If you need the primary used language depending on your configuration (supportedLngs, load) you will prefer using i18next.languages[0].
+   */
+  language: string;
+
+  /**
+   * Is set to an array of language-codes that will be used it order to lookup the translation value.
+   */
+  languages: readonly string[];
+
+  /**
+   * Is set to the current resolved language.
+   * It can be used as primary used language, for example in a language switcher.
+   */
+  resolvedLanguage?: string;
+
+  /**
+   * Checks if namespace has loaded yet.
+   * i.e. used by react-i18next
+   */
+  hasLoadedNamespace(
+    ns: string | readonly string[],
+    options?: {
+      lng?: string | readonly string[];
+      fallbackLng?: InitOptions['fallbackLng'];
+      /**
+       * if `undefined` is returned default checks are performed.
+       */
+      precheck?: (
+        i18n: i18n,
+        /**
+         * Check if the language namespace provided are not in loading status:
+         * returns `true` if load is completed successfully or with an error.
+         */
+        loadNotPending: (
+          lng: string | readonly string[],
+          ns: string | readonly string[],
+        ) => boolean,
+      ) => boolean | undefined;
+    },
+  ): boolean;
+
+  /**
+   * Loads additional namespaces not defined in init options.
+   */
+  loadNamespaces(ns: string | readonly string[], callback?: Callback): Promise<void>;
+
+  /**
+   * Loads additional languages not defined in init options (preload).
+   */
+  loadLanguages(lngs: string | readonly string[], callback?: Callback): Promise<void>;
+
+  /**
+   * Reloads resources on given state. Optionally you can pass an array of languages and namespaces as params if you don't want to reload all.
+   */
+  reloadResources(
+    lngs?: string | readonly string[],
+    ns?: string | readonly string[],
+    callback?: () => void,
+  ): Promise<void>;
+  reloadResources(lngs: null, ns: string | readonly string[], callback?: () => void): Promise<void>;
+
+  /**
+   * Changes the default namespace.
+   */
+  setDefaultNamespace(ns: string | readonly string[]): void;
+
+  /**
+   * Returns rtl or ltr depending on languages read direction.
+   */
+  dir(lng?: string): 'ltr' | 'rtl';
+
+  /**
+   * Exposes interpolation.format function added on init.
+   */
+  format: FormatFunction;
+
+  /**
+   * Will return a new i18next instance.
+   * Please read the options page for details on configuration options.
+   * Providing a callback will automatically call init.
+   * The callback will be called after all translations were loaded or with an error when failed (in case of using a backend).
+   */
+  createInstance(options?: InitOptions, callback?: Callback): i18n;
+
+  /**
+   * Creates a clone of the current instance. Shares store, plugins and initial configuration.
+   * Can be used to create an instance sharing storage but being independent on set language or namespaces.
+   */
+  cloneInstance(options?: CloneOptions, callback?: Callback): i18n;
+
+  /**
+   * Gets fired after initialization.
+   */
+  on(event: 'initialized', callback: (options: InitOptions) => void): void;
+
+  /**
+   * Gets fired on loaded resources.
+   */
+  on(
+    event: 'loaded',
+    callback: (loaded: { [language: string]: { [namespace: string]: boolean } }) => void,
+  ): void;
+
+  /**
+   * Gets fired if loading resources failed.
+   */
+  on(event: 'failedLoading', callback: (lng: string, ns: string, msg: string) => void): void;
+
+  /**
+   * Gets fired on accessing a key not existing.
+   */
+  on(
+    event: 'missingKey',
+    callback: (lngs: readonly string[], namespace: string, key: string, res: string) => void,
+  ): void;
+
+  /**
+   * Gets fired when resources got added or removed.
+   */
+  on(event: 'added' | 'removed', callback: (lng: string, ns: string) => void): void;
+
+  /**
+   * Gets fired when changeLanguage got called.
+   */
+  on(event: 'languageChanged', callback: (lng: string) => void): void;
+
+  /**
+   * Event listener
+   */
+  on(event: string, listener: (...args: any[]) => void): void;
+
+  /**
+   * Remove event listener
+   * removes all callback when callback not specified
+   */
+  off(event: string, listener?: (...args: any[]) => void): void;
+
+  /**
+   * Gets one value by given key.
+   */
+  getResource(
+    lng: string,
+    ns: string,
+    key: string,
+    options?: Pick<InitOptions, 'keySeparator' | 'ignoreJSONStructure'>,
+  ): any;
+
+  /**
+   * Adds one key/value.
+   */
+  addResource(
+    lng: string,
+    ns: string,
+    key: string,
+    value: string,
+    options?: { keySeparator?: string; silent?: boolean },
+  ): i18n;
+
+  /**
+   * Adds multiple key/values.
+   */
+  addResources(lng: string, ns: string, resources: any): i18n;
+
+  /**
+   * Adds a complete bundle.
+   * Setting deep param to true will extend existing translations in that file.
+   * Setting overwrite to true it will overwrite existing translations in that file.
+   */
+  addResourceBundle(
+    lng: string,
+    ns: string,
+    resources: any,
+    deep?: boolean,
+    overwrite?: boolean,
+  ): i18n;
+
+  /**
+   * Checks if a resource bundle exists.
+   */
+  hasResourceBundle(lng: string, ns: string): boolean;
+
+  /**
+   * Returns a resource bundle.
+   */
+  getResourceBundle(lng: string, ns: string): any;
+
+  /**
+   * Removes an existing bundle.
+   */
+  removeResourceBundle(lng: string, ns: string): i18n;
+
+  /**
+   * Current options
+   */
+  options: InitOptions;
+
+  /**
+   * Is initialized
+   */
+  isInitialized: boolean;
+
+  /**
+   * Is initializing
+   */
+  isInitializing: boolean;
+
+  /**
+   * Store was initialized
+   */
+  initializedStoreOnce: boolean;
+
+  /**
+   * Language was initialized
+   */
+  initializedLanguageOnce: boolean;
+
+  /**
+   * Emit event
+   */
+  emit(eventName: string, ...args: any[]): void;
+}
+
+declare const localeStrings: {
+    readonly Check: {
+        readonly lengthOfStringForPriceOrWeightMustBeExactly: "Length {{length}} of string for price or weight sum must be exactly {{exactLength}}";
+        readonly priceOrWeightComponent: "price or weight";
+        readonly lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "Length {{length}} of string for check character pair must be less than or equal to {{maximumLength}}";
+    };
+    readonly IdentificationKey: {
+        readonly identificationKeyTypeLength: "{{identificationKeyType}} must be {{length}} digits long";
+        readonly invalidCheckDigit: "Invalid check digit";
+        readonly invalidGTINLength: "GTIN must be 13, 12, 8, or 14 digits long";
+        readonly invalidGTIN14Length: "GTIN must be 14 digits long";
+        readonly invalidZeroSuppressedGTIN12: "Invalid zero-suppressed GTIN-12";
+        readonly invalidZeroSuppressibleGTIN12: "GTIN-12 not zero-suppressible";
+        readonly invalidZeroSuppressedGTIN12AsGTIN13: "Invalid zero-suppressed GTIN-12 as GTIN-13";
+        readonly invalidZeroSuppressedGTIN12AsGTIN14: "Invalid zero-suppressed GTIN-12 as GTIN-14";
+        readonly invalidGTIN13AtRetail: "GTIN-13 at retail consumer trade item level can't start with zero";
+        readonly invalidGTINAtRetail: "GTIN not supported at retail consumer trade item level";
+        readonly invalidGTINAtOtherThanRetail: "GTIN not supported at other than retail consumer trade item level";
+        readonly indicatorDigit: "indicator digit";
+        readonly serialComponent: "serial component";
+        readonly reference: "reference";
+        readonly referenceCantBeAllNumeric: "Reference can't be all-numeric";
+        readonly invalidCheckCharacterPair: "Invalid check character pair";
+    };
+    readonly Prefix: {
+        readonly gs1CompanyPrefix: "GS1 Company Prefix";
+        readonly upcCompanyPrefix: "U.P.C. Company Prefix";
+        readonly gs18Prefix: "GS1-8 Prefix";
+        readonly gs1CompanyPrefixCantStartWith0: "GS1 Company Prefix can't start with \"0\"";
+        readonly gs1CompanyPrefixCantStartWith00000: "GS1 Company Prefix can't start with \"00000\"";
+        readonly gs1CompanyPrefixCantStartWith000000: "GS1 Company Prefix can't start with \"000000\"";
+        readonly upcCompanyPrefixCantStartWith0000: "U.P.C. Company Prefix can't start with \"0000\"";
+        readonly gs18PrefixCantStartWith0: "GS1-8 Prefix can't start with \"0\"";
+        readonly identificationKeyTypeNotSupportedByGS18Prefix: "{{identificationKeyType}} not supported by GS1-8 Prefix";
+    };
+};
+
 declare const gs1NS = "aidct_gs1";
+/**
+ * Locale strings type is extracted from the English locale strings object.
+ */
+type GS1LocaleStrings = typeof localeStrings;
+/**
+ * GS1 resources.
+ */
+declare const gs1Resources: {
+    en: {
+        aidct_gs1: {
+            readonly Check: {
+                readonly lengthOfStringForPriceOrWeightMustBeExactly: "Length {{length}} of string for price or weight sum must be exactly {{exactLength}}";
+                readonly priceOrWeightComponent: "price or weight";
+                readonly lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "Length {{length}} of string for check character pair must be less than or equal to {{maximumLength}}";
+            };
+            readonly IdentificationKey: {
+                readonly identificationKeyTypeLength: "{{identificationKeyType}} must be {{length}} digits long";
+                readonly invalidCheckDigit: "Invalid check digit";
+                readonly invalidGTINLength: "GTIN must be 13, 12, 8, or 14 digits long";
+                readonly invalidGTIN14Length: "GTIN must be 14 digits long";
+                readonly invalidZeroSuppressedGTIN12: "Invalid zero-suppressed GTIN-12";
+                readonly invalidZeroSuppressibleGTIN12: "GTIN-12 not zero-suppressible";
+                readonly invalidZeroSuppressedGTIN12AsGTIN13: "Invalid zero-suppressed GTIN-12 as GTIN-13";
+                readonly invalidZeroSuppressedGTIN12AsGTIN14: "Invalid zero-suppressed GTIN-12 as GTIN-14";
+                readonly invalidGTIN13AtRetail: "GTIN-13 at retail consumer trade item level can't start with zero";
+                readonly invalidGTINAtRetail: "GTIN not supported at retail consumer trade item level";
+                readonly invalidGTINAtOtherThanRetail: "GTIN not supported at other than retail consumer trade item level";
+                readonly indicatorDigit: "indicator digit";
+                readonly serialComponent: "serial component";
+                readonly reference: "reference";
+                readonly referenceCantBeAllNumeric: "Reference can't be all-numeric";
+                readonly invalidCheckCharacterPair: "Invalid check character pair";
+            };
+            readonly Prefix: {
+                readonly gs1CompanyPrefix: "GS1 Company Prefix";
+                readonly upcCompanyPrefix: "U.P.C. Company Prefix";
+                readonly gs18Prefix: "GS1-8 Prefix";
+                readonly gs1CompanyPrefixCantStartWith0: "GS1 Company Prefix can't start with \"0\"";
+                readonly gs1CompanyPrefixCantStartWith00000: "GS1 Company Prefix can't start with \"00000\"";
+                readonly gs1CompanyPrefixCantStartWith000000: "GS1 Company Prefix can't start with \"000000\"";
+                readonly upcCompanyPrefixCantStartWith0000: "U.P.C. Company Prefix can't start with \"0000\"";
+                readonly gs18PrefixCantStartWith0: "GS1-8 Prefix can't start with \"0\"";
+                readonly identificationKeyTypeNotSupportedByGS18Prefix: "{{identificationKeyType}} not supported by GS1-8 Prefix";
+            };
+        };
+    };
+    fr: {
+        aidct_gs1: {
+            readonly Check: {
+                readonly lengthOfStringForPriceOrWeightMustBeExactly: "La longueur {{longueur}} de la chaîne pour le prix ou la somme du poids doit être exactement {{exactLength}}";
+                readonly priceOrWeightComponent: "prix ou poids";
+                readonly lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "La longueur {{length}} de la chaîne pour la paire de caractères de vérification doit être inférieure ou égale à {{maximum Length}}";
+            };
+            readonly IdentificationKey: {
+                readonly identificationKeyTypeLength: "{{identificationKeyType}} doit comporter {{length}} chiffres";
+                readonly invalidCheckDigit: "Chiffre de contrôle non valide";
+                readonly invalidGTINLength: "Le GTIN doit comporter 13, 12, 8 ou 14 chiffres";
+                readonly invalidGTIN14Length: "Le GTIN doit comporter 14 chiffres";
+                readonly invalidZeroSuppressedGTIN12: "Code GTIN-12 non valide avec zéro supprimé";
+                readonly invalidZeroSuppressibleGTIN12: "Le GTIN-12 ne peut pas être supprimé par zéro";
+                readonly invalidZeroSuppressedGTIN12AsGTIN13: "GTIN-12 non valide avec zéro supprimé en tant que GTIN-13";
+                readonly invalidZeroSuppressedGTIN12AsGTIN14: "GTIN-12 non valide avec zéro supprimé en tant que GTIN-14";
+                readonly invalidGTIN13AtRetail: "Le GTIN-13 au niveau des articles de consommation au détail ne peut pas commencer par zéro";
+                readonly invalidGTINAtRetail: "Le GTIN n'est pas pris en charge au niveau des articles de consommation au détail";
+                readonly invalidGTINAtOtherThanRetail: "Le GTIN n'est pas pris en charge à d'autres niveaux que ceux des articles de consommation au détail";
+                readonly indicatorDigit: "chiffre indicateur";
+                readonly serialComponent: "composant série";
+                readonly reference: "référence";
+                readonly referenceCantBeAllNumeric: "La référence ne peut pas être entièrement numérique";
+                readonly invalidCheckCharacterPair: "Paire de caractères de contrôle non valide";
+            };
+            readonly Prefix: {
+                readonly gs1CompanyPrefix: "Préfixe de l'entreprise GS1";
+                readonly upcCompanyPrefix: "Préfixe de l'entreprise U.P.C.";
+                readonly gs18Prefix: "Préfixe GS1-8";
+                readonly gs1CompanyPrefixCantStartWith0: "Le préfixe de l'entreprise GS1 ne peut pas commencer par \"0\"";
+                readonly gs1CompanyPrefixCantStartWith00000: "Le préfixe de l'entreprise GS1 ne peut pas commencer par \"00000\"";
+                readonly gs1CompanyPrefixCantStartWith000000: "Le préfixe de l'entreprise GS1 ne peut pas commencer par \"000000\"";
+                readonly upcCompanyPrefixCantStartWith0000: "Le préfixe de l'entreprise U.P.C. ne peut pas commencer par \"0000\"";
+                readonly gs18PrefixCantStartWith0: "Le préfixe GS1-8 ne peut pas commencer par \"0\"";
+                readonly identificationKeyTypeNotSupportedByGS18Prefix: "{{identificationKeyType}} non pris en charge par le préfixe GS1-8";
+            };
+        };
+    };
+};
+declare const i18nextGS1: i18n;
+/**
+ * Initialize internationalization.
+ *
+ * @param environment
+ * Environment in which the application is running.
+ *
+ * @param debug
+ * Debug setting.
+ *
+ * @returns
+ * Void promise.
+ */
+declare function i18nGS1Init(environment: I18NEnvironment, debug?: boolean): Promise<void>;
 
 /**
  * GS1 AI encodable character set 82 creator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs | GS1
@@ -761,13 +1400,14 @@ interface NumericIdentificationKeyCreator extends NumericIdentificationKeyValida
     /**
      * Create all identification keys for the prefix from `0` to `capacity - 1`.
      *
-     * The implementation creates the strings as needed using an internal generator function, so the values are created
-     * only as needed.
+     * The implementation creates the strings only as needed using an internal generator function. Although the result
+     * is equivalent to calling `creator.create(new Sequencer(0, creator.capacity - 1))`, this method is significantly
+     * faster.
      *
      * @returns
-     * Iterable iterator over created identification keys.
+     * All identification keys for the prefix.
      */
-    createAll: () => IterableIterator<string>;
+    createAll: () => Iterable<string>;
 }
 /**
  * Abstract numeric identification key creator. Implements common functionality for a numeric identification key creator.
@@ -845,7 +1485,7 @@ declare abstract class AbstractNumericIdentificationKeyCreator extends AbstractI
     /**
      * @inheritDoc
      */
-    createAll(): IterableIterator<string>;
+    createAll(): Iterable<string>;
 }
 declare const GTINCreator_base: ts_mixer_dist_types_types_js.Class<any[], GTINValidator & AbstractNumericIdentificationKeyCreator, typeof GTINValidator & typeof AbstractNumericIdentificationKeyCreator>;
 /**
@@ -1348,4 +1988,4 @@ declare class PrefixManager {
     get gmnCreator(): NonNumericIdentificationKeyCreator;
 }
 
-export { AI39_CREATOR, AI82_CREATOR, CPID_VALIDATOR, ContentCharacterSet, GCN_VALIDATOR, GDTI_VALIDATOR, GIAI_VALIDATOR, GINC_VALIDATOR, GLN_VALIDATOR, GMN_VALIDATOR, GRAI_VALIDATOR, GSIN_VALIDATOR, GSRN_VALIDATOR, GTIN12_VALIDATOR, GTIN13_VALIDATOR, GTIN8_VALIDATOR, GTINCreator, GTINLevel, GTINType, GTINValidator, GTIN_VALIDATORS, type IdentificationKeyCreator, IdentificationKeyType, type IdentificationKeyValidation, type IdentificationKeyValidator, LeaderType, NonGTINNumericIdentificationKeyCreator, NonGTINNumericIdentificationKeyValidator, NonNumericIdentificationKeyCreator, type NonNumericIdentificationKeyValidation, NonNumericIdentificationKeyValidator, type NumericIdentificationKeyCreator, type NumericIdentificationKeyValidator, PrefixManager, PrefixType, SSCC_VALIDATOR, SerializableNumericIdentificationKeyCreator, SerializableNumericIdentificationKeyValidator, checkCharacterPair, checkDigit, checkDigitSum, fiveDigitPriceWeightCheckDigit, fourDigitPriceWeightCheckDigit, gs1NS, hasValidCheckCharacterPair, hasValidCheckDigit };
+export { AI39_CREATOR, AI82_CREATOR, CPID_VALIDATOR, ContentCharacterSet, GCN_VALIDATOR, GDTI_VALIDATOR, GIAI_VALIDATOR, GINC_VALIDATOR, GLN_VALIDATOR, GMN_VALIDATOR, GRAI_VALIDATOR, type GS1LocaleStrings, GSIN_VALIDATOR, GSRN_VALIDATOR, GTIN12_VALIDATOR, GTIN13_VALIDATOR, GTIN8_VALIDATOR, GTINCreator, GTINLevel, GTINType, GTINValidator, GTIN_VALIDATORS, type IdentificationKeyCreator, IdentificationKeyType, type IdentificationKeyValidation, type IdentificationKeyValidator, LeaderType, NonGTINNumericIdentificationKeyCreator, NonGTINNumericIdentificationKeyValidator, NonNumericIdentificationKeyCreator, type NonNumericIdentificationKeyValidation, NonNumericIdentificationKeyValidator, type NumericIdentificationKeyCreator, type NumericIdentificationKeyValidator, PrefixManager, PrefixType, SSCC_VALIDATOR, SerializableNumericIdentificationKeyCreator, SerializableNumericIdentificationKeyValidator, checkCharacterPair, checkDigit, checkDigitSum, fiveDigitPriceWeightCheckDigit, fourDigitPriceWeightCheckDigit, gs1NS, gs1Resources, hasValidCheckCharacterPair, hasValidCheckDigit, i18nGS1Init, i18nextGS1 };