@aidc-toolkit/gs1 0.9.3 → 0.9.5

package/dist/index.d.ts

@@ -0,0 +1,1436 @@
+import { CharacterSetCreator, StringValidation, StringValidator, CharacterSetValidator, CharacterSetValidation, Exclusion } from '@aidc-toolkit/utility';
+import * as ts_mixer_dist_types_types_js from 'ts-mixer/dist/types/types.js';
+
+/**
+ * GS1 AI encodable character set 82 creator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs | GS1
+ * General Specifications}. Supports {@linkcode Exclusion.AllNumeric}.
+ */
+declare const AI82_CREATOR: CharacterSetCreator;
+/**
+ * GS1 AI encodable character set 39 creator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs | GS1
+ * General Specifications}. Supports {@linkcode Exclusion.AllNumeric}.
+ */
+declare const AI39_CREATOR: CharacterSetCreator;
+
+/**
+ * Calculate the check digit sum for a numeric string as per section 7.9.1 of the {@link https://www.gs1.org/genspecs |
+ * GS1 General Specifications}.
+ *
+ * @param exchangeWeights
+ * If true, start the weights at 1 instead of 3 on the right.
+ *
+ * @param s
+ * Numeric string.
+ *
+ * @returns
+ * Accumulated sum of each digit multiplied by the weight at its position.
+ */
+declare function checkDigitSum(exchangeWeights: boolean, s: string): number;
+/**
+ * Calculate the check digit for a numeric string as per section 7.9.1 of the {@link https://www.gs1.org/genspecs | GS1
+ * General Specifications}.
+ *
+ * @param s
+ * Numeric string.
+ *
+ * @returns
+ * Check digit 0-9 as a string.
+ */
+declare function checkDigit(s: string): string;
+/**
+ * Determine if a numeric string has a valid check digit.
+ *
+ * @param s
+ * Numeric string with check digit.
+ *
+ * @returns
+ * True if the check digit is valid.
+ */
+declare function hasValidCheckDigit(s: string): boolean;
+/**
+ * Calculate the price/weight check digit for a four-digit numeric string as per section 7.9.3 of the {@link
+ * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ *
+ * @param s
+ * Numeric string exactly four characters long.
+ *
+ * @returns
+ * Check digit 0-9 as a string.
+ */
+declare function fourDigitPriceWeightCheckDigit(s: string): string;
+/**
+ * Calculate the price/weight check digit for a five-digit numeric string as per section 7.9.3 of the {@link
+ * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ *
+ * @param s
+ * Numeric string exactly five characters long.
+ *
+ * @returns
+ * Check digit 0-9 as a string.
+ */
+declare function fiveDigitPriceWeightCheckDigit(s: string): string;
+/**
+ * Calculate the check character for a GS1 AI encodable character set 82 string as per section 7.9.5 of the {@link
+ * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ *
+ * @param s
+ * GS1 AI encodable character set 82 string.
+ *
+ * @returns
+ * Check character pair.
+ */
+declare function checkCharacterPair(s: string): string;
+/**
+ * Determine if a GS1 AI encodable character set 82 string has a valid check character pair.
+ *
+ * @param s
+ * GS1 AI encodable character set 82 string with check character pair.
+ *
+ * @returns
+ * True if the check character pair is valid.
+ */
+declare function hasValidCheckCharacterPair(s: string): boolean;
+
+/**
+ * Identification key type.
+ */
+declare enum IdentificationKeyType {
+    /**
+     * Global Trade Item Number.
+     */
+    GTIN = "GTIN",
+    /**
+     * Global Location Number.
+     */
+    GLN = "GLN",
+    /**
+     * Serial Shipping Container Code.
+     */
+    SSCC = "SSCC",
+    /**
+     * Global Returnable Asset Identifier.
+     */
+    GRAI = "GRAI",
+    /**
+     * Global Individual Asset Identifier.
+     */
+    GIAI = "GIAI",
+    /**
+     * Global Service Relation Number.
+     */
+    GSRN = "GSRN",
+    /**
+     * Global Document Type Identifier.
+     */
+    GDTI = "GDTI",
+    /**
+     * Global Identification Number for Consignment.
+     */
+    GINC = "GINC",
+    /**
+     * Global Shipment Identification Number.
+     */
+    GSIN = "GSIN",
+    /**
+     * Global Coupon Number.
+     */
+    GCN = "GCN",
+    /**
+     * Component/Part Identifier.
+     */
+    CPID = "CPID",
+    /**
+     * Global Model Number.
+     */
+    GMN = "GMN"
+}
+/**
+ * Prefix type.
+ */
+declare enum PrefixType {
+    /**
+     * GS1 Company Prefix.
+     */
+    GS1CompanyPrefix = 0,
+    /**
+     * U.P.C. Company Prefix.
+     */
+    UPCCompanyPrefix = 1,
+    /**
+     * GS1-8 Prefix.
+     */
+    GS18Prefix = 2
+}
+/**
+ * Character set supported by the reference portion of an identification key or the serial component of a numeric
+ * identification key.
+ */
+declare enum CharacterSet {
+    /**
+     * Numeric.
+     */
+    Numeric = 0,
+    /**
+     * GS1 AI encodable character set 82.
+     */
+    AI82 = 1,
+    /**
+     * GS1 AI encodable character set 39.
+     */
+    AI39 = 2
+}
+/**
+ * Identification key validation parameters.
+ */
+interface IdentificationKeyValidation extends StringValidation {
+    /**
+     * Position offset within a larger string. Strings are sometimes composed of multiple substrings; this parameter
+     * ensures that the error notes the proper position in the string.
+     */
+    positionOffset?: number | undefined;
+}
+/**
+ * Identification key validator. Validates an identification key against its definition in section 3 of the {@link
+ * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ */
+interface IdentificationKeyValidator<V extends IdentificationKeyValidation = IdentificationKeyValidation> extends StringValidator<V> {
+    /**
+     * Get the identification key type. Per the GS1 General Specifications, the identification key type determines
+     * the remaining properties.
+     */
+    get identificationKeyType(): IdentificationKeyType;
+    /**
+     * Get the prefix type supported by the identification key type. For all identification key types except the GTIN,
+     * this is {@linkcode PrefixType.GS1CompanyPrefix}. For the GTIN, the prefix type determines the length.
+     */
+    get prefixType(): PrefixType;
+    /**
+     * Get the length. For numeric identification key types, the length is fixed; for alphanumeric identification key
+     * types, the length is the maximum.
+     */
+    get length(): number;
+    /**
+     * Get the reference character set.
+     */
+    get referenceCharacterSet(): CharacterSet;
+    /**
+     * Get the reference validator.
+     */
+    get referenceValidator(): CharacterSetValidator;
+    /**
+     * Validate an identification key and throw an error if validation fails.
+     *
+     * @param identificationKey
+     * Identification key.
+     *
+     * @param validation
+     * Identification key validation parameters.
+     */
+    validate: (identificationKey: string, validation?: V) => void;
+}
+/**
+ * Abstract identification key validator. Implements common functionality for an identification key validator.
+ */
+declare abstract class AbstractIdentificationKeyValidator<V extends IdentificationKeyValidation = IdentificationKeyValidation> implements IdentificationKeyValidator<V> {
+    private static readonly CHARACTER_SET_CREATORS;
+    /**
+     * Identification key type.
+     */
+    private readonly _identificationKeyType;
+    /**
+     * Prefix type.
+     */
+    private readonly _prefixType;
+    /**
+     * Length.
+     */
+    private readonly _length;
+    /**
+     * Reference character set.
+     */
+    private readonly _referenceCharacterSet;
+    /**
+     * Reference validator.
+     */
+    private readonly _referenceValidator;
+    /**
+     * Get the character set validator for a character set.
+     *
+     * @param characterSet
+     * Character set.
+     *
+     * @returns
+     * Character set validator.
+     */
+    protected static validatorFor(characterSet: CharacterSet): CharacterSetValidator;
+    /**
+     * Constructor.
+     *
+     * @param identificationKeyType
+     * Identification key type.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param referenceCharacterSet
+     * Reference character set.
+     */
+    protected constructor(identificationKeyType: IdentificationKeyType, prefixType: PrefixType, length: number, referenceCharacterSet: CharacterSet);
+    /**
+     * @inheritDoc
+     */
+    get identificationKeyType(): IdentificationKeyType;
+    /**
+     * @inheritDoc
+     */
+    get prefixType(): PrefixType;
+    /**
+     * @inheritDoc
+     */
+    get length(): number;
+    /**
+     * @inheritDoc
+     */
+    get referenceCharacterSet(): CharacterSet;
+    /**
+     * @inheritDoc
+     */
+    get referenceValidator(): CharacterSetValidator;
+    /**
+     * Pad an identification key on the left with zero-value character for validation purposes. This is done to align an
+     * identification key with a position offset for any error message that may be thrown by the reference validator.
+     *
+     * @param identificationKey
+     * Identification key.
+     *
+     * @param validation
+     * Identification key validation parameters.
+     *
+     * @returns
+     * Padded identification key.
+     */
+    protected padIdentificationKey(identificationKey: string, validation: IdentificationKeyValidation | undefined): string;
+    /**
+     * Validate the prefix within an identification key.
+     *
+     * @param partialIdentificationKey
+     * Partial identification key.
+     *
+     * @param positionOffset
+     * Position offset within a larger string.
+     */
+    protected validatePrefix(partialIdentificationKey: string, positionOffset?: number): void;
+    abstract validate(identificationKey: string, validation?: V): void;
+}
+/**
+ * Leader type.
+ */
+declare enum LeaderType {
+    /**
+     * No leader.
+     */
+    None = 0,
+    /**
+     * Indicator digit (GTIN only).
+     */
+    IndicatorDigit = 1,
+    /**
+     * Extension digit (SSCC only).
+     */
+    ExtensionDigit = 2
+}
+/**
+ * Numeric identification key validator. Validates a numeric identification key.
+ */
+interface NumericIdentificationKeyValidator extends IdentificationKeyValidator {
+    /**
+     * Get the leader type.
+     */
+    get leaderType(): LeaderType;
+}
+/**
+ * Abstract numeric identification key validator. Implements common functionality for a numeric identification key
+ * validator.
+ */
+declare abstract class AbstractNumericIdentificationKeyValidator extends AbstractIdentificationKeyValidator implements NumericIdentificationKeyValidator {
+    /**
+     * Leader type.
+     */
+    private readonly _leaderType;
+    /**
+     * Prefix position, determined by the leader type.
+     */
+    private readonly _prefixPosition;
+    /**
+     * Constructor.
+     *
+     * @param identificationKeyType
+     * Identification key type.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param leaderType
+     * Leader type.
+     */
+    protected constructor(identificationKeyType: IdentificationKeyType, prefixType: PrefixType, length: number, leaderType: LeaderType);
+    /**
+     * @inheritDoc
+     */
+    get leaderType(): LeaderType;
+    /**
+     * @inheritDoc
+     */
+    validate(identificationKey: string, validation?: IdentificationKeyValidation): void;
+}
+/**
+ * GTIN type. The numeric values of this enumeration are equal to the lengths of the GTIN types.
+ */
+declare enum GTINType {
+    /**
+     * GTIN-13.
+     */
+    GTIN13 = 13,
+    /**
+     * GTIN-12.
+     */
+    GTIN12 = 12,
+    /**
+     * GTIN-8.
+     */
+    GTIN8 = 8,
+    /**
+     * GTIN-14.
+     */
+    GTIN14 = 14
+}
+/**
+ * Level at which GTIN is to be validated.
+ */
+declare enum GTINLevel {
+    /**
+     * Any level (level is ignored).
+     */
+    Any = 0,
+    /**
+     * Retail consumer trade item level, supporting GTIN-13, GTIN-12 (optionally zero-suppressed), and GTIN-8.
+     */
+    RetailConsumer = 1,
+    /**
+     * Other than retail consumer trade item level, supporting GTIN-13, GTIN-12 (not zero-suppressed), and GTIN-14.
+     */
+    OtherThanRetailConsumer = 2
+}
+/**
+ * GTIN validator.
+ */
+declare class GTINValidator extends AbstractNumericIdentificationKeyValidator {
+    /**
+     * Zero-suppressed GTIN-12 validation parameters.
+     */
+    private static readonly ZERO_SUPPRESSED_GTIN12_VALIDATION;
+    /**
+     * Constructor.
+     *
+     * @param gtinType
+     * GTIN type.
+     */
+    constructor(gtinType: GTINType);
+    /**
+     * @inheritDoc
+     */
+    get gtinType(): GTINType;
+    /**
+     * @inheritDoc
+     */
+    protected validatePrefix(partialIdentificationKey: string, positionOffset?: number): void;
+    /**
+     * Zero expand a zero-suppressed GTIN-12.
+     *
+     * @param zeroSuppressedGTIN12
+     * Zero-suppressed GTIN-12.
+     *
+     * @returns
+     * GTIN-12.
+     */
+    static zeroExpand(zeroSuppressedGTIN12: string): string;
+    /**
+     * Validate any GTIN, optionally against a level.
+     *
+     * @param gtin
+     * GTIN.
+     *
+     * @param gtinLevel
+     * Level at which GTIN is to be validated.
+     */
+    static validateAny(gtin: string, gtinLevel?: GTINLevel): void;
+    /**
+     * Validate a GTIN-14.
+     *
+     * @param gtin14
+     * GTIN-14.
+     */
+    static validateGTIN14(gtin14: string): void;
+}
+/**
+ * Non-GTIN numeric identification key validator.
+ */
+declare class NonGTINNumericIdentificationKeyValidator extends AbstractNumericIdentificationKeyValidator {
+    /**
+     * Constructor.
+     *
+     * @param identificationKeyType
+     * Identification key type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param leaderType
+     * Leader type.
+     */
+    constructor(identificationKeyType: IdentificationKeyType, length: number, leaderType?: LeaderType);
+}
+/**
+ * Serializable numeric identification key validator. Validates both serialized and non-serialized forms of
+ * numeric identification keys that support serialization.
+ */
+declare class SerializableNumericIdentificationKeyValidator extends NonGTINNumericIdentificationKeyValidator {
+    /**
+     * Serial component length.
+     */
+    private readonly _serialComponentLength;
+    /**
+     * Serial component character set.
+     */
+    private readonly _serialComponentCharacterSet;
+    /**
+     * Serial component validation parameters.
+     */
+    private readonly _serialComponentValidation;
+    /**
+     * Serial component validator.
+     */
+    private readonly _serialComponentValidator;
+    /**
+     * Constructor.
+     *
+     * @param identificationKeyType
+     * Identification key type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param serialComponentLength
+     * Serial component length.
+     *
+     * @param serialComponentCharacterSet
+     * Serial component character set.
+     */
+    constructor(identificationKeyType: IdentificationKeyType, length: number, serialComponentLength: number, serialComponentCharacterSet: CharacterSet);
+    /**
+     * Get the serial component length.
+     */
+    get serialComponentLength(): number;
+    /**
+     * Get the serial component character set.
+     */
+    get serialComponentCharacterSet(): CharacterSet;
+    /**
+     * Get the serial component validation parameters.
+     */
+    protected get serialComponentValidation(): CharacterSetValidation;
+    /**
+     * Get the serial component validator.
+     */
+    get serialComponentValidator(): CharacterSetValidator;
+    /**
+     * @inheritDoc
+     */
+    validate(identificationKey: string, validation?: IdentificationKeyValidation): void;
+}
+/**
+ * Non-numeric identification key validation parameters.
+ */
+interface NonNumericIdentificationKeyValidation extends IdentificationKeyValidation {
+    /**
+     * Exclusion support for reference. Prevents non-numeric identification key from being mistaken for numeric
+     * identification key.
+     */
+    exclusion?: Exclusion.None | Exclusion.AllNumeric | undefined;
+}
+/**
+ * Non-numeric identification key validator.
+ */
+declare class NonNumericIdentificationKeyValidator extends AbstractIdentificationKeyValidator<NonNumericIdentificationKeyValidation> {
+    /**
+     * Validator to ensure that an identification key (minus check character pair) is not all numeric.
+     */
+    private static readonly NOT_ALL_NUMERIC_VALIDATOR;
+    /**
+     * True if the identification key requires a check character pair.
+     */
+    private readonly _requiresCheckCharacterPair;
+    /**
+     * Constructor.
+     *
+     * @param identificationKeyType
+     * Identification key type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param referenceCharacterSet
+     * Reference character set.
+     *
+     * @param requiresCheckCharacterPair
+     * True if the identification key requires a check character pair.
+     */
+    constructor(identificationKeyType: IdentificationKeyType, length: number, referenceCharacterSet: CharacterSet, requiresCheckCharacterPair?: boolean);
+    /**
+     * Determine if the identification key requires a check character pair.
+     */
+    get requiresCheckCharacterPair(): boolean;
+    /**
+     * Validate a non-numeric identification key and throw an error if validation fails.
+     *
+     * @param identificationKey
+     * Identification key.
+     *
+     * @param validation
+     * Validation parameters.
+     */
+    validate(identificationKey: string, validation?: NonNumericIdentificationKeyValidation): void;
+}
+/**
+ * GTIN-13 validator.
+ */
+declare const GTIN13_VALIDATOR: GTINValidator;
+/**
+ * GTIN-12 validator.
+ */
+declare const GTIN12_VALIDATOR: GTINValidator;
+/**
+ * GTIN-8 validator.
+ */
+declare const GTIN8_VALIDATOR: GTINValidator;
+/**
+ * GTIN validators indexed by prefix type.
+ */
+declare const GTIN_VALIDATORS: GTINValidator[];
+/**
+ * GLN validator.
+ */
+declare const GLN_VALIDATOR: NonGTINNumericIdentificationKeyValidator;
+/**
+ * SSCC validator.
+ */
+declare const SSCC_VALIDATOR: NonGTINNumericIdentificationKeyValidator;
+/**
+ * GRAI validator.
+ */
+declare const GRAI_VALIDATOR: SerializableNumericIdentificationKeyValidator;
+/**
+ * GIAI validator.
+ */
+declare const GIAI_VALIDATOR: NonNumericIdentificationKeyValidator;
+/**
+ * GSRN validator.
+ */
+declare const GSRN_VALIDATOR: NonGTINNumericIdentificationKeyValidator;
+/**
+ * GDTI validator.
+ */
+declare const GDTI_VALIDATOR: SerializableNumericIdentificationKeyValidator;
+/**
+ * GINC validator.
+ */
+declare const GINC_VALIDATOR: NonNumericIdentificationKeyValidator;
+/**
+ * GSIN validator.
+ */
+declare const GSIN_VALIDATOR: NonGTINNumericIdentificationKeyValidator;
+/**
+ * GCN validator.
+ */
+declare const GCN_VALIDATOR: SerializableNumericIdentificationKeyValidator;
+/**
+ * CPID validator.
+ */
+declare const CPID_VALIDATOR: NonNumericIdentificationKeyValidator;
+/**
+ * GMN validator.
+ */
+declare const GMN_VALIDATOR: NonNumericIdentificationKeyValidator;
+/**
+ * Identification key creator. Creates an identification key based on its definition in section 3 of the {@link
+ * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ *
+ * Keys are created based on a prefix defined in a prefix manager to which the identification key creator is bound.
+ */
+interface IdentificationKeyCreator extends IdentificationKeyValidator {
+    /**
+     * Get the reference creator.
+     */
+    get referenceCreator(): CharacterSetCreator;
+    /**
+     * Get the prefix manager to which this identification key creator is bound.
+     */
+    get prefixManager(): PrefixManager;
+    /**
+     * Get the prefix, equivalent to calling {@linkcode PrefixManager.prefix | prefixManager.prefix} for a GTIN or
+     * {@linkcode PrefixManager.gs1CompanyPrefix | prefixManager.gs1CompanyPrefix} for all other identification key
+     * types.
+     */
+    get prefix(): string;
+    /**
+     * Get the reference length.
+     */
+    get referenceLength(): number;
+}
+/**
+ * Abstract identification key creator. Implements common functionality for an identification key creator, bound to a
+ * {@link PrefixManager}.
+ */
+declare abstract class AbstractIdentificationKeyCreator implements IdentificationKeyCreator {
+    /**
+     * Prefix manager.
+     */
+    private _prefixManager;
+    /**
+     * Reference length.
+     */
+    private _referenceLength;
+    /**
+     * Initialize the prefix manager. This method is in lieu of a constructor due to the mixin architecture.
+     *
+     * @param prefixManager
+     * Prefix manager.
+     *
+     * @param prefix
+     * Prefix within prefix manager to use to calculate reference length.
+     *
+     * @param checkAllowance
+     * Number of characters to allow for check digit or check character pair.
+     */
+    protected init(prefixManager: PrefixManager, prefix: string, checkAllowance: number): void;
+    abstract get identificationKeyType(): IdentificationKeyType;
+    abstract get prefixType(): PrefixType;
+    abstract get length(): number;
+    abstract get referenceCharacterSet(): CharacterSet;
+    abstract get referenceValidator(): CharacterSetValidator;
+    /**
+     * @inheritDoc
+     */
+    get referenceCreator(): CharacterSetCreator;
+    /**
+     * @inheritDoc
+     */
+    get prefixManager(): PrefixManager;
+    /**
+     * @inheritDoc
+     */
+    get prefix(): string;
+    /**
+     * @inheritDoc
+     */
+    get referenceLength(): number;
+    abstract validate(identificationKey: string, validation?: IdentificationKeyValidation): void;
+}
+/**
+ * Numeric identification key creator. Creates one or many numeric identification keys.
+ */
+interface NumericIdentificationKeyCreator extends NumericIdentificationKeyValidator, IdentificationKeyCreator {
+    /**
+     * Get the capacity (`10**referenceLength`).
+     */
+    get capacity(): number;
+    create: {
+        /**
+         * Create an identification key with a reference based on a numeric value. The value is converted to a reference of
+         * the appropriate length using {@linkcode NUMERIC_CREATOR}.
+         *
+         * @param value
+         * Numeric value.
+         *
+         * @param sparse
+         * If true, the value is mapped to a sparse sequence resistant to discovery. Default is false.
+         *
+         * @returns
+         * Identification key.
+         */
+        (value: number | bigint, sparse?: boolean): string;
+        /**
+         * Create identification keys with references based on numeric values. The values are converted to references of
+         * the appropriate length using {@linkcode NUMERIC_CREATOR}.
+         *
+         * @param values
+         * Numeric values.
+         *
+         * @param sparse
+         * If true, the values are mapped to a sparse sequence resistant to discovery. Default is false.
+         *
+         * @returns
+         * Identification keys.
+         */
+        (values: Iterable<number | bigint>, sparse?: boolean): IterableIterator<string>;
+    };
+    /**
+     * 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.
+     *
+     * @returns
+     * Iterable iterator over created identification keys.
+     */
+    createAll: () => IterableIterator<string>;
+}
+/**
+ * Abstract numeric identification key creator. Implements common functionality for a numeric identification key creator.
+ */
+declare abstract class AbstractNumericIdentificationKeyCreator extends AbstractIdentificationKeyCreator implements NumericIdentificationKeyCreator {
+    /**
+     * Capacity.
+     */
+    private _capacity;
+    /**
+     * Tweak for sparse creation.
+     */
+    private _tweak;
+    /**
+     * Initialize the prefix manager. This method is in lieu of a constructor due to the mixin architecture.
+     *
+     * @param prefixManager
+     * Prefix manager.
+     *
+     * @param prefix
+     * Prefix within prefix manager to use to calculate reference length.
+     */
+    protected init(prefixManager: PrefixManager, prefix: string): void;
+    abstract get leaderType(): LeaderType;
+    /**
+     * @inheritDoc
+     */
+    get capacity(): number;
+    /**
+     * Get the tweak for sparse creation.
+     */
+    get tweak(): bigint;
+    /**
+     * Set the tweak for sparse creation.
+     */
+    set tweak(value: bigint);
+    /**
+     * Build an identification key from a reference by merging it with the prefix and adding the check digit.
+     *
+     * @param reference
+     * Identification key reference.
+     *
+     * @returns
+     * Identification key.
+     */
+    private buildIdentificationKey;
+    /**
+     * @inheritDoc
+     */
+    create(value: number | bigint, sparse?: boolean): string;
+    /**
+     * @inheritDoc
+     */
+    create(values: Iterable<number | bigint>, sparse?: boolean): IterableIterator<string>;
+    /**
+     * Create all identification keys from a partial identification key. Call is recursive until remaining reference
+     * length is 0.
+     *
+     * @param partialIdentificationKey
+     * Partial identification key. Initial value is `this.prefix`.
+     *
+     * @param remainingReferenceLength
+     * Remaining reference length. Initial value is `this.referenceLength`.
+     *
+     * @param extensionWeight
+     * If this value is not zero, the identification key has an extension digit, this call is setting it, and this value
+     * is applied to the calculation of the check digit.
+     *
+     * @param weight
+     * If the extension weight is zero, this value is applied to the calculation of the check digit.
+     *
+     * @param partialCheckDigitSum
+     * Partial check digit sum for the partial identification key.
+     *
+     * @yields
+     * Identification key.
+     */
+    private static createAllPartial;
+    /**
+     * @inheritDoc
+     */
+    createAll(): IterableIterator<string>;
+}
+declare const GTINCreator_base: ts_mixer_dist_types_types_js.Class<any[], GTINValidator & AbstractNumericIdentificationKeyCreator, typeof GTINValidator & typeof AbstractNumericIdentificationKeyCreator>;
+/**
+ * GTIN creator. Applicable to GTIN-13, GTIN-12, and GTIN-8 types; no applicable to GTIN-14 type.
+ */
+declare class GTINCreator extends GTINCreator_base {
+    /**
+     * Validation parameters for required indicator digit.
+     */
+    private static readonly REQUIRED_INDICATOR_DIGIT_VALIDATION;
+    /**
+     * Validation parameters for optional indicator digit.
+     */
+    private static readonly OPTIONAL_INDICATOR_DIGIT_VALIDATION;
+    /**
+     * Constructor. Called internally by {@link PrefixManager.gtinCreator}; should not be called by other code.
+     *
+     * @param prefixManager
+     * Prefix manager.
+     *
+     * @param gtinType
+     * GTIN type.
+     */
+    constructor(prefixManager: PrefixManager, gtinType: GTINType);
+    /**
+     * @inheritDoc
+     */
+    get prefix(): string;
+    /**
+     * Create a GTIN-14 with an indicator digit and a reference based on a numeric value. The value is converted to a
+     * reference of the appropriate length using {@linkcode NUMERIC_CREATOR}.
+     *
+     * @param indicatorDigit
+     * Indicator digit.
+     *
+     * @param value
+     * Numeric value of the reference.
+     *
+     * @param sparse
+     * If true, the value is mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * GTIN-14.
+     */
+    createGTIN14(indicatorDigit: string, value: number | bigint, sparse?: boolean): string;
+    /**
+     * Create multiple GTIN-14s with an indicator digit and references based on numeric values. The values are converted
+     * to references of the appropriate length using {@linkcode NUMERIC_CREATOR}.
+     *
+     * The implementation uses {@link CharacterSetCreator.create}, so the values are created only as needed.
+     *
+     * @param indicatorDigit
+     * Indicator digit.
+     *
+     * @param values
+     * Values.
+     *
+     * @param sparse
+     * If true, the values are mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * Iterable iterator over created GTIN-14s.
+     */
+    createGTIN14(indicatorDigit: string, values: Iterable<number | bigint>, sparse?: boolean): IterableIterator<string>;
+    /**
+     * Zero suppress a GTIN-12.
+     *
+     * @param gtin12
+     * GTIN-12.
+     *
+     * @returns
+     * Zero-suppressed GTIN-12.
+     */
+    static zeroSuppress(gtin12: string): string;
+    /**
+     * Convert a GTIN of any length to a GTIN-14 with an optional indicator digit.
+     *
+     * @param indicatorDigit
+     * Indicator digit. If blank, assumes "0" if the GTIN is not already a GTIN-14.
+     *
+     * @param gtin
+     * GTIN.
+     *
+     * @returns
+     * GTIN-14.
+     */
+    static convertToGTIN14(indicatorDigit: string, gtin: string): string;
+    /**
+     * Normalize a GTIN of any length.
+     * - A GTIN-14 that starts with six zeros or a GTIN-13 that starts with five zeros is normalized to GTIN-8.
+     * - A GTIN-14 that starts with two zeros or a GTIN-13 that starts with one zero is normalized to GTIN-12.
+     * - A GTIN-14 that starts with one zero is normalized to GTIN-13.
+     * - Otherwise, the GTIN is unchanged.
+     *
+     * @param gtin
+     * GTIN.
+     *
+     * @returns
+     * Normalized GTIN.
+     */
+    static normalize(gtin: string): string;
+}
+declare const NonGTINNumericIdentificationKeyCreator_base: ts_mixer_dist_types_types_js.Class<any[], NonGTINNumericIdentificationKeyValidator & AbstractNumericIdentificationKeyCreator, typeof NonGTINNumericIdentificationKeyValidator & typeof AbstractNumericIdentificationKeyCreator>;
+/**
+ * Non-GTIN numeric identification key creator.
+ */
+declare class NonGTINNumericIdentificationKeyCreator extends NonGTINNumericIdentificationKeyCreator_base {
+    /**
+     * Constructor. Called internally by {@link PrefixManager} non-GTIN numeric identification key creator getters;
+     * should not be called by other code.
+     *
+     * @param prefixManager
+     * Prefix manager.
+     *
+     * @param identificationKeyType
+     * Identification key type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param leaderType
+     * Leader type.
+     */
+    constructor(prefixManager: PrefixManager, identificationKeyType: IdentificationKeyType, length: number, leaderType?: LeaderType);
+}
+declare const SerializableNumericIdentificationKeyCreator_base: ts_mixer_dist_types_types_js.Class<any[], SerializableNumericIdentificationKeyValidator & AbstractNumericIdentificationKeyCreator, typeof SerializableNumericIdentificationKeyValidator & typeof AbstractNumericIdentificationKeyCreator>;
+/**
+ * Serializable numeric identification key creator.
+ */
+declare class SerializableNumericIdentificationKeyCreator extends SerializableNumericIdentificationKeyCreator_base {
+    /**
+     * Constructor. Called internally by {@link PrefixManager} serialized numeric identification key creator getters;
+     * should not be called by other code.
+     *
+     * @param prefixManager
+     * Prefix manager.
+     *
+     * @param identificationKeyType
+     * Identification key type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param serialComponentLength
+     * Serial component length.
+     *
+     * @param serialComponentCharacterSet
+     * Serial component character set.
+     */
+    constructor(prefixManager: PrefixManager, identificationKeyType: IdentificationKeyType, length: number, serialComponentLength: number, serialComponentCharacterSet: CharacterSet);
+    /**
+     * Get the serial component creator.
+     */
+    get serialComponentCreator(): CharacterSetCreator;
+    /**
+     * Concatenate a validated base identification key with a serial component.
+     *
+     * @param baseIdentificationKey
+     * Base identification key.
+     *
+     * @param serialComponent
+     * Serial component.
+     *
+     * @returns
+     * Serialized identification key.
+     */
+    private concatenateValidated;
+    /**
+     * Create a serialized identification key with a reference based on a numeric value and a serial component. The
+     * value is converted to a reference of the appropriate length using {@linkcode NUMERIC_CREATOR}.
+     *
+     * @param value
+     * Numeric value of the references.
+     *
+     * @param serialComponent
+     * Serial component.
+     *
+     * @param sparse
+     * If true, the value is mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * Serialized identification key.
+     */
+    createSerialized(value: number, serialComponent: string, sparse?: boolean): string;
+    /**
+     * Create multiple serialized identification keys with a reference based on a numeric value and multiple serial
+     * components. The value is converted to a reference of the appropriate length using {@linkcode NUMERIC_CREATOR}.
+     *
+     * @param value
+     * Numeric value.
+     *
+     * @param serialComponents
+     * Serial components.
+     *
+     * @param sparse
+     * If true, the value is mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * Serialized identification keys.
+     */
+    createSerialized(value: number, serialComponents: Iterable<string>, sparse?: boolean): IterableIterator<string>;
+    /**
+     * Concatenate a base identification key with a serial component.
+     *
+     * @param baseIdentificationKey
+     * Base identification key.
+     *
+     * @param serialComponent
+     * Serial component.
+     *
+     * @returns
+     * Serialized identification key.
+     */
+    concatenate(baseIdentificationKey: string, serialComponent: string): string;
+    /**
+     * Concatenate a base identification key with multiple serial components.
+     *
+     * @param baseIdentificationKey
+     * Base identification key.
+     *
+     * @param serialComponents
+     * Serial components.
+     *
+     * @returns
+     * Serialized identification keys.
+     */
+    concatenate(baseIdentificationKey: string, serialComponents: Iterable<string>): IterableIterator<string>;
+}
+declare const NonNumericIdentificationKeyCreator_base: ts_mixer_dist_types_types_js.Class<any[], NonNumericIdentificationKeyValidator & AbstractIdentificationKeyCreator, typeof NonNumericIdentificationKeyValidator & typeof AbstractIdentificationKeyCreator>;
+/**
+ * Non-numeric identification key creator.
+ */
+declare class NonNumericIdentificationKeyCreator extends NonNumericIdentificationKeyCreator_base {
+    /**
+     * Reference validation parameters.
+     */
+    private readonly _referenceValidation;
+    /**
+     * Constructor. Called internally by {@link PrefixManager} non-numeric identification key creator getters; should
+     * not be called by other code.
+     *
+     * @param prefixManager
+     * Prefix manager.
+     *
+     * @param identificationKeyType
+     * Identification key type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param referenceCharacterSet
+     * Reference character set.
+     *
+     * @param requiresCheckCharacterPair
+     * True if the identification key requires a check character pair.
+     */
+    constructor(prefixManager: PrefixManager, identificationKeyType: IdentificationKeyType, length: number, referenceCharacterSet: CharacterSet, requiresCheckCharacterPair?: boolean);
+    /**
+     * Create an identification key with a reference.
+     *
+     * @param reference
+     * Reference.
+     *
+     * @returns
+     * Identification key.
+     */
+    create(reference: string): string;
+    /**
+     * Create multiple identification keys with references.
+     *
+     * @param references
+     * References.
+     *
+     * @returns
+     * Identification keys.
+     */
+    create(references: Iterable<string>): IterableIterator<string>;
+}
+/**
+ * Prefix manager. This is the core class for identification key creation.
+ *
+ * A prefix manager may be created for any {@link PrefixType | prefix type}. As most applications work with a limited
+ * number of prefixes for creating identification keys, prefix managers are cached in memory and may be reused.
+ *
+ * Prefix managers are keyed by GS1 Company Prefix, so the prefix type that is requested may not match the prefix type
+ * of the returned prefix manager. For example, the prefix manager for GS1 Company Prefix 0614141 is identical to the
+ * one for U.P.C. Company Prefix 614141, with the prefix type equal to {@link PrefixType.UPCCompanyPrefix} and the
+ * prefix equal to "614141".
+ *
+ * To support the creation of sparse identification keys, a prefix manager maintains a {@link tweakFactor | tweak
+ * factor} which is used, along with a type-specific multiplier, as the tweak when creating numeric identification keys.
+ * The default tweak factor is the numeric value of the GS1 Company Prefix representation of the prefix preceded by '1'
+ * to ensure uniqueness (i.e., so that prefixes 0 N1 N2 N3... and N1 N2 N3... produce different tweak factors). This is
+ * usually sufficient for obfuscation, but as the sparse creation algorithm is reversible and as the GS1 Company Prefix
+ * is discoverable via {@link https://www.gs1.org/services/verified-by-gs1 | Verified by GS1}, a user-defined tweak
+ * factor should be used if a higher degree of obfuscation is required. When using a tweak factor other than the
+ * default, care should be taken to restore it when resuming the application. A tweak factor of 0 creates a straight
+ * sequence.
+ */
+declare class PrefixManager {
+    /**
+     * Cached prefix managers, keyed by GS1 Company Prefix.
+     */
+    private static readonly PREFIX_MANAGERS_MAP;
+    /**
+     * GS1 Company Prefix minimum length.
+     */
+    static readonly GS1_COMPANY_PREFIX_MINIMUM_LENGTH = 4;
+    /**
+     * GS1 Company Prefix maximum length.
+     */
+    static readonly GS1_COMPANY_PREFIX_MAXIMUM_LENGTH = 12;
+    /**
+     * U.P.C. Company Prefix minimum length.
+     */
+    static readonly UPC_COMPANY_PREFIX_MINIMUM_LENGTH = 6;
+    /**
+     * U.P.C. Company Prefix maximum length.
+     */
+    static readonly UPC_COMPANY_PREFIX_MAXIMUM_LENGTH = 11;
+    /**
+     * GS1-8 Prefix minimum length.
+     */
+    static readonly GS1_8_PREFIX_MINIMUM_LENGTH = 2;
+    /**
+     * GS1-8 Prefix maximum length.
+     */
+    static readonly GS1_8_PREFIX_MAXIMUM_LENGTH = 7;
+    /**
+     * Validation parameters for GS1 Company Prefix.
+     */
+    private static readonly GS1_COMPANY_PREFIX_VALIDATION;
+    /**
+     * Validation parameters for U.P.C. Company Prefix expressed as GS1 Company Prefix.
+     */
+    private static readonly UPC_COMPANY_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION;
+    /**
+     * Validation parameters for GS1-8 Prefix expressed as GS1 Company Prefix.
+     */
+    private static readonly GS1_8_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION;
+    /**
+     * Validation parameters for U.P.C. Company Prefix.
+     */
+    private static readonly UPC_COMPANY_PREFIX_VALIDATION;
+    /**
+     * Validation parameters for GS1-8 Prefix.
+     */
+    private static readonly GS1_8_PREFIX_VALIDATION;
+    /**
+     * Creator tweak factors. Different numeric identification key types have different tweak factors so that sparse
+     * creation generates different sequences for each.
+     */
+    private static readonly CREATOR_TWEAK_FACTORS_MAP;
+    /**
+     * Normalized prefix type.
+     */
+    private readonly _prefixType;
+    /**
+     * Normalized prefix.
+     */
+    private readonly _prefix;
+    /**
+     * Prefix as GS1 Company Prefix.
+     */
+    private readonly _gs1CompanyPrefix;
+    /**
+     * U.P.C. Company Prefix if prefix type is {@link PrefixType.UPCCompanyPrefix}.
+     */
+    private readonly _upcCompanyPrefix;
+    /**
+     * GS1-8 Prefix if prefix type is {@link PrefixType.GS18Prefix}.
+     */
+    private readonly _gs18Prefix;
+    /**
+     * Tweak factor.
+     */
+    private _tweakFactor;
+    /**
+     * Cached identification key creators.
+     */
+    private readonly _identificationKeyCreatorsMap;
+    /**
+     * Constructor.
+     *
+     * @param gs1CompanyPrefix
+     * GS1 Company Prefix.
+     */
+    private constructor();
+    /**
+     * Get the prefix type.
+     */
+    get prefixType(): PrefixType;
+    /**
+     * Get the prefix.
+     */
+    get prefix(): string;
+    /**
+     * Get the GS1 Company Prefix.
+     */
+    get gs1CompanyPrefix(): string;
+    /**
+     * Get the U.P.C. Company Prefix if prefix type is {@link PrefixType.UPCCompanyPrefix} or undefined if not.
+     */
+    get upcCompanyPrefix(): string | undefined;
+    /**
+     * Get the GS1-8 Prefix if prefix type is {@link PrefixType.GS18Prefix} or undefined if not.
+     */
+    get gs18Prefix(): string | undefined;
+    /**
+     * Set the tweak for an identification key creator if it's a numeric identification key creator.
+     *
+     * @param creator
+     * Identification key creator.
+     */
+    private setCreatorTweak;
+    /**
+     * Get the tweak factor.
+     */
+    get tweakFactor(): bigint;
+    /**
+     * Set the tweak factor.
+     *
+     * @param value
+     * Tweak factor.
+     */
+    set tweakFactor(value: number | bigint);
+    /**
+     * Reset the tweak factor to its default (numeric value of the GS1 Company Prefix preceded by '1').
+     */
+    resetTweakFactor(): void;
+    /**
+     * Get a prefix manager.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param prefix
+     * Prefix.
+     *
+     * @returns
+     * Prefix manager with normalized prefix type and prefix.
+     */
+    static get(prefixType: PrefixType, prefix: string): PrefixManager;
+    /**
+     * 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 isFromIdentificationKey
+     * If true, the prefix is from an identification key and should be trimmed before its character set is validated.
+     *
+     * @param isNumericIdentificationKey
+     * If true, the prefix is from a numeric identification key and its character set will be validated by the caller.
+     *
+     * @param positionOffset
+     * Position offset within a larger string.
+     */
+    static validatePrefix(prefixType: PrefixType, allowUPCCompanyPrefix: boolean, allowGS18Prefix: boolean, prefix: string, isFromIdentificationKey?: boolean, isNumericIdentificationKey?: boolean, positionOffset?: number): void;
+    /**
+     * Get an identification key creator.
+     *
+     * @param identificationKeyType
+     * Identification key type.
+     *
+     * @param constructorCallback
+     * Constructor callback.
+     *
+     * @returns
+     * Identification key creator.
+     */
+    private getIdentificationKeyCreator;
+    /**
+     * Get non-GTIN numeric identification key creator.
+     *
+     * @param validator
+     * Validator on which identification key creator is based.
+     *
+     * @returns
+     * Identification key creator.
+     */
+    private getNonGTINNumericIdentificationKeyCreator;
+    /**
+     * Get serialized numeric identification key creator.
+     *
+     * @param validator
+     * Validator on which identification key creator is based.
+     *
+     * @returns
+     * Identification key creator.
+     */
+    private getSerializableNumericIdentificationKeyCreator;
+    /**
+     * Get non-numeric identification key creator.
+     *
+     * @param validator
+     * Validator on which identification key creator is based.
+     *
+     * @returns
+     * Identification key creator.
+     */
+    private getNonNumericIdentificationKeyCreator;
+    /**
+     * Get GTIN creator.
+     */
+    get gtinCreator(): GTINCreator;
+    /**
+     * Get GLN creator.
+     */
+    get glnCreator(): NonGTINNumericIdentificationKeyCreator;
+    /**
+     * Get SSCC creator.
+     */
+    get ssccCreator(): NonGTINNumericIdentificationKeyCreator;
+    /**
+     * Get GRAI creator.
+     */
+    get graiCreator(): SerializableNumericIdentificationKeyCreator;
+    /**
+     * Get GIAI creator.
+     */
+    get giaiCreator(): NonNumericIdentificationKeyCreator;
+    /**
+     * Get GSRN creator.
+     */
+    get gsrnCreator(): NonGTINNumericIdentificationKeyCreator;
+    /**
+     * Get GDTI creator.
+     */
+    get gdtiCreator(): SerializableNumericIdentificationKeyCreator;
+    /**
+     * Get GINC creator.
+     */
+    get gincCreator(): NonNumericIdentificationKeyCreator;
+    /**
+     * Get GSIN creator.
+     */
+    get gsinCreator(): NonGTINNumericIdentificationKeyCreator;
+    /**
+     * Get GCN creator.
+     */
+    get gcnCreator(): SerializableNumericIdentificationKeyCreator;
+    /**
+     * Get CPID creator.
+     */
+    get cpidCreator(): NonNumericIdentificationKeyCreator;
+    /**
+     * Get GMN creator.
+     */
+    get gmnCreator(): NonNumericIdentificationKeyCreator;
+}
+
+export { AI39_CREATOR, AI82_CREATOR, CPID_VALIDATOR, CharacterSet, 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, hasValidCheckCharacterPair, hasValidCheckDigit };