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

package/src/gtin-validator.ts

@@ -1,10 +1,11 @@
 import { type CharacterSetValidation, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
-import { AbstractNumericIdentifierValidator } from "./abstract-numeric-identifier-validator.js";
 import { checkDigit, hasValidCheckDigit, isValidPriceOrWeightCheckDigit } from "./check.js";
-import { IdentifierDescriptors } from "./descriptors.js";
 import type { GTINDescriptor } from "./gtin-descriptor.js";
-import { type GTINBaseType, type GTINType, GTINTypes } from "./gtin-type.js";
+import { type GTINBaseLength, GTINLengths } from "./gtin-length.js";
+import type { GTINType } from "./gtin-type.js";
+import { IdentifierDescriptors } from "./identifier-descriptors.js";
 import { i18nextGS1 } from "./locale/i18n.js";
+import { NumericIdentifierValidator } from "./numeric-identifier-validator.js";
 import { type PrefixType, PrefixTypes } from "./prefix-type.js";
 import { PrefixValidator } from "./prefix-validator.js";
 
@@ -56,11 +57,11 @@ export interface RCNReference {
 /**
  * GTIN validator.
  */
-export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescriptor> {
+export class GTINValidator extends NumericIdentifierValidator<GTINType> implements GTINDescriptor {
     /**
      * Validation parameters for optional indicator digit.
      */
-    private static readonly OPTIONAL_INDICATOR_DIGIT_VALIDATION: CharacterSetValidation = {
+    static readonly #OPTIONAL_INDICATOR_DIGIT_VALIDATION: CharacterSetValidation = {
         minimumLength: 0,
         maximumLength: 1,
         component: () => i18nextGS1.t("Identifier.indicatorDigit")
@@ -69,7 +70,7 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
     /**
      * Validation parameters for zero-suppressed GTIN-12.
      */
-    private static readonly ZERO_SUPPRESSED_GTIN12_VALIDATION: CharacterSetValidation = {
+    static readonly #ZERO_SUPPRESSED_GTIN12_VALIDATION: CharacterSetValidation = {
         minimumLength: 8,
         maximumLength: 8
     };
@@ -77,35 +78,27 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
     /**
      * Prefix type.
      */
-    private readonly _prefixType: PrefixType;
+    readonly #prefixType: PrefixType;
 
     /**
      * Constructor.
      *
-     * @param gtinBaseType
-     * GTIN base type (all except GTIN-14).
+     * @param gtinBaseLength
+     * GTIN base length (all except GTIN-14).
      */
-    constructor(gtinBaseType: GTINBaseType) {
-        const identifierDescriptor = IdentifierDescriptors.GTIN[gtinBaseType];
+    constructor(gtinBaseLength: GTINBaseLength) {
+        const identifierDescriptor = IdentifierDescriptors.GTIN[gtinBaseLength];
 
         super(identifierDescriptor);
 
-        this._prefixType = identifierDescriptor.prefixType;
+        this.#prefixType = identifierDescriptor.prefixType;
     }
 
     /**
      * @inheritDoc
      */
     override get prefixType(): PrefixType {
-        return this._prefixType;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    get gtinType(): GTINType {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Length maps to GTIN type.
-        return this.length as GTINType;
+        return this.#prefixType;
     }
 
     /**
@@ -163,7 +156,7 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
      * GTIN-12.
      */
     static zeroExpand(zeroSuppressedGTIN12: string): string {
-        NUMERIC_CREATOR.validate(zeroSuppressedGTIN12, GTINValidator.ZERO_SUPPRESSED_GTIN12_VALIDATION);
+        NUMERIC_CREATOR.validate(zeroSuppressedGTIN12, GTINValidator.#ZERO_SUPPRESSED_GTIN12_VALIDATION);
 
         // Convert to individual digits.
         const d = Array.from(zeroSuppressedGTIN12);
@@ -208,14 +201,14 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
     static convertToGTIN14(indicatorDigit: string, gtin: string): string {
         GTINValidator.validateAny(gtin);
 
-        NUMERIC_CREATOR.validate(indicatorDigit, GTINValidator.OPTIONAL_INDICATOR_DIGIT_VALIDATION);
+        NUMERIC_CREATOR.validate(indicatorDigit, GTINValidator.#OPTIONAL_INDICATOR_DIGIT_VALIDATION);
 
         // Check digit doesn't change by prepending zeros.
-        let gtin14 = gtin.padStart(GTINTypes.GTIN14, "0");
+        let gtin14 = gtin.padStart(GTINLengths.GTIN14, "0");
 
         // If indicator digit provided and is different, recalculate the check digit.
         if (indicatorDigit.length !== 0 && indicatorDigit !== gtin14.charAt(0)) {
-            const partialGTIN14 = indicatorDigit + gtin14.substring(1, GTINTypes.GTIN14 - 1);
+            const partialGTIN14 = indicatorDigit + gtin14.substring(1, GTINLengths.GTIN14 - 1);
 
             gtin14 = partialGTIN14 + checkDigit(partialGTIN14);
         }
@@ -242,7 +235,7 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
         let normalizedGTIN: string;
 
         switch (gtinLength) {
-            case GTINTypes.GTIN13 as number:
+            case GTINLengths.GTIN13 as number:
                 if (!gtin.startsWith("0")) {
                     // GTIN is GTIN-13.
                     normalizedGTIN = gtin;
@@ -257,12 +250,12 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
                 }
                 break;
 
-            case GTINTypes.GTIN12 as number:
+            case GTINLengths.GTIN12 as number:
                 // GTIN is GTIN-12.
                 normalizedGTIN = gtin;
                 break;
 
-            case GTINTypes.GTIN8 as number:
+            case GTINLengths.GTIN8 as number:
                 if (!gtin.startsWith("0")) {
                     // GTIN is GTIN-8.
                     normalizedGTIN = gtin;
@@ -272,7 +265,7 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
                 }
                 break;
 
-            case GTINTypes.GTIN14 as number:
+            case GTINLengths.GTIN14 as number:
                 if (!gtin.startsWith("0")) {
                     // GTIN is GTIN-14.
                     normalizedGTIN = gtin;
@@ -316,7 +309,7 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
         let gtinLevelRestriction: GTINLevel;
 
         switch (gtin.length) {
-            case GTINTypes.GTIN13 as number:
+            case GTINLengths.GTIN13 as number:
                 if (gtin.startsWith("0")) {
                     throw new RangeError(i18nextGS1.t("Identifier.invalidGTIN13AtRetail"));
                 }
@@ -327,14 +320,14 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
                 gtinLevelRestriction = GTINLevels.Any;
                 break;
 
-            case GTINTypes.GTIN12 as number:
+            case GTINLengths.GTIN12 as number:
                 // Validate prefix requiring exact match for prefix type.
                 PrefixValidator.validate(PrefixTypes.UPCCompanyPrefix, false, false, gtin, true, true);
 
                 gtinLevelRestriction = GTINLevels.Any;
                 break;
 
-            case GTINTypes.GTIN8 as number:
+            case GTINLengths.GTIN8 as number:
                 // Zero-suppressed GTIN-12 always starts with 0.
                 if (!gtin.startsWith("0")) {
                     // Validate prefix requiring exact match for prefix type.
@@ -346,7 +339,7 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
                 gtinLevelRestriction = GTINLevels.RetailConsumer;
                 break;
 
-            case GTINTypes.GTIN14 as number:
+            case GTINLengths.GTIN14 as number:
                 // Validate prefix supporting any prefix type.
                 PrefixValidator.validate(PrefixTypes.GS1CompanyPrefix, true, true, gtin.substring(1), true, true);
 
@@ -375,7 +368,7 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
      * GTIN-14.
      */
     static validateGTIN14(gtin14: string): void {
-        if (gtin14.length !== GTINTypes.GTIN14) {
+        if (gtin14.length !== GTINLengths.GTIN14) {
             throw new RangeError(i18nextGS1.t("Identifier.invalidGTIN14Length"));
         }
 
@@ -515,26 +508,26 @@ export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescri
  * GTIN-13 validator.
  */
 // Defined here because of circular reference.
-export const GTIN13_VALIDATOR = new GTINValidator(GTINTypes.GTIN13);
+export const GTIN13_VALIDATOR = new GTINValidator(GTINLengths.GTIN13);
 
 /**
  * GTIN-12 validator.
  */
 // Defined here because of circular reference.
-export const GTIN12_VALIDATOR = new GTINValidator(GTINTypes.GTIN12);
+export const GTIN12_VALIDATOR = new GTINValidator(GTINLengths.GTIN12);
 
 /**
  * GTIN-8 validator.
  */
 // Defined here because of circular reference.
-export const GTIN8_VALIDATOR = new GTINValidator(GTINTypes.GTIN8);
+export const GTIN8_VALIDATOR = new GTINValidator(GTINLengths.GTIN8);
 
 /**
  * GTIN validators indexed by prefix type.
  */
 // Defined here because of circular reference.
-export const GTIN_VALIDATORS: Readonly<Record<GTINBaseType, GTINValidator>> = {
-    [GTINTypes.GTIN13]: GTIN13_VALIDATOR,
-    [GTINTypes.GTIN12]: GTIN12_VALIDATOR,
-    [GTINTypes.GTIN8]: GTIN8_VALIDATOR
+export const GTIN_VALIDATORS: Readonly<Record<GTINBaseLength, GTINValidator>> = {
+    [GTINLengths.GTIN13]: GTIN13_VALIDATOR,
+    [GTINLengths.GTIN12]: GTIN12_VALIDATOR,
+    [GTINLengths.GTIN8]: GTIN8_VALIDATOR
 };

package/src/identifier-creator.ts

@@ -1,4 +1,4 @@
-import type { IdentifierDescriptor } from "./identifier-descriptor.js";
+import type { IdentifierType } from "./identifier-type.js";
 import type { IdentifierValidation, IdentifierValidator } from "./identifier-validator.js";
 import type { PrefixProvider } from "./prefix-provider.js";
 
@@ -8,13 +8,13 @@ import type { PrefixProvider } from "./prefix-provider.js";
  *
  * Keys are created based on a prefix defined in a prefix provider to which the identifier creator is bound.
  *
- * @template TIdentifierDescriptor
- * Identifier descriptor type.
+ * @template TIdentifierType
+ * Identifier type type.
  *
  * @template TIdentifierValidation
  * Identifier validation type.
  */
-export interface IdentifierCreator<TIdentifierDescriptor extends IdentifierDescriptor = IdentifierDescriptor, TIdentifierValidation extends IdentifierValidation = IdentifierValidation> extends IdentifierValidator<TIdentifierDescriptor, TIdentifierValidation> {
+export interface IdentifierCreator<TIdentifierType extends IdentifierType = IdentifierType, TIdentifierValidation extends IdentifierValidation = IdentifierValidation> extends IdentifierValidator<TIdentifierType, TIdentifierValidation> {
     /**
      * Get the prefix provider to which this identifier creator is bound.
      */

package/src/identifier-creators.ts

@@ -0,0 +1,177 @@
+import { GTINCreator } from "./gtin-creator.js";
+import type { GTINBaseLength } from "./gtin-length.js";
+import type { GTINType } from "./gtin-type.js";
+import type { IdentifierCreator } from "./identifier-creator.js";
+import {
+    type IdentifierTypeExtension,
+    isGTINExtension,
+    isNonGTINNumericIdentifierExtension,
+    isNonNumericIdentifierExtension,
+    isNonSerializableNumericIdentifierExtension,
+    isNumericIdentifierExtension,
+    isSerializableNumericIdentifierExtension
+} from "./identifier-extension.js";
+import type { IdentifierType } from "./identifier-type.js";
+import type { NonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator.js";
+import { NonNumericIdentifierCreator } from "./non-numeric-identifier-creator.js";
+import { NonSerializableNumericIdentifierCreator } from "./non-serializable-numeric-identifier-creator.js";
+import type { NumericIdentifierCreator } from "./numeric-identifier-creator.js";
+import type { PrefixProvider } from "./prefix-provider.js";
+import { SerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator.js";
+
+/**
+ * Identifier creator type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierTypeCreator<TIdentifierType extends IdentifierType> = IdentifierTypeExtension<
+    TIdentifierType,
+    IdentifierCreator,
+    NumericIdentifierCreator,
+    GTINCreator,
+    NonGTINNumericIdentifierCreator,
+    NonSerializableNumericIdentifierCreator,
+    SerializableNumericIdentifierCreator,
+    NonNumericIdentifierCreator
+>;
+
+/**
+ * Identifier creators entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierCreatorsEntry<TIdentifierType extends IdentifierType> = IdentifierTypeCreator<TIdentifierType>;
+
+/**
+ * Identifier creators record type.
+ */
+export type IdentifierCreatorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierCreatorsEntry<TIdentifierType>;
+};
+
+/**
+ * GTIN creator constructor type.
+ */
+export type GTINCreatorConstructor =
+    new (prefixProvider: PrefixProvider, gtinBaseLength: GTINBaseLength) => GTINCreator;
+
+/**
+ * Non-GTIN creator constructor type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type NonGTINCreatorConstructor<TIdentifierType extends Exclude<IdentifierType, GTINType>> =
+    new (prefixProvider: PrefixProvider, identifierType: TIdentifierType) => IdentifierCreatorsRecord[TIdentifierType];
+
+/**
+ * Identifier creator constructors entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierCreatorConstructorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends GTINType ?
+    GTINCreatorConstructor :
+    NonGTINCreatorConstructor<Exclude<TIdentifierType, GTINType>>;
+
+/**
+ * Identifier creator constructors record type.
+ */
+export type IdentifierCreatorConstructorsRecord = {
+    readonly [TIdentifierType in IdentifierType]: IdentifierCreatorConstructorsEntry<TIdentifierType>;
+};
+
+export const IdentifierCreatorConstructors: IdentifierCreatorConstructorsRecord = {
+    GTIN: GTINCreator,
+    GLN: NonSerializableNumericIdentifierCreator,
+    SSCC: NonSerializableNumericIdentifierCreator,
+    GRAI: SerializableNumericIdentifierCreator,
+    GIAI: NonNumericIdentifierCreator,
+    GSRN: NonSerializableNumericIdentifierCreator,
+    GDTI: SerializableNumericIdentifierCreator,
+    GINC: NonNumericIdentifierCreator,
+    GSIN: NonSerializableNumericIdentifierCreator,
+    GCN: SerializableNumericIdentifierCreator,
+    CPID: NonNumericIdentifierCreator,
+    GMN: NonNumericIdentifierCreator
+};
+
+/**
+ * Determine if identifier creator is a numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a numeric identifier creator.
+ */
+export function isNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NumericIdentifierCreator {
+    return isNumericIdentifierExtension(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a GTIN creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a GTIN creator.
+ */
+export function isGTINCreator(identifierCreator: IdentifierCreator): identifierCreator is GTINCreator {
+    return isGTINExtension(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a non-GTIN numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a non-GTIN numeric identifier creator.
+ */
+export function isNonGTINNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonGTINNumericIdentifierCreator {
+    return isNonGTINNumericIdentifierExtension(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a non-serializable numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a non-serializable numeric identifier creator.
+ */
+export function isNonSerializableNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonSerializableNumericIdentifierCreator {
+    return isNonSerializableNumericIdentifierExtension(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a serializable numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a serializable numeric identifier creator.
+ */
+export function isSerializableNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is SerializableNumericIdentifierCreator {
+    return isSerializableNumericIdentifierExtension(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a non-numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a non-numeric identifier creator.
+ */
+export function isNonNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonNumericIdentifierCreator {
+    return isNonNumericIdentifierExtension(identifierCreator);
+}

package/src/{descriptors.ts → identifier-descriptors.ts}

@@ -1,17 +1,25 @@
 import { ContentCharacterSets } from "./content-character-set.js";
 import type { GTINDescriptor } from "./gtin-descriptor.js";
-import { type GTINBaseType, GTINTypes } from "./gtin-type.js";
+import { type GTINBaseLength, GTINBaseLengths } from "./gtin-length.js";
+import type { GTINType } from "./gtin-type.js";
 import type { IdentifierDescriptor } from "./identifier-descriptor.js";
+import {
+    type IdentifierTypeExtension,
+    isGTINExtension,
+    isNonGTINNumericIdentifierExtension,
+    isNonNumericIdentifierExtension,
+    isNonSerializableNumericIdentifierExtension,
+    isNumericIdentifierExtension,
+    isSerializableNumericIdentifierExtension
+} from "./identifier-extension.js";
 import { type IdentifierType, IdentifierTypes } from "./identifier-type.js";
+import { LeaderTypes } from "./leader-type.js";
 import type { NonGTINNumericIdentifierDescriptor } from "./non-gtin-numeric-identifier-descriptor.js";
-import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type.js";
 import type { NonNumericIdentifierDescriptor } from "./non-numeric-identifier-descriptor.js";
-import type { NonNumericIdentifierType } from "./non-numeric-identifier-type.js";
+import type { NonSerializableNumericIdentifierDescriptor } from "./non-serializable-numeric-identifier-descriptor.js";
 import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
-import { LeaderTypes, type NumericIdentifierType } from "./numeric-identifier-type.js";
 import { PrefixTypes } from "./prefix-type.js";
 import type { SerializableNumericIdentifierDescriptor } from "./serializable-numeric-identifier-descriptor.js";
-import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
 
 /**
  * GTIN-13 descriptor.
@@ -19,7 +27,7 @@ import type { SerializableNumericIdentifierType } from "./serializable-numeric-i
 const GTIN13_DESCRIPTOR: GTINDescriptor = {
     identifierType: IdentifierTypes.GTIN,
     prefixType: PrefixTypes.GS1CompanyPrefix,
-    length: GTINTypes.GTIN13,
+    length: GTINBaseLengths.GTIN13,
     referenceCharacterSet: ContentCharacterSets.Numeric,
     leaderType: LeaderTypes.IndicatorDigit
 };
@@ -30,7 +38,7 @@ const GTIN13_DESCRIPTOR: GTINDescriptor = {
 const GTIN12_DESCRIPTOR: GTINDescriptor = {
     identifierType: IdentifierTypes.GTIN,
     prefixType: PrefixTypes.UPCCompanyPrefix,
-    length: GTINTypes.GTIN12,
+    length: GTINBaseLengths.GTIN12,
     referenceCharacterSet: ContentCharacterSets.Numeric,
     leaderType: LeaderTypes.IndicatorDigit
 };
@@ -41,7 +49,7 @@ const GTIN12_DESCRIPTOR: GTINDescriptor = {
 const GTIN8_DESCRIPTOR: GTINDescriptor = {
     identifierType: IdentifierTypes.GTIN,
     prefixType: PrefixTypes.GS18Prefix,
-    length: GTINTypes.GTIN8,
+    length: GTINBaseLengths.GTIN8,
     referenceCharacterSet: ContentCharacterSets.Numeric,
     leaderType: LeaderTypes.IndicatorDigit
 };
@@ -49,16 +57,16 @@ const GTIN8_DESCRIPTOR: GTINDescriptor = {
 /**
  * GTIN descriptors indexed by prefix type.
  */
-const GTIN_DESCRIPTORS: Readonly<Record<GTINBaseType, GTINDescriptor>> = {
-    [GTINTypes.GTIN13]: GTIN13_DESCRIPTOR,
-    [GTINTypes.GTIN12]: GTIN12_DESCRIPTOR,
-    [GTINTypes.GTIN8]: GTIN8_DESCRIPTOR
+const GTIN_DESCRIPTORS: Readonly<Record<GTINBaseLength, GTINDescriptor>> = {
+    [GTINBaseLengths.GTIN13]: GTIN13_DESCRIPTOR,
+    [GTINBaseLengths.GTIN12]: GTIN12_DESCRIPTOR,
+    [GTINBaseLengths.GTIN8]: GTIN8_DESCRIPTOR
 };
 
 /**
  * GLN descriptor.
  */
-const GLN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+const GLN_DESCRIPTOR: NonSerializableNumericIdentifierDescriptor = {
     identifierType: IdentifierTypes.GLN,
     prefixType: PrefixTypes.GS1CompanyPrefix,
     length: 13,
@@ -69,7 +77,7 @@ const GLN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
 /**
  * SSCC descriptor.
  */
-const SSCC_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+const SSCC_DESCRIPTOR: NonSerializableNumericIdentifierDescriptor = {
     identifierType: IdentifierTypes.SSCC,
     prefixType: PrefixTypes.GS1CompanyPrefix,
     length: 18,
@@ -104,7 +112,7 @@ const GIAI_DESCRIPTOR: NonNumericIdentifierDescriptor = {
 /**
  * GSRN descriptor.
  */
-const GSRN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+const GSRN_DESCRIPTOR: NonSerializableNumericIdentifierDescriptor = {
     identifierType: IdentifierTypes.GSRN,
     prefixType: PrefixTypes.GS1CompanyPrefix,
     length: 18,
@@ -139,7 +147,7 @@ const GINC_DESCRIPTOR: NonNumericIdentifierDescriptor = {
 /**
  * GSIN descriptor.
  */
-const GSIN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+const GSIN_DESCRIPTOR: NonSerializableNumericIdentifierDescriptor = {
     identifierType: IdentifierTypes.GSIN,
     prefixType: PrefixTypes.GS1CompanyPrefix,
     length: 17,
@@ -188,15 +196,16 @@ const GMN_DESCRIPTOR: NonNumericIdentifierDescriptor = {
  * @template TIdentifierType
  * Identifier type type.
  */
-export type IdentifierTypeDescriptor<TIdentifierType extends IdentifierType> = TIdentifierType extends NonNumericIdentifierType ?
-    NonNumericIdentifierDescriptor :
-    TIdentifierType extends SerializableNumericIdentifierType ?
-        SerializableNumericIdentifierDescriptor :
-        TIdentifierType extends NonGTINNumericIdentifierType ?
-            NonGTINNumericIdentifierDescriptor :
-            TIdentifierType extends typeof IdentifierTypes.GTIN ?
-                GTINDescriptor :
-                IdentifierDescriptor;
+export type IdentifierTypeDescriptor<TIdentifierType extends IdentifierType> = IdentifierTypeExtension<
+    TIdentifierType,
+    IdentifierDescriptor,
+    NumericIdentifierDescriptor,
+    GTINDescriptor,
+    NonGTINNumericIdentifierDescriptor,
+    NonSerializableNumericIdentifierDescriptor,
+    SerializableNumericIdentifierDescriptor,
+    NonNumericIdentifierDescriptor
+>;
 
 /**
  * Identifier descriptors entry type based on identifier type type.
@@ -204,15 +213,15 @@ export type IdentifierTypeDescriptor<TIdentifierType extends IdentifierType> = T
  * @template TIdentifierType
  * Identifier type type.
  */
-export type IdentifierDescriptorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends typeof IdentifierTypes.GTIN ?
-    Readonly<Record<GTINBaseType, GTINDescriptor>> :
+export type IdentifierDescriptorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends GTINType ?
+    Readonly<Record<GTINBaseLength, GTINDescriptor>> :
     IdentifierTypeDescriptor<TIdentifierType>;
 
 /**
  * Identifier descriptors record type.
  */
 export type IdentifierDescriptorsRecord = {
-    [TIdentifierType in IdentifierType]: IdentifierDescriptorsEntry<TIdentifierType>;
+    readonly [TIdentifierType in IdentifierType]: IdentifierDescriptorsEntry<TIdentifierType>;
 };
 
 /**
@@ -231,7 +240,7 @@ export const IdentifierDescriptors: IdentifierDescriptorsRecord = {
     [IdentifierTypes.GCN]: GCN_DESCRIPTOR,
     [IdentifierTypes.CPID]: CPID_DESCRIPTOR,
     [IdentifierTypes.GMN]: GMN_DESCRIPTOR
-} as const;
+};
 
 /**
  * Determine if identifier descriptors or descriptor is GTIN descriptors.
@@ -242,28 +251,10 @@ export const IdentifierDescriptors: IdentifierDescriptorsRecord = {
  * @returns
  * True if GTIN descriptors.
  */
-export function isGTINDescriptors(identifierDescriptorsOrDescriptor: IdentifierDescriptorsEntry<IdentifierType>): identifierDescriptorsOrDescriptor is Readonly<Record<GTINBaseType, GTINDescriptor>> {
+export function isGTINDescriptors(identifierDescriptorsOrDescriptor: IdentifierDescriptorsEntry<IdentifierType>): identifierDescriptorsOrDescriptor is Readonly<Record<GTINBaseLength, GTINDescriptor>> {
     return !("identifierType" in identifierDescriptorsOrDescriptor);
 }
 
-/**
- * Determine if an array of identifier types includes a given identifier type.
- *
- * @param identifierTypes
- * Identifier types.
- *
- * @param identifierType
- * Identifier type.
- *
- * @returns
- * True if element is included in the array.
- */
-function identifierTypesIncludes(identifierTypes: readonly IdentifierType[], identifierType: IdentifierType): boolean {
-    return identifierTypes.includes(identifierType);
-}
-
-const NUMERIC_IDENTIFIER_TYPES: readonly NumericIdentifierType[] = [IdentifierTypes.GTIN, IdentifierTypes.GLN, IdentifierTypes.SSCC, IdentifierTypes.GRAI, IdentifierTypes.GSRN, IdentifierTypes.GDTI, IdentifierTypes.GSIN, IdentifierTypes.GCN];
-
 /**
  * Determine if identifier descriptor is a numeric identifier descriptor.
  *
@@ -274,7 +265,7 @@ const NUMERIC_IDENTIFIER_TYPES: readonly NumericIdentifierType[] = [IdentifierTy
  * True if identifier descriptor is a numeric identifier descriptor.
  */
 export function isNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NumericIdentifierDescriptor {
-    return identifierTypesIncludes(NUMERIC_IDENTIFIER_TYPES, identifierDescriptor.identifierType);
+    return isNumericIdentifierExtension(identifierDescriptor);
 }
 
 /**
@@ -287,7 +278,7 @@ export function isNumericIdentifierDescriptor(identifierDescriptor: IdentifierDe
  * True if identifier descriptor is a GTIN descriptor.
  */
 export function isGTINDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is GTINDescriptor {
-    return identifierDescriptor.identifierType === IdentifierTypes.GTIN;
+    return isGTINExtension(identifierDescriptor);
 }
 
 /**
@@ -300,10 +291,21 @@ export function isGTINDescriptor(identifierDescriptor: IdentifierDescriptor): id
  * True if identifier descriptor is a non-GTIN numeric identifier descriptor.
  */
 export function isNonGTINNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonGTINNumericIdentifierDescriptor {
-    return isNumericIdentifierDescriptor(identifierDescriptor) && !isGTINDescriptor(identifierDescriptor);
+    return isNonGTINNumericIdentifierExtension(identifierDescriptor);
 }
 
-const SERIALIZABLE_NUMERIC_IDENTIFIER_TYPES: readonly SerializableNumericIdentifierType[] = [IdentifierTypes.GRAI, IdentifierTypes.GDTI, IdentifierTypes.GCN];
+/**
+ * Determine if identifier descriptor is a non-serializable numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a non-serializable numeric identifier descriptor.
+ */
+export function isNonSerializableNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonSerializableNumericIdentifierDescriptor {
+    return isNonSerializableNumericIdentifierExtension(identifierDescriptor);
+}
 
 /**
  * Determine if identifier descriptor is a serializable numeric identifier descriptor.
@@ -315,7 +317,7 @@ const SERIALIZABLE_NUMERIC_IDENTIFIER_TYPES: readonly SerializableNumericIdentif
  * True if identifier descriptor is a serializable numeric identifier descriptor.
  */
 export function isSerializableNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is SerializableNumericIdentifierDescriptor {
-    return identifierTypesIncludes(SERIALIZABLE_NUMERIC_IDENTIFIER_TYPES, identifierDescriptor.identifierType);
+    return isSerializableNumericIdentifierExtension(identifierDescriptor);
 }
 
 /**
@@ -328,5 +330,5 @@ export function isSerializableNumericIdentifierDescriptor(identifierDescriptor:
  * True if identifier descriptor is a non-numeric identifier descriptor.
  */
 export function isNonNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonNumericIdentifierDescriptor {
-    return !isNumericIdentifierDescriptor(identifierDescriptor);
+    return isNonNumericIdentifierExtension(identifierDescriptor);
 }