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

package/src/identifier-extension.ts

@@ -0,0 +1,155 @@
+import type { GTINDescriptor } from "./gtin-descriptor.js";
+import { type GTINType, GTINTypes } from "./gtin-type.js";
+import type { IdentifierDescriptor } from "./identifier-descriptor.js";
+import type { IdentifierType } from "./identifier-type.js";
+import type { NonGTINNumericIdentifierDescriptor } from "./non-gtin-numeric-identifier-descriptor.js";
+import {
+    type NonGTINNumericIdentifierType,
+    NonGTINNumericIdentifierTypes
+} from "./non-gtin-numeric-identifier-type.js";
+import type { NonNumericIdentifierDescriptor } from "./non-numeric-identifier-descriptor.js";
+import { type NonNumericIdentifierType, NonNumericIdentifierTypes } from "./non-numeric-identifier-type.js";
+import type { NonSerializableNumericIdentifierDescriptor } from "./non-serializable-numeric-identifier-descriptor.js";
+import {
+    type NonSerializableNumericIdentifierType,
+    NonSerializableNumericIdentifierTypes
+} from "./non-serializable-numeric-identifier-type.js";
+import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
+import { type NumericIdentifierType, NumericIdentifierTypes } from "./numeric-identifier-type.js";
+import type { SerializableNumericIdentifierDescriptor } from "./serializable-numeric-identifier-descriptor.js";
+import {
+    type SerializableNumericIdentifierType,
+    SerializableNumericIdentifierTypes
+} from "./serializable-numeric-identifier-type.js";
+
+/**
+ * Identifier extension type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierTypeExtension<
+    TIdentifierType extends IdentifierType,
+    TIdentifierExtension extends IdentifierDescriptor,
+    TNumericIdentifierExtension extends TIdentifierExtension & NumericIdentifierDescriptor,
+    TGTINExtension extends TNumericIdentifierExtension & GTINDescriptor,
+    TNonGTINNumericIdentifierExtension extends TNumericIdentifierExtension & NonGTINNumericIdentifierDescriptor,
+    TNonSerializableNumericIdentifierExtension extends TNonGTINNumericIdentifierExtension & NonSerializableNumericIdentifierDescriptor,
+    TSerializableNumericIdentifierExtension extends TNonGTINNumericIdentifierExtension & SerializableNumericIdentifierDescriptor,
+    TNonNumericIdentifierExtension extends TIdentifierExtension & NonNumericIdentifierDescriptor
+> =
+    TIdentifierType extends NumericIdentifierType ?
+        TIdentifierType extends GTINType ?
+            TGTINExtension :
+            TIdentifierType extends NonGTINNumericIdentifierType ?
+                TIdentifierType extends NonSerializableNumericIdentifierType ?
+                    TNonSerializableNumericIdentifierExtension :
+                    TIdentifierType extends SerializableNumericIdentifierType ?
+                        TSerializableNumericIdentifierExtension :
+                        TNonGTINNumericIdentifierExtension :
+                TNumericIdentifierExtension :
+        TIdentifierType extends NonNumericIdentifierType ?
+            TNonNumericIdentifierExtension :
+            TIdentifierExtension;
+
+/**
+ * Determine if identifier extension is a numeric identifier extension.
+ *
+ * @param identifierDescriptor
+ * Identifier extension.
+ *
+ * @returns
+ * True if identifier extension is a numeric identifier extension.
+ */
+export function isNumericIdentifierExtension<
+    TIdentifierExtension extends IdentifierDescriptor,
+    TNumericIdentifierExtension extends TIdentifierExtension & NumericIdentifierDescriptor
+>(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is TNumericIdentifierExtension {
+    return identifierDescriptor.identifierType in NumericIdentifierTypes;
+}
+
+/**
+ * Determine if identifier extension is a GTIN extension.
+ *
+ * @param identifierDescriptor
+ * Identifier extension.
+ *
+ * @returns
+ * True if identifier extension is a GTIN extension.
+ */
+export function isGTINExtension<
+    TIdentifierExtension extends IdentifierDescriptor,
+    TNumericIdentifierExtension extends TIdentifierExtension & NumericIdentifierDescriptor,
+    TGTINExtension extends TNumericIdentifierExtension & GTINDescriptor
+>(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is TGTINExtension {
+    return identifierDescriptor.identifierType in GTINTypes;
+}
+
+/**
+ * Determine if identifier extension is a non-GTIN numeric identifier extension.
+ *
+ * @param identifierDescriptor
+ * Identifier extension.
+ *
+ * @returns
+ * True if identifier extension is a non-GTIN numeric identifier extension.
+ */
+export function isNonGTINNumericIdentifierExtension<
+    TIdentifierExtension extends IdentifierDescriptor,
+    TNumericIdentifierExtension extends TIdentifierExtension & NumericIdentifierDescriptor,
+    TNonGTINNumericIdentifierExtension extends TNumericIdentifierExtension & NonGTINNumericIdentifierDescriptor
+>(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is TNonGTINNumericIdentifierExtension {
+    return identifierDescriptor.identifierType in NonGTINNumericIdentifierTypes;
+}
+
+/**
+ * Determine if identifier extension is a non-serializable numeric identifier extension.
+ *
+ * @param identifierDescriptor
+ * Identifier extension.
+ *
+ * @returns
+ * True if identifier extension is a non-serializable numeric identifier extension.
+ */
+export function isNonSerializableNumericIdentifierExtension<
+    TIdentifierExtension extends IdentifierDescriptor,
+    TNumericIdentifierExtension extends TIdentifierExtension & NumericIdentifierDescriptor,
+    TNonGTINNumericIdentifierExtension extends TNumericIdentifierExtension & NonGTINNumericIdentifierDescriptor,
+    TNonSerializableNumericIdentifierExtension extends TNonGTINNumericIdentifierExtension & NonSerializableNumericIdentifierDescriptor
+>(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is TNonSerializableNumericIdentifierExtension {
+    return identifierDescriptor.identifierType in NonSerializableNumericIdentifierTypes;
+}
+
+/**
+ * Determine if identifier extension is a serializable numeric identifier extension.
+ *
+ * @param identifierDescriptor
+ * Identifier extension.
+ *
+ * @returns
+ * True if identifier extension is a serializable numeric identifier extension.
+ */
+export function isSerializableNumericIdentifierExtension<
+    TIdentifierExtension extends IdentifierDescriptor,
+    TNumericIdentifierExtension extends TIdentifierExtension & NumericIdentifierDescriptor,
+    TNonGTINNumericIdentifierExtension extends TNumericIdentifierExtension & NonGTINNumericIdentifierDescriptor,
+    TSerializableNumericIdentifierExtension extends TNonGTINNumericIdentifierExtension & SerializableNumericIdentifierDescriptor
+>(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is TSerializableNumericIdentifierExtension {
+    return identifierDescriptor.identifierType in SerializableNumericIdentifierTypes;
+}
+
+/**
+ * Determine if identifier extension is a non-numeric identifier extension.
+ *
+ * @param identifierDescriptor
+ * Identifier extension.
+ *
+ * @returns
+ * True if identifier extension is a non-numeric identifier extension.
+ */
+export function isNonNumericIdentifierExtension<
+    TIdentifierExtension extends IdentifierDescriptor,
+    TNonNumericIdentifierExtension extends TIdentifierExtension & NonNumericIdentifierDescriptor
+>(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is TNonNumericIdentifierExtension {
+    return identifierDescriptor.identifierType in NonNumericIdentifierTypes;
+}

package/src/identifier-validator.ts

@@ -1,5 +1,11 @@
 import type { CharacterSetCreator, StringValidation, StringValidator } from "@aidc-toolkit/utility";
+import { CONTENT_CHARACTER_SET_CREATORS } from "./content-character-set-creators.js";
+import { ContentCharacterSets } from "./content-character-set.js";
 import type { IdentifierDescriptor } from "./identifier-descriptor.js";
+import type { IdentifierTypeDescriptor } from "./identifier-descriptors.js";
+import type { IdentifierType } from "./identifier-type.js";
+import { PrefixTypes } from "./prefix-type.js";
+import { PrefixValidator } from "./prefix-validator.js";
 
 /**
  * Identifier validation parameters.
@@ -9,42 +15,119 @@ export interface IdentifierValidation extends StringValidation {
 
 /**
  * Identifier validator. Validates an identifier against its definition in section 3 of the {@link
- * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}.
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Implements common functionality for an
+ * identifier validator.
  *
- * @template TIdentifierDescriptor
- * Identifier descriptor type.
+ * @template TIdentifierType
+ * Identifier type type.
  *
  * @template TIdentifierValidation
  * Identifier validation type.
  */
-export interface IdentifierValidator<TIdentifierDescriptor extends IdentifierDescriptor = IdentifierDescriptor, TIdentifierValidation extends IdentifierValidation = IdentifierValidation> extends StringValidator<TIdentifierValidation> {
+export abstract class IdentifierValidator<TIdentifierType extends IdentifierType = IdentifierType, TIdentifierValidation extends IdentifierValidation = IdentifierValidation> implements IdentifierDescriptor, StringValidator<TIdentifierValidation> {
+    /**
+     * Identifier type.
+     */
+    readonly #identifierType: IdentifierTypeDescriptor<TIdentifierType>["identifierType"];
+
+    /**
+     * Length.
+     */
+    readonly #length: IdentifierTypeDescriptor<TIdentifierType>["length"];
+
+    /**
+     * Reference character set.
+     */
+    readonly #referenceCharacterSet: IdentifierTypeDescriptor<TIdentifierType>["referenceCharacterSet"];
+
+    /**
+     * Reference creator.
+     */
+    readonly #referenceCreator: CharacterSetCreator;
+
+    /**
+     * Constructor.
+     *
+     * @param identifierDescriptor
+     * Identifier descriptor.
+     */
+    protected constructor(identifierDescriptor: IdentifierTypeDescriptor<TIdentifierType>) {
+        this.#identifierType = identifierDescriptor.identifierType;
+        this.#length = identifierDescriptor.length;
+        this.#referenceCharacterSet = identifierDescriptor.referenceCharacterSet;
+        this.#referenceCreator = CONTENT_CHARACTER_SET_CREATORS[identifierDescriptor.referenceCharacterSet];
+    }
+
     /**
      * Get the identifier type. Per the GS1 General Specifications, the identifier type determines the remaining
      * properties.
      */
-    get identifierType(): TIdentifierDescriptor["identifierType"];
+    get identifierType(): IdentifierTypeDescriptor<TIdentifierType>["identifierType"] {
+        return this.#identifierType;
+    }
 
     /**
      * Get the prefix type supported by the identifier type. For all identifier types except the GTIN, this is a GS1
      * Company Prefix. For the GTIN, the prefix type determines the length.
      */
-    get prefixType(): TIdentifierDescriptor["prefixType"];
+    get prefixType(): IdentifierTypeDescriptor<TIdentifierType>["prefixType"] {
+        // All identifier types except GTIN support only the GS1 Company Prefix.
+        return PrefixTypes.GS1CompanyPrefix;
+    }
 
     /**
      * Get the length. For numeric identifier types, the length is fixed; for alphanumeric identifier types, the length
      * is the maximum.
      */
-    get length(): number;
+    get length(): IdentifierTypeDescriptor<TIdentifierType>["length"] {
+        return this.#length;
+    }
 
     /**
      * Get the reference character set.
      */
-    get referenceCharacterSet(): TIdentifierDescriptor["referenceCharacterSet"];
+    get referenceCharacterSet(): IdentifierTypeDescriptor<TIdentifierType>["referenceCharacterSet"] {
+        return this.#referenceCharacterSet;
+    }
 
     /**
      * Get the reference creator.
      */
-    get referenceCreator(): CharacterSetCreator;
+    get referenceCreator(): CharacterSetCreator {
+        return this.#referenceCreator;
+    }
+
+    /**
+     * Pad an identifier on the left with zero-value character for validation purposes. This is done to align an
+     * identifier with a position offset for any error message that may be thrown by the reference validator.
+     *
+     * @param identifier
+     * Identifier.
+     *
+     * @param positionOffset
+     * Position offset within a larger string.
+     *
+     * @returns
+     * Padded identifier.
+     */
+    protected padIdentifier(identifier: string, positionOffset?: number): string {
+        // Identifier is returned as is if position offset is undefined.
+        return positionOffset === undefined ? identifier : this.referenceCreator.character(0).repeat(positionOffset).concat(identifier);
+    }
+
+    /**
+     * Validate the prefix within an identifier.
+     *
+     * @param partialIdentifier
+     * Partial identifier.
+     *
+     * @param positionOffset
+     * Position offset within a larger string.
+     */
+    protected validatePrefix(partialIdentifier: string, positionOffset?: number): void {
+        // Delegate to prefix validator with support for U.P.C. Company Prefix but not GS1-8 Prefix.
+        PrefixValidator.validate(this.prefixType, true, false, partialIdentifier, true, this.referenceCharacterSet === ContentCharacterSets.Numeric, positionOffset);
+    }
 
     /**
      * Validate an identifier and throw an error if validation fails.
@@ -55,5 +138,5 @@ export interface IdentifierValidator<TIdentifierDescriptor extends IdentifierDes
      * @param validation
      * Identifier validation parameters.
      */
-    validate: (identifier: string, validation?: TIdentifierValidation) => void;
+    abstract validate(identifier: string, validation?: TIdentifierValidation): void;
 }

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

@@ -1,32 +1,33 @@
-import {
-    isGTINDescriptor,
-    isGTINDescriptors,
-    isNonGTINNumericIdentifierDescriptor,
-    isNonNumericIdentifierDescriptor,
-    isNumericIdentifierDescriptor,
-    isSerializableNumericIdentifierDescriptor
-} from "./descriptors.js";
-import type { GTINBaseType } from "./gtin-type.js";
+import type { GTINBaseLength } from "./gtin-length.js";
+import type { GTINType } from "./gtin-type.js";
 import { GTIN_VALIDATORS, type GTINValidator } from "./gtin-validator.js";
+import { isGTINDescriptors } from "./identifier-descriptors.js";
+import {
+    type IdentifierTypeExtension,
+    isGTINExtension,
+    isNonGTINNumericIdentifierExtension,
+    isNonNumericIdentifierExtension,
+    isNonSerializableNumericIdentifierExtension,
+    isNumericIdentifierExtension,
+    isSerializableNumericIdentifierExtension
+} from "./identifier-extension.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 type { NonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
 import { NonNumericIdentifierValidator } from "./non-numeric-identifier-validator.js";
+import { NonSerializableNumericIdentifierValidator } from "./non-serializable-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);
+const GLN_VALIDATOR = new NonSerializableNumericIdentifierValidator(IdentifierTypes.GLN);
 
 /**
  * SSCC validator.
  */
-const SSCC_VALIDATOR = new NonGTINNumericIdentifierValidator(IdentifierTypes.SSCC);
+const SSCC_VALIDATOR = new NonSerializableNumericIdentifierValidator(IdentifierTypes.SSCC);
 
 /**
  * GRAI validator.
@@ -41,7 +42,7 @@ const GIAI_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.GIAI);
 /**
  * GSRN validator.
  */
-const GSRN_VALIDATOR = new NonGTINNumericIdentifierValidator(IdentifierTypes.GSRN);
+const GSRN_VALIDATOR = new NonSerializableNumericIdentifierValidator(IdentifierTypes.GSRN);
 
 /**
  * GDTI validator.
@@ -56,7 +57,7 @@ const GINC_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.GINC);
 /**
  * GSIN validator.
  */
-const GSIN_VALIDATOR = new NonGTINNumericIdentifierValidator(IdentifierTypes.GSIN);
+const GSIN_VALIDATOR = new NonSerializableNumericIdentifierValidator(IdentifierTypes.GSIN);
 
 /**
  * GCN validator.
@@ -79,15 +80,16 @@ const GMN_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.GMN);
  * @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;
+export type IdentifierTypeValidator<TIdentifierType extends IdentifierType> = IdentifierTypeExtension<
+    TIdentifierType,
+    IdentifierValidator,
+    NumericIdentifierValidator,
+    GTINValidator,
+    NonGTINNumericIdentifierValidator,
+    NonSerializableNumericIdentifierValidator,
+    SerializableNumericIdentifierValidator,
+    NonNumericIdentifierValidator
+>;
 
 /**
  * Identifier validators entry type based on identifier type type.
@@ -95,15 +97,15 @@ export type IdentifierTypeValidator<TIdentifierType extends IdentifierType> = TI
  * @template TIdentifierType
  * Identifier type type.
  */
-export type IdentifierValidatorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends typeof IdentifierTypes.GTIN ?
-    Readonly<Record<GTINBaseType, GTINValidator>> :
+export type IdentifierValidatorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends GTINType ?
+    Readonly<Record<GTINBaseLength, GTINValidator>> :
     IdentifierTypeValidator<TIdentifierType>;
 
 /**
  * Identifier validators record type.
  */
 export type IdentifierValidatorsRecord = {
-    [TIdentifierType in IdentifierType]: IdentifierValidatorsEntry<TIdentifierType>;
+    readonly [TIdentifierType in IdentifierType]: IdentifierValidatorsEntry<TIdentifierType>;
 };
 
 /**
@@ -122,7 +124,7 @@ export const IdentifierValidators: IdentifierValidatorsRecord = {
     [IdentifierTypes.GCN]: GCN_VALIDATOR,
     [IdentifierTypes.CPID]: CPID_VALIDATOR,
     [IdentifierTypes.GMN]: GMN_VALIDATOR
-} as const;
+};
 
 /**
  * Determine if identifier validators or validator is GTIN validators.
@@ -133,7 +135,7 @@ export const IdentifierValidators: IdentifierValidatorsRecord = {
  * @returns
  * True if GTIN validators.
  */
-export function isGTINValidators(identifierValidatorsOrValidator: IdentifierValidatorsEntry<IdentifierType>): identifierValidatorsOrValidator is Readonly<Record<GTINBaseType, GTINValidator>> {
+export function isGTINValidators(identifierValidatorsOrValidator: IdentifierValidatorsEntry<IdentifierType>): identifierValidatorsOrValidator is Readonly<Record<GTINBaseLength, GTINValidator>> {
     return isGTINDescriptors(identifierValidatorsOrValidator);
 }
 
@@ -147,7 +149,7 @@ export function isGTINValidators(identifierValidatorsOrValidator: IdentifierVali
  * True if identifier validator is a numeric identifier validator.
  */
 export function isNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NumericIdentifierValidator {
-    return isNumericIdentifierDescriptor(identifierValidator);
+    return isNumericIdentifierExtension(identifierValidator);
 }
 
 /**
@@ -160,7 +162,7 @@ export function isNumericIdentifierValidator(identifierValidator: IdentifierVali
  * True if identifier validator is a GTIN validator.
  */
 export function isGTINValidator(identifierValidator: IdentifierValidator): identifierValidator is GTINValidator {
-    return isGTINDescriptor(identifierValidator);
+    return isGTINExtension(identifierValidator);
 }
 
 /**
@@ -173,7 +175,20 @@ export function isGTINValidator(identifierValidator: IdentifierValidator): ident
  * True if identifier validator is a non-GTIN numeric identifier validator.
  */
 export function isNonGTINNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonGTINNumericIdentifierValidator {
-    return isNonGTINNumericIdentifierDescriptor(identifierValidator);
+    return isNonGTINNumericIdentifierExtension(identifierValidator);
+}
+
+/**
+ * Determine if identifier validator is a non-serializable numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a non-serializable numeric identifier validator.
+ */
+export function isNonSerializableNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonSerializableNumericIdentifierValidator {
+    return isNonSerializableNumericIdentifierExtension(identifierValidator);
 }
 
 /**
@@ -186,7 +201,7 @@ export function isNonGTINNumericIdentifierValidator(identifierValidator: Identif
  * True if identifier validator is a serializable numeric identifier validator.
  */
 export function isSerializableNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is SerializableNumericIdentifierValidator {
-    return isSerializableNumericIdentifierDescriptor(identifierValidator);
+    return isSerializableNumericIdentifierExtension(identifierValidator);
 }
 
 /**
@@ -199,5 +214,5 @@ export function isSerializableNumericIdentifierValidator(identifierValidator: Id
  * True if identifier validator is a non-numeric identifier validator.
  */
 export function isNonNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonNumericIdentifierValidator {
-    return isNonNumericIdentifierDescriptor(identifierValidator);
+    return isNonNumericIdentifierExtension(identifierValidator);
 }

package/src/index.ts

@@ -27,34 +27,40 @@ export * from "./prefix-validator.js";
 export * from "./content-character-set.js";
 
 export * from "./identifier-type.js";
+export * from "./leader-type.js";
 export * from "./numeric-identifier-type.js";
 export * from "./gtin-type.js";
-export type * from "./non-gtin-numeric-identifier-type.js";
-export type * from "./serializable-numeric-identifier-type.js";
-export type * from "./non-numeric-identifier-type.js";
+export * from "./non-gtin-numeric-identifier-type.js";
+export * from "./non-serializable-numeric-identifier-type.js";
+export * from "./serializable-numeric-identifier-type.js";
+export * from "./non-numeric-identifier-type.js";
 
 export type * from "./identifier-descriptor.js";
 export type * from "./numeric-identifier-descriptor.js";
+export * from "./gtin-length.js";
 export type * from "./gtin-descriptor.js";
 export type * from "./non-gtin-numeric-identifier-descriptor.js";
+export type * from "./non-serializable-numeric-identifier-descriptor.js";
 export type * from "./serializable-numeric-identifier-descriptor.js";
 export type * from "./non-numeric-identifier-descriptor.js";
-export * from "./descriptors.js";
+export * from "./identifier-descriptors.js";
 
-export type * from "./identifier-validator.js";
-export type * from "./numeric-identifier-validator.js";
+export * from "./identifier-validator.js";
+export * from "./numeric-identifier-validator.js";
 export { GTINLevels, type GTINLevelKey, type GTINLevel, type RCNReference, GTINValidator } from "./gtin-validator.js";
 export * from "./non-gtin-numeric-identifier-validator.js";
+export * from "./non-serializable-numeric-identifier-validator.js";
 export * from "./serializable-numeric-identifier-validator.js";
 export * from "./non-numeric-identifier-validator.js";
-export * from "./validators.js";
+export * from "./identifier-validators.js";
 
 export type * from "./identifier-creator.js";
 export type * from "./numeric-identifier-creator.js";
 export * from "./gtin-creator.js";
-export * from "./non-gtin-numeric-identifier-creator.js";
+export type * from "./non-gtin-numeric-identifier-creator.js";
+export * from "./non-serializable-numeric-identifier-creator.js";
 export * from "./serializable-numeric-identifier-creator.js";
 export * from "./non-numeric-identifier-creator.js";
-export * from "./creators.js";
+export * from "./identifier-creators.js";
 
 export * from "./prefix-manager.js";

package/src/leader-type.ts

@@ -0,0 +1,29 @@
+/**
+ * Leader type.
+ */
+export const LeaderTypes = {
+    /**
+     * No leader.
+     */
+    None: "None",
+
+    /**
+     * Indicator digit (GTIN only).
+     */
+    IndicatorDigit: "Indicator digit",
+
+    /**
+     * Extension digit (SSCC only).
+     */
+    ExtensionDigit: "Extension digit"
+} as const;
+
+/**
+ * Leader type key.
+ */
+export type LeaderTypeKey = keyof typeof LeaderTypes;
+
+/**
+ * Leader type.
+ */
+export type LeaderType = typeof LeaderTypes[LeaderTypeKey];

package/src/non-gtin-numeric-identifier-creator.ts

@@ -1,27 +1,12 @@
-import { Mixin } from "ts-mixer";
-import { AbstractNumericIdentifierCreator } from "./abstract-numeric-identifier-creator.js";
 import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type.js";
-import { NonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
-import type { PrefixProvider } from "./prefix-provider.js";
-import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
+import type { NonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import type { NumericIdentifierCreator } from "./numeric-identifier-creator.js";
 
 /**
- * Non-GTIN numeric identifier creator.
+ * Non-GTIN numeric identifier creator. Creates one or many non-GTIN numeric identifiers.
+ *
+ * @template TNonGTINNumericIdentifierType
+ * Non-GTIN numeric identifier type type.
  */
-export class NonGTINNumericIdentifierCreator extends Mixin(NonGTINNumericIdentifierValidator, AbstractNumericIdentifierCreator) {
-    /**
-     * Constructor. Typically called internally by a prefix manager but may be called by other code with another prefix
-     * provider type.
-     *
-     * @param prefixProvider
-     * Prefix provider.
-     *
-     * @param identifierType
-     * Identifier type.
-     */
-    constructor(prefixProvider: PrefixProvider, identifierType: Exclude<NonGTINNumericIdentifierType, SerializableNumericIdentifierType>) {
-        super(identifierType);
-
-        this.init(prefixProvider, prefixProvider.gs1CompanyPrefix);
-    }
+export interface NonGTINNumericIdentifierCreator<TNonGTINNumericIdentifierType extends NonGTINNumericIdentifierType = NonGTINNumericIdentifierType> extends NonGTINNumericIdentifierValidator<TNonGTINNumericIdentifierType>, NumericIdentifierCreator<TNonGTINNumericIdentifierType> {
 }

package/src/non-gtin-numeric-identifier-descriptor.ts

@@ -1,6 +1,6 @@
+import type { LeaderType, LeaderTypes } from "./leader-type.js";
 import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type.js";
 import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
-import type { LeaderType, LeaderTypes } from "./numeric-identifier-type.js";
 import type { PrefixTypes } from "./prefix-type.js";
 
 /**

package/src/non-gtin-numeric-identifier-type.ts

@@ -1,7 +1,18 @@
-import type { IdentifierTypes } from "./identifier-type.js";
-import type { NumericIdentifierType } from "./numeric-identifier-type.js";
+import { exclude } from "@aidc-toolkit/core";
+import { GTINTypes } from "./gtin-type.js";
+import { NumericIdentifierTypes } from "./numeric-identifier-type.js";
+
+/**
+ * Non-GTIN numeric identifier types.
+ */
+export const NonGTINNumericIdentifierTypes = exclude(NumericIdentifierTypes, GTINTypes);
+
+/**
+ * Non-GTIN numeric identifier type key.
+ */
+export type NonGTINNumericIdentifierTypeKey = keyof typeof NonGTINNumericIdentifierTypes;
 
 /**
  * Non-GTIN numeric identifier type.
  */
-export type NonGTINNumericIdentifierType = Exclude<NumericIdentifierType, typeof IdentifierTypes.GTIN>;
+export type NonGTINNumericIdentifierType = typeof NonGTINNumericIdentifierTypes[NonGTINNumericIdentifierTypeKey];

package/src/non-gtin-numeric-identifier-validator.ts

@@ -1,20 +1,12 @@
-import { AbstractNumericIdentifierValidator } from "./abstract-numeric-identifier-validator.js";
-import { IdentifierDescriptors } from "./descriptors.js";
 import type { NonGTINNumericIdentifierDescriptor } from "./non-gtin-numeric-identifier-descriptor.js";
 import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type.js";
-import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
+import { NumericIdentifierValidator } from "./numeric-identifier-validator.js";
 
 /**
  * Non-GTIN numeric identifier validator.
+ *
+ * @template TNonGTINNumericIdentifierType
+ * Non-GTIN numeric identifier type type.
  */
-export class NonGTINNumericIdentifierValidator extends AbstractNumericIdentifierValidator<NonGTINNumericIdentifierDescriptor> {
-    /**
-     * Constructor.
-     *
-     * @param identifierType
-     * Identifier type.
-     */
-    constructor(identifierType: Exclude<NonGTINNumericIdentifierType, SerializableNumericIdentifierType>) {
-        super(IdentifierDescriptors[identifierType]);
-    }
+export abstract class NonGTINNumericIdentifierValidator<TNonGTINNumericIdentifierType extends NonGTINNumericIdentifierType = NonGTINNumericIdentifierType> extends NumericIdentifierValidator<TNonGTINNumericIdentifierType> implements NonGTINNumericIdentifierDescriptor {
 }