@aidc-toolkit/gs1 1.0.24-beta → 1.0.26-beta

package/src/prefix-validator.ts

@@ -1,6 +1,7 @@
 import { type CharacterSetValidation, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
-import { i18nextGS1 } from "./locale/i18n";
-import { type PrefixType, PrefixTypes } from "./prefix-type";
+import { i18nextGS1 } from "./locale/i18n.js";
+import type { PrefixProvider } from "./prefix-provider.js";
+import { type PrefixType, PrefixTypes } from "./prefix-type.js";
 
 /**
  * Prefix validation parameters.
@@ -98,94 +99,155 @@ const GS1_8_PREFIX_VALIDATION: Readonly<PrefixValidation> = {
 };
 
 /**
- * Validate a prefix.
- *
- * @param prefixType
- * Prefix type.
- *
- * @param allowUPCCompanyPrefix
- * If true, a U.P.C. Company Prefix expressed as a GS1 Company Prefix is permitted.
- *
- * @param allowGS18Prefix
- * If true, a GS1-8 Prefix expressed as a GS1 Company Prefix is permitted.
- *
- * @param prefix
- * Prefix.
- *
- * @param isFromIdentifier
- * If true, the prefix is from an identifier and should be trimmed before its character set is validated.
- *
- * @param isNumericIdentifier
- * If true, the prefix is from a numeric identifier and its character set will be validated by the caller.
- *
- * @param positionOffset
- * Position offset within a larger string.
+ * Prefix validator.
  */
-function validate(prefixType: PrefixType, allowUPCCompanyPrefix: boolean, allowGS18Prefix: boolean, prefix: string, isFromIdentifier = false, isNumericIdentifier = false, positionOffset?: number): void {
-    let baseValidation: PrefixValidation;
-
-    // Validate the prefix type and determine the prefix validation parameters.
-    switch (prefixType) {
-        case PrefixTypes.GS1CompanyPrefix:
-            if (!prefix.startsWith("0")) {
-                baseValidation = GS1_COMPANY_PREFIX_VALIDATION;
-            } else if (!prefix.startsWith("00000")) {
-                if (!allowUPCCompanyPrefix) {
-                    throw new RangeError(i18nextGS1.t("Prefix.gs1CompanyPrefixCantStartWith0"));
+export const PrefixValidator = {
+    GS1_COMPANY_PREFIX_MINIMUM_LENGTH,
+    GS1_COMPANY_PREFIX_MAXIMUM_LENGTH,
+    UPC_COMPANY_PREFIX_MINIMUM_LENGTH,
+    UPC_COMPANY_PREFIX_MAXIMUM_LENGTH,
+    GS1_8_PREFIX_MINIMUM_LENGTH,
+    GS1_8_PREFIX_MAXIMUM_LENGTH,
+
+    /**
+     * Validate a prefix.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param allowUPCCompanyPrefix
+     * If true, a U.P.C. Company Prefix expressed as a GS1 Company Prefix is permitted.
+     *
+     * @param allowGS18Prefix
+     * If true, a GS1-8 Prefix expressed as a GS1 Company Prefix is permitted.
+     *
+     * @param prefix
+     * Prefix.
+     *
+     * @param isFromIdentifier
+     * If true, the prefix is from an identifier and should be trimmed before its character set is validated.
+     *
+     * @param isNumericIdentifier
+     * If true, the prefix is from a numeric identifier and its character set will be validated by the caller.
+     *
+     * @param positionOffset
+     * Position offset within a larger string.
+     */
+    validate(prefixType: PrefixType, allowUPCCompanyPrefix: boolean, allowGS18Prefix: boolean, prefix: string, isFromIdentifier = false, isNumericIdentifier = false, positionOffset?: number): void {
+        let baseValidation: PrefixValidation;
+
+        // Validate the prefix type and determine the prefix validation parameters.
+        switch (prefixType) {
+            case PrefixTypes.GS1CompanyPrefix:
+                if (!prefix.startsWith("0")) {
+                    baseValidation = GS1_COMPANY_PREFIX_VALIDATION;
+                } else if (!prefix.startsWith("00000")) {
+                    if (!allowUPCCompanyPrefix) {
+                        throw new RangeError(i18nextGS1.t("Prefix.gs1CompanyPrefixCantStartWith0"));
+                    }
+
+                    baseValidation = UPC_COMPANY_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION;
+                } else if (!prefix.startsWith("000000")) {
+                    if (!allowGS18Prefix) {
+                        throw new RangeError(i18nextGS1.t("Prefix.gs1CompanyPrefixCantStartWith00000"));
+                    }
+
+                    baseValidation = GS1_8_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION;
+                } else {
+                    throw new RangeError(i18nextGS1.t("Prefix.gs1CompanyPrefixCantStartWith000000"));
                 }
+                break;
 
-                baseValidation = UPC_COMPANY_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION;
-            } else if (!prefix.startsWith("000000")) {
-                if (!allowGS18Prefix) {
-                    throw new RangeError(i18nextGS1.t("Prefix.gs1CompanyPrefixCantStartWith00000"));
+            case PrefixTypes.UPCCompanyPrefix:
+                if (prefix.startsWith("0000")) {
+                    throw new RangeError(i18nextGS1.t("Prefix.upcCompanyPrefixCantStartWith0000"));
                 }
 
-                baseValidation = GS1_8_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION;
-            } else {
-                throw new RangeError(i18nextGS1.t("Prefix.gs1CompanyPrefixCantStartWith000000"));
-            }
-            break;
+                baseValidation = UPC_COMPANY_PREFIX_VALIDATION;
+                break;
 
-        case PrefixTypes.UPCCompanyPrefix:
-            if (prefix.startsWith("0000")) {
-                throw new RangeError(i18nextGS1.t("Prefix.upcCompanyPrefixCantStartWith0000"));
-            }
+            case PrefixTypes.GS18Prefix:
+                if (prefix.startsWith("0")) {
+                    throw new RangeError(i18nextGS1.t("Prefix.gs18PrefixCantStartWith0"));
+                }
 
-            baseValidation = UPC_COMPANY_PREFIX_VALIDATION;
-            break;
+                baseValidation = GS1_8_PREFIX_VALIDATION;
+                break;
+        }
 
-        case PrefixTypes.GS18Prefix:
-            if (prefix.startsWith("0")) {
-                throw new RangeError(i18nextGS1.t("Prefix.gs18PrefixCantStartWith0"));
-            }
+        const mergedValidation: PrefixValidation = {
+            ...baseValidation,
+            positionOffset
+        };
 
-            baseValidation = GS1_8_PREFIX_VALIDATION;
-            break;
-    }
+        // If from key and numeric, key validation will take care of character set validation.
+        if (!isFromIdentifier) {
+            NUMERIC_CREATOR.validate(prefix, mergedValidation);
+        } else if (!isNumericIdentifier) {
+            // Validate only the minimum length, allowing at least one character for the (possibly non-numeric) reference.
+            NUMERIC_CREATOR.validate(prefix.substring(0, Math.min(mergedValidation.minimumLength, prefix.length - 1)), mergedValidation);
+        }
+    },
 
-    const mergedValidation: PrefixValidation = {
-        ...baseValidation,
-        positionOffset
-    };
-
-    // If from key and numeric, key validation will take care of character set validation.
-    if (!isFromIdentifier) {
-        NUMERIC_CREATOR.validate(prefix, mergedValidation);
-    } else if (!isNumericIdentifier) {
-        // Validate only the minimum length, allowing at least one character for the (possibly non-numeric) reference.
-        NUMERIC_CREATOR.validate(prefix.substring(0, Math.min(mergedValidation.minimumLength, prefix.length - 1)), mergedValidation);
+    /**
+     * Normalize a prefix.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param prefix
+     * Prefix.
+     *
+     * @returns
+     * Prefix provider with normalized prefix type and prefix.
+     */
+    normalize(prefixType: PrefixType, prefix: string): PrefixProvider {
+        // Validate first.
+        this.validate(prefixType, true, true, prefix);
+
+        let gs1CompanyPrefix: string;
+
+        // First step is to map the prefix to a GS1 Company Prefix.
+        switch (prefixType) {
+            case PrefixTypes.GS1CompanyPrefix:
+                gs1CompanyPrefix = prefix;
+                break;
+
+            case PrefixTypes.UPCCompanyPrefix:
+                gs1CompanyPrefix = "0" + prefix;
+                break;
+
+            case PrefixTypes.GS18Prefix:
+                gs1CompanyPrefix = "00000" + prefix;
+                break;
+        }
+
+        let normalizedPrefixType: PrefixType;
+        let normalizedPrefix: string;
+
+        let upcCompanyPrefix: string | undefined = undefined;
+        let gs18Prefix: string | undefined = undefined;
+
+        // Determine the prefix type and populate the remaining fields.
+        if (!gs1CompanyPrefix.startsWith("0")) {
+            normalizedPrefixType = PrefixTypes.GS1CompanyPrefix;
+            normalizedPrefix = gs1CompanyPrefix;
+        } else if (!gs1CompanyPrefix.startsWith("00000")) {
+            normalizedPrefixType = PrefixTypes.UPCCompanyPrefix;
+            upcCompanyPrefix = gs1CompanyPrefix.substring(1);
+            normalizedPrefix = upcCompanyPrefix;
+        } else {
+            normalizedPrefixType = PrefixTypes.GS18Prefix;
+            gs18Prefix = gs1CompanyPrefix.substring(5);
+            normalizedPrefix = gs18Prefix;
+        }
+
+        return {
+            prefixType: normalizedPrefixType,
+            prefix: normalizedPrefix,
+            gs1CompanyPrefix,
+            upcCompanyPrefix,
+            gs18Prefix
+        };
     }
-}
-
-/**
- * Prefix validator.
- */
-export const PrefixValidator = {
-    GS1_COMPANY_PREFIX_MINIMUM_LENGTH,
-    GS1_COMPANY_PREFIX_MAXIMUM_LENGTH,
-    UPC_COMPANY_PREFIX_MINIMUM_LENGTH,
-    UPC_COMPANY_PREFIX_MAXIMUM_LENGTH,
-    GS1_8_PREFIX_MINIMUM_LENGTH,
-    GS1_8_PREFIX_MAXIMUM_LENGTH,
-    validate
 } as const;

package/src/serializable-numeric-identifier-creator.ts

@@ -1,10 +1,9 @@
 import { mapIterable, type TransformerInput, type TransformerOutput } from "@aidc-toolkit/utility";
 import { Mixin } from "ts-mixer";
-import type { IdentifierType } from "./identifier-type";
-import type { ContentCharacterSet } from "./identifier-validator";
-import { AbstractNumericIdentifierCreator } from "./numeric-identifier-creator";
-import type { PrefixProvider } from "./prefix-provider";
-import { SerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator";
+import { AbstractNumericIdentifierCreator } from "./abstract-numeric-identifier-creator.js";
+import type { PrefixProvider } from "./prefix-provider.js";
+import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
+import { SerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
 
 /**
  * Serializable numeric identifier creator.
@@ -19,18 +18,9 @@ export class SerializableNumericIdentifierCreator extends Mixin(SerializableNume
      *
      * @param identifierType
      * Identifier type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param serialComponentLength
-     * Serial component length.
-     *
-     * @param serialComponentCharacterSet
-     * Serial component character set.
      */
-    constructor(prefixProvider: PrefixProvider, identifierType: IdentifierType, length: number, serialComponentLength: number, serialComponentCharacterSet: ContentCharacterSet) {
-        super(identifierType, length, serialComponentLength, serialComponentCharacterSet);
+    constructor(prefixProvider: PrefixProvider, identifierType: SerializableNumericIdentifierType) {
+        super(identifierType);
 
         this.init(prefixProvider, prefixProvider.gs1CompanyPrefix);
     }

package/src/serializable-numeric-identifier-descriptor.ts

@@ -0,0 +1,29 @@
+import type { ContentCharacterSet } from "./content-character-set.js";
+import type { NonGTINNumericIdentifierDescriptor } from "./non-gtin-numeric-identifier-descriptor.js";
+import type { LeaderTypes } from "./numeric-identifier-type.js";
+import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
+
+/**
+ * Serializable numeric identifier descriptor.
+ */
+export interface SerializableNumericIdentifierDescriptor extends NonGTINNumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: SerializableNumericIdentifierType;
+
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: typeof LeaderTypes.None;
+
+    /**
+     * Serial component length.
+     */
+    readonly serialComponentLength: number;
+
+    /**
+     * Serial component character set.
+     */
+    readonly serialComponentCharacterSet: ContentCharacterSet;
+}

package/src/serializable-numeric-identifier-type.ts

@@ -0,0 +1,9 @@
+import type { IdentifierTypes } from "./identifier-type.js";
+
+/**
+ * Serializable numeric identifier type.
+ */
+export type SerializableNumericIdentifierType =
+    typeof IdentifierTypes.GRAI |
+    typeof IdentifierTypes.GDTI |
+    typeof IdentifierTypes.GCN;

package/src/serializable-numeric-identifier-validator.ts

@@ -1,23 +1,17 @@
 import type { CharacterSetCreator, CharacterSetValidation } from "@aidc-toolkit/utility";
-import { type IdentifierType, IdentifierTypes } from "./identifier-type";
-import { type ContentCharacterSet, ContentCharacterSets, type IdentifierValidation } from "./identifier-validator";
-import { i18nextGS1 } from "./locale/i18n";
-import {
-    type NonGTINNumericIdentifierType,
-    NonGTINNumericIdentifierValidator
-} from "./non-gtin-numeric-identifier-validator";
-import { LeaderTypes } from "./numeric-identifier-validator";
+import { AbstractNumericIdentifierValidator } from "./abstract-numeric-identifier-validator.js";
+import type { ContentCharacterSet } from "./content-character-set.js";
+import { IdentifierDescriptors } from "./descriptors.js";
+import type { IdentifierValidation } from "./identifier-validator.js";
+import { i18nextGS1 } from "./locale/i18n.js";
+import type { SerializableNumericIdentifierDescriptor } from "./serializable-numeric-identifier-descriptor.js";
+import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
 
 /**
- * Serializable numeric identifier type.
+ * Serializable numeric identifier validator. Validates both serialized and non-serialized forms of numeric identifiers
+ * that support serialization.
  */
-export type SerializableNumericIdentifierType = Exclude<NonGTINNumericIdentifierType, typeof IdentifierTypes.GLN | typeof IdentifierTypes.SSCC | typeof IdentifierTypes.GSRN | typeof IdentifierTypes.GSIN>;
-
-/**
- * Serializable numeric identifier validator. Validates both serialized and non-serialized forms of
- * numeric identifiers that support serialization.
- */
-export class SerializableNumericIdentifierValidator extends NonGTINNumericIdentifierValidator {
+export class SerializableNumericIdentifierValidator extends AbstractNumericIdentifierValidator<SerializableNumericIdentifierDescriptor> {
     /**
      * Serial component length.
      */
@@ -43,29 +37,22 @@ export class SerializableNumericIdentifierValidator extends NonGTINNumericIdenti
      *
      * @param identifierType
      * Identifier type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param serialComponentLength
-     * Serial component length.
-     *
-     * @param serialComponentCharacterSet
-     * Serial component character set.
      */
-    constructor(identifierType: IdentifierType, length: number, serialComponentLength: number, serialComponentCharacterSet: ContentCharacterSet) {
-        super(identifierType, length, LeaderTypes.None);
+    constructor(identifierType: SerializableNumericIdentifierType) {
+        const identifierDescriptor = IdentifierDescriptors[identifierType];
+
+        super(identifierDescriptor);
 
-        this._serialComponentLength = serialComponentLength;
-        this._serialComponentCharacterSet = serialComponentCharacterSet;
+        this._serialComponentLength = identifierDescriptor.serialComponentLength;
+        this._serialComponentCharacterSet = identifierDescriptor.serialComponentCharacterSet;
 
         this._serialComponentValidation = {
             minimumLength: 1,
-            maximumLength: serialComponentLength,
+            maximumLength: identifierDescriptor.serialComponentLength,
             component: () => i18nextGS1.t("Identifier.serialComponent")
         };
 
-        this._serialComponentCreator = SerializableNumericIdentifierValidator.creatorFor(serialComponentCharacterSet);
+        this._serialComponentCreator = SerializableNumericIdentifierValidator.creatorFor(identifierDescriptor.serialComponentCharacterSet);
     }
 
     /**
@@ -107,18 +94,3 @@ export class SerializableNumericIdentifierValidator extends NonGTINNumericIdenti
         }
     }
 }
-
-/**
- * GRAI validator.
- */
-export const GRAI_VALIDATOR = new SerializableNumericIdentifierValidator(IdentifierTypes.GRAI, 13, 16, ContentCharacterSets.AI82);
-
-/**
- * GDTI validator.
- */
-export const GDTI_VALIDATOR = new SerializableNumericIdentifierValidator(IdentifierTypes.GDTI, 13, 17, ContentCharacterSets.AI82);
-
-/**
- * GCN validator.
- */
-export const GCN_VALIDATOR = new SerializableNumericIdentifierValidator(IdentifierTypes.GCN, 13, 12, ContentCharacterSets.Numeric);

package/src/validators.ts

@@ -0,0 +1,203 @@
+import {
+    isGTINDescriptor,
+    isGTINDescriptors,
+    isNonGTINNumericIdentifierDescriptor,
+    isNonNumericIdentifierDescriptor,
+    isNumericIdentifierDescriptor,
+    isSerializableNumericIdentifierDescriptor
+} from "./descriptors.js";
+import type { GTINBaseType } from "./gtin-type.js";
+import { GTIN_VALIDATORS, type GTINValidator } from "./gtin-validator.js";
+import { type IdentifierType, IdentifierTypes } from "./identifier-type.js";
+import type { IdentifierValidator } from "./identifier-validator.js";
+import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type.js";
+import { NonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import type { NonNumericIdentifierType } from "./non-numeric-identifier-type.js";
+import { NonNumericIdentifierValidator } from "./non-numeric-identifier-validator.js";
+import type { NumericIdentifierValidator } from "./numeric-identifier-validator.js";
+import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
+import { SerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
+
+/**
+ * GLN validator.
+ */
+const GLN_VALIDATOR = new NonGTINNumericIdentifierValidator(IdentifierTypes.GLN);
+
+/**
+ * SSCC validator.
+ */
+const SSCC_VALIDATOR = new NonGTINNumericIdentifierValidator(IdentifierTypes.SSCC);
+
+/**
+ * GRAI validator.
+ */
+const GRAI_VALIDATOR = new SerializableNumericIdentifierValidator(IdentifierTypes.GRAI);
+
+/**
+ * GIAI validator.
+ */
+const GIAI_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.GIAI);
+
+/**
+ * GSRN validator.
+ */
+const GSRN_VALIDATOR = new NonGTINNumericIdentifierValidator(IdentifierTypes.GSRN);
+
+/**
+ * GDTI validator.
+ */
+const GDTI_VALIDATOR = new SerializableNumericIdentifierValidator(IdentifierTypes.GDTI);
+
+/**
+ * GINC validator.
+ */
+const GINC_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.GINC);
+
+/**
+ * GSIN validator.
+ */
+const GSIN_VALIDATOR = new NonGTINNumericIdentifierValidator(IdentifierTypes.GSIN);
+
+/**
+ * GCN validator.
+ */
+const GCN_VALIDATOR = new SerializableNumericIdentifierValidator(IdentifierTypes.GCN);
+
+/**
+ * CPID validator.
+ */
+const CPID_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.CPID);
+
+/**
+ * GMN validator.
+ */
+const GMN_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.GMN);
+
+/**
+ * Identifier validator type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierTypeValidator<TIdentifierType extends IdentifierType> = TIdentifierType extends NonNumericIdentifierType ?
+    NonNumericIdentifierValidator :
+    TIdentifierType extends SerializableNumericIdentifierType ?
+        SerializableNumericIdentifierValidator :
+        TIdentifierType extends NonGTINNumericIdentifierType ?
+            NonGTINNumericIdentifierValidator :
+            TIdentifierType extends typeof IdentifierTypes.GTIN ?
+                GTINValidator :
+                IdentifierValidator;
+
+/**
+ * Identifier validators entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierValidatorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends typeof IdentifierTypes.GTIN ?
+    Readonly<Record<GTINBaseType, GTINValidator>> :
+    IdentifierTypeValidator<TIdentifierType>;
+
+/**
+ * Identifier validators record type.
+ */
+export type IdentifierValidatorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierValidatorsEntry<TIdentifierType>;
+};
+
+/**
+ * Identifier validators for all identifier types.
+ */
+export const IdentifierValidators: IdentifierValidatorsRecord = {
+    [IdentifierTypes.GTIN]: GTIN_VALIDATORS,
+    [IdentifierTypes.GLN]: GLN_VALIDATOR,
+    [IdentifierTypes.SSCC]: SSCC_VALIDATOR,
+    [IdentifierTypes.GRAI]: GRAI_VALIDATOR,
+    [IdentifierTypes.GIAI]: GIAI_VALIDATOR,
+    [IdentifierTypes.GSRN]: GSRN_VALIDATOR,
+    [IdentifierTypes.GDTI]: GDTI_VALIDATOR,
+    [IdentifierTypes.GINC]: GINC_VALIDATOR,
+    [IdentifierTypes.GSIN]: GSIN_VALIDATOR,
+    [IdentifierTypes.GCN]: GCN_VALIDATOR,
+    [IdentifierTypes.CPID]: CPID_VALIDATOR,
+    [IdentifierTypes.GMN]: GMN_VALIDATOR
+} as const;
+
+/**
+ * Determine if identifier validators or validator is GTIN validators.
+ *
+ * @param identifierValidatorsOrValidator
+ * Identifier validators or validator.
+ *
+ * @returns
+ * True if GTIN validators.
+ */
+export function isGTINValidators(identifierValidatorsOrValidator: IdentifierValidatorsEntry<IdentifierType>): identifierValidatorsOrValidator is Readonly<Record<GTINBaseType, GTINValidator>> {
+    return isGTINDescriptors(identifierValidatorsOrValidator);
+}
+
+/**
+ * Determine if identifier validator is a numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a numeric identifier validator.
+ */
+export function isNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NumericIdentifierValidator {
+    return isNumericIdentifierDescriptor(identifierValidator);
+}
+
+/**
+ * Determine if identifier validator is a GTIN validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a GTIN validator.
+ */
+export function isGTINValidator(identifierValidator: IdentifierValidator): identifierValidator is GTINValidator {
+    return isGTINDescriptor(identifierValidator);
+}
+
+/**
+ * Determine if identifier validator is a non-GTIN numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a non-GTIN numeric identifier validator.
+ */
+export function isNonGTINNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonGTINNumericIdentifierValidator {
+    return isNonGTINNumericIdentifierDescriptor(identifierValidator);
+}
+
+/**
+ * Determine if identifier validator is a serializable numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a serializable numeric identifier validator.
+ */
+export function isSerializableNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is SerializableNumericIdentifierValidator {
+    return isSerializableNumericIdentifierDescriptor(identifierValidator);
+}
+
+/**
+ * Determine if identifier validator is a non-numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a non-numeric identifier validator.
+ */
+export function isNonNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonNumericIdentifierValidator {
+    return isNonNumericIdentifierDescriptor(identifierValidator);
+}

package/test/check.test.ts

@@ -8,7 +8,7 @@ import {
     hasValidCheckDigit,
     isValidPriceOrWeightCheckDigit,
     priceOrWeightCheckDigit
-} from "../src";
+} from "../src/index.js";
 
 describe("Check digit", () => {
     const testNumericString = "1234567890";

package/test/creator.test.ts

@@ -1,11 +1,9 @@
 import { describe } from "vitest";
-import { PrefixManager, PrefixTypes } from "../src";
-import { testGTINCreator } from "./gtin-creator";
-import {
-    testNonGTINNumericIdentifierCreator,
-    testNonNumericIdentifierCreator
-} from "./non-gtin-numeric-identifier-creator";
-import { testSerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator";
+import { PrefixManager, PrefixTypes } from "../src/index.js";
+import { testGTINCreator } from "./gtin-creator.js";
+import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator.js";
+import { testNonNumericIdentifierCreator } from "./non-numeric-identifier-creator.js";
+import { testSerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator.js";
 
 describe("Creators", () => {
     testGTINCreator(PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "952123456").gtinCreator);

package/test/gtin-creator.ts

@@ -1,10 +1,14 @@
 import { CharacterSetCreator, Sequence } from "@aidc-toolkit/utility";
 import { expect, test } from "vitest";
-import { type GTINCreator, GTINTypes, GTINValidator, hasValidCheckDigit, PrefixTypes } from "../src";
-import { testNumericIdentifierCreator } from "./numeric-identifier-creator";
+import { type GTINCreator, GTINTypes, GTINValidator, hasValidCheckDigit, isGTINCreator, PrefixTypes } from "../src/index.js";
+import { testNumericIdentifierCreator } from "./numeric-identifier-creator.js";
 
 export function testGTINCreator(creator: GTINCreator): void {
     testNumericIdentifierCreator(creator, () => {
+        test("Mapping", () => {
+            expect(isGTINCreator(creator)).toBe(true);
+        });
+
         test("Length", () => {
             switch (creator.prefixType) {
                 case PrefixTypes.GS1CompanyPrefix: