@aidc-toolkit/gs1 1.0.42-beta → 1.0.43

package/dist/index.d.ts

@@ -1,63 +1,2205 @@
-/*!
- * Copyright © 2024-2026 Dolphin Data Development Ltd. and AIDC Toolkit
- * contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-export * from "./locale/i18n.js";
-export * from "./character-set.js";
-export * from "./check.js";
-export * from "./prefix-type.js";
-export type * from "./prefix-provider.js";
-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 * 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 "./identifier-descriptors.js";
-export * from "./identifier-validator.js";
-export * from "./numeric-identifier-validator.js";
-export { GTINLevels, type GTINLevelKey, type GTINLevel, 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 "./identifier-validators.js";
-export * from "./verified-by-gs1.js";
-export type * from "./identifier-creator.js";
-export type * from "./numeric-identifier-creator.js";
-export * from "./gtin-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 "./identifier-creators.js";
-export * from "./variable-measure.js";
-export * from "./prefix-manager.js";
-export * from "./gcp-length-data.js";
-export * from "./gcp-length-cache.js";
-export * from "./gcp-length.js";
-//# sourceMappingURL=index.d.ts.map
+import { I18nEnvironment, Hyperlink, AbstractConstructor, AppData, Cache, AppDataStorage } from '@aidc-toolkit/core';
+import { Resource, i18n, ParseKeys } from 'i18next';
+import { CharacterSetCreator, CharacterSetValidator, CharacterSetValidation, StringValidation, StringValidator, Exclusions, TransformerInput, TransformerOutput } from '@aidc-toolkit/utility';
+
+declare const _default: {
+    AI64CharacterSetValidator: {
+        lengthMustBeMultipleOf4: string;
+    };
+    Check: {
+        lengthOfStringForPriceOrWeightMustBeExactly: string;
+        priceOrWeightComponent: string;
+        lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: string;
+    };
+    Identifier: {
+        identifierTypeLength: string;
+        invalidCheckDigit: string;
+        invalidGTINLength: string;
+        invalidGTIN14Length: string;
+        invalidZeroSuppressedGTIN12: string;
+        invalidZeroSuppressibleGTIN12: string;
+        invalidZeroSuppressedGTIN12AsGTIN13: string;
+        invalidZeroSuppressedGTIN12AsGTIN14: string;
+        invalidGTINAtRetail: string;
+        invalidGTINAtOtherThanRetail: string;
+        invalidRCNLength: string;
+        invalidVariableMeasureRCNFormat: string;
+        invalidVariableMeasureRCNPrefix: string;
+        invalidVariableMeasurePriceOrWeight: string;
+        indicatorDigit: string;
+        serialComponent: string;
+        reference: string;
+        referenceCantBeAllNumeric: string;
+        invalidCheckCharacterPair: string;
+    };
+    Prefix: {
+        gs1CompanyPrefix: string;
+        upcCompanyPrefix: string;
+        gs18Prefix: string;
+        gs1CompanyPrefixCantStartWith0: string;
+        gs1CompanyPrefixCantStartWith00000: string;
+        gs1CompanyPrefixCantStartWith000000: string;
+        upcCompanyPrefixCantStartWith0000: string;
+        gs18PrefixCantStartWith0: string;
+        identifierTypeNotSupportedByGS18Prefix: string;
+    };
+    GCPLength: {
+        gs1CompanyPrefixLengthDataFileNotFound: string;
+        gs1CompanyPrefixLengthDataNotLoaded: string;
+    };
+};
+
+declare const gs1NS = "aidct_gs1";
+/**
+ * Locale strings type is extracted from the English locale strings object.
+ */
+type GS1LocaleResources = typeof _default;
+/**
+ * GS1 resource bundle.
+ */
+declare const gs1ResourceBundle: Resource;
+declare const i18nextGS1: i18n;
+/**
+ * Initialize internationalization.
+ *
+ * @param environment
+ * Environment in which the application is running.
+ *
+ * @param debug
+ * Debug setting.
+ *
+ * @returns
+ * GS1 resource bundle.
+ */
+declare function i18nGS1Init(environment: I18nEnvironment, debug?: boolean): Promise<Resource>;
+
+/**
+ * GS1 AI encodable character set 82 creator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
+ */
+declare const AI82_CREATOR: CharacterSetCreator;
+/**
+ * GS1 AI encodable character set 82 validator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
+ */
+declare const AI82_VALIDATOR: CharacterSetValidator;
+/**
+ * GS1 AI encodable character set 39 creator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
+ */
+declare const AI39_CREATOR: CharacterSetCreator;
+/**
+ * GS1 AI encodable character set 39 validator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
+ */
+declare const AI39_VALIDATOR: CharacterSetValidator;
+/**
+ * GS1 AI encodable character set 64 validator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Doesn't support any exclusions.
+ */
+declare const AI64_VALIDATOR: CharacterSetValidator;
+
+/**
+ * Calculate the check digit sum for a numeric string as per section 7.9.1 of the {@link
+ * https://ref.gs1.org/standards/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://ref.gs1.org/standards/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 or weight check digit for a four-or five-digit numeric string as per sections 7.9.2-7.9.4 of the
+ * {@link https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}.
+ *
+ * @param s
+ * Numeric string exactly four or five characters long.
+ *
+ * @returns
+ * Check digit 0-9 as a string.
+ */
+declare function priceOrWeightCheckDigit(s: string): string;
+/**
+ * Determine if a price or weight check digit is valid for numeric string.
+ *
+ * @param s
+ * Numeric string exactly four or five characters long.
+ *
+ * @param checkDigit
+ * Price or weight check digit.
+ *
+ * @returns
+ * True if the check digit is valid.
+ */
+declare function isValidPriceOrWeightCheckDigit(s: string, checkDigit: string): boolean;
+/**
+ * Calculate the check character for a GS1 AI encodable character set 82 string as per section 7.9.5 of the {@link
+ * https://ref.gs1.org/standards/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;
+
+/**
+ * Prefix types.
+ */
+declare const PrefixTypes: {
+    /**
+     * GS1 Company Prefix.
+     */
+    readonly GS1CompanyPrefix: "GS1 Company Prefix";
+    /**
+     * U.P.C. Company Prefix.
+     */
+    readonly UPCCompanyPrefix: "U.P.C. Company Prefix";
+    /**
+     * GS1-8 Prefix.
+     */
+    readonly GS18Prefix: "GS1-8 Prefix";
+};
+/**
+ * Prefix type key.
+ */
+type PrefixTypeKey = keyof typeof PrefixTypes;
+/**
+ * Prefix type.
+ */
+type PrefixType = typeof PrefixTypes[PrefixTypeKey];
+
+/**
+ * Prefix provider.
+ */
+interface PrefixProvider {
+    /**
+     * Prefix type.
+     */
+    readonly prefixType: PrefixType;
+    /**
+     * Prefix appropriate to the prefix type.
+     */
+    readonly prefix: string;
+    /**
+     * Prefix as GS1 Company Prefix.
+     */
+    readonly gs1CompanyPrefix: string;
+    /**
+     * Prefix as U.P.C. Company Prefix if prefix type is {@linkcode PrefixTypes.UPCCompanyPrefix} or undefined if not.
+     */
+    readonly upcCompanyPrefix: string | undefined;
+    /**
+     * Prefix as GS1-8 Prefix if prefix type is {@linkcode PrefixTypes.GS18Prefix} or undefined if not.
+     */
+    readonly gs18Prefix: string | undefined;
+}
+
+/**
+ * Prefix validation parameters.
+ */
+interface PrefixValidation extends CharacterSetValidation {
+    /**
+     * Minimum length.
+     */
+    minimumLength: number;
+    /**
+     * Maximum length.
+     */
+    maximumLength: number;
+    /**
+     * Callback to localized prefix type name.
+     */
+    component: () => string;
+}
+/**
+ * Prefix validator.
+ */
+declare const PrefixValidator: {
+    readonly GS1_COMPANY_PREFIX_MINIMUM_LENGTH: 4;
+    readonly GS1_COMPANY_PREFIX_MAXIMUM_LENGTH: 12;
+    readonly UPC_COMPANY_PREFIX_MINIMUM_LENGTH: 5;
+    readonly UPC_COMPANY_PREFIX_MAXIMUM_LENGTH: 11;
+    readonly GS1_8_PREFIX_MINIMUM_LENGTH: 2;
+    readonly GS1_8_PREFIX_MAXIMUM_LENGTH: 7;
+    /**
+     * Validate a prefix.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param allowUPCCompanyPrefix
+     * If true, a U.P.C. Company Prefix expressed as a GS1 Company Prefix is permitted.
+     *
+     * @param allowGS18Prefix
+     * If true, a GS1-8 Prefix expressed as a GS1 Company Prefix is permitted.
+     *
+     * @param prefix
+     * Prefix.
+     *
+     * @param isFromIdentifier
+     * If true, the prefix is from an identifier and should be trimmed before its character set is validated.
+     *
+     * @param isNumericIdentifier
+     * If true, the prefix is from a numeric identifier and its character set will be validated by the caller.
+     *
+     * @param errorMessageParseKey
+     * Parse key for error message when validating GS1 Company Prefix type.
+     */
+    readonly validate: (prefixType: PrefixType, allowUPCCompanyPrefix: boolean, allowGS18Prefix: boolean, prefix: string, isFromIdentifier?: boolean, isNumericIdentifier?: boolean, errorMessageParseKey?: ParseKeys) => void;
+    /**
+     * Normalize a prefix.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param prefix
+     * Prefix.
+     *
+     * @returns
+     * Prefix provider with normalized prefix type and prefix.
+     */
+    readonly normalize: (prefixType: PrefixType, prefix: string) => PrefixProvider;
+};
+
+/**
+ * Character sets supported by the reference portion of an identifier or the serial component of a numeric identifier.
+ */
+declare const ContentCharacterSets: {
+    /**
+     * Numeric.
+     */
+    readonly Numeric: "Numeric";
+    /**
+     * GS1 AI encodable character set 82.
+     */
+    readonly AI82: "AI82";
+    /**
+     * GS1 AI encodable character set 39.
+     */
+    readonly AI39: "AI39";
+};
+/**
+ * Content character set key.
+ */
+type ContentCharacterSetKey = keyof typeof ContentCharacterSets;
+/**
+ * Content character set.
+ */
+type ContentCharacterSet = typeof ContentCharacterSets[ContentCharacterSetKey];
+
+/**
+ * Identifier types.
+ */
+declare const IdentifierTypes: {
+    /**
+     * Global Trade Item Number.
+     */
+    readonly GTIN: "GTIN";
+    /**
+     * Global Location Number.
+     */
+    readonly GLN: "GLN";
+    /**
+     * Serial Shipping Container Code.
+     */
+    readonly SSCC: "SSCC";
+    /**
+     * Global Returnable Asset Identifier.
+     */
+    readonly GRAI: "GRAI";
+    /**
+     * Global Individual Asset Identifier.
+     */
+    readonly GIAI: "GIAI";
+    /**
+     * Global Service Relation Number.
+     */
+    readonly GSRN: "GSRN";
+    /**
+     * Global Document Type Identifier.
+     */
+    readonly GDTI: "GDTI";
+    /**
+     * Global Identification Number for Consignment.
+     */
+    readonly GINC: "GINC";
+    /**
+     * Global Shipment Identification Number.
+     */
+    readonly GSIN: "GSIN";
+    /**
+     * Global Coupon Number.
+     */
+    readonly GCN: "GCN";
+    /**
+     * Component/Part Identifier.
+     */
+    readonly CPID: "CPID";
+    /**
+     * Global Model Number.
+     */
+    readonly GMN: "GMN";
+};
+/**
+ * Identifier type key.
+ */
+type IdentifierTypeKey = keyof typeof IdentifierTypes;
+/**
+ * Identifier type.
+ */
+type IdentifierType = typeof IdentifierTypes[IdentifierTypeKey];
+
+/**
+ * Leader type.
+ */
+declare const LeaderTypes: {
+    /**
+     * No leader.
+     */
+    readonly None: "None";
+    /**
+     * Indicator digit (GTIN only).
+     */
+    readonly IndicatorDigit: "Indicator digit";
+    /**
+     * Extension digit (SSCC only).
+     */
+    readonly ExtensionDigit: "Extension digit";
+};
+/**
+ * Leader type key.
+ */
+type LeaderTypeKey = keyof typeof LeaderTypes;
+/**
+ * Leader type.
+ */
+type LeaderType = typeof LeaderTypes[LeaderTypeKey];
+
+/**
+ * Numeric identifier types.
+ */
+declare const NumericIdentifierTypes: Pick<{
+    readonly GTIN: "GTIN";
+    readonly GLN: "GLN";
+    readonly SSCC: "SSCC";
+    readonly GRAI: "GRAI";
+    readonly GIAI: "GIAI";
+    readonly GSRN: "GSRN";
+    readonly GDTI: "GDTI";
+    readonly GINC: "GINC";
+    readonly GSIN: "GSIN";
+    readonly GCN: "GCN";
+    readonly CPID: "CPID";
+    readonly GMN: "GMN";
+}, "GTIN" | "GLN" | "SSCC" | "GRAI" | "GSRN" | "GDTI" | "GSIN" | "GCN">;
+/**
+ * Numeric identifier type key.
+ */
+type NumericIdentifierTypeKey = keyof typeof NumericIdentifierTypes;
+/**
+ * Numeric identifier type.
+ */
+type NumericIdentifierType = typeof NumericIdentifierTypes[NumericIdentifierTypeKey];
+
+/**
+ * GTIN types.
+ */
+declare const GTINTypes: Pick<Pick<{
+    readonly GTIN: "GTIN";
+    readonly GLN: "GLN";
+    readonly SSCC: "SSCC";
+    readonly GRAI: "GRAI";
+    readonly GIAI: "GIAI";
+    readonly GSRN: "GSRN";
+    readonly GDTI: "GDTI";
+    readonly GINC: "GINC";
+    readonly GSIN: "GSIN";
+    readonly GCN: "GCN";
+    readonly CPID: "CPID";
+    readonly GMN: "GMN";
+}, "GTIN" | "GLN" | "SSCC" | "GRAI" | "GSRN" | "GDTI" | "GSIN" | "GCN">, "GTIN">;
+/**
+ * GTIN type key.
+ */
+type GTINTypeKey = keyof typeof GTINTypes;
+/**
+ * GTIN type.
+ */
+type GTINType = typeof GTINTypes[GTINTypeKey];
+
+/**
+ * Non-GTIN numeric identifier types.
+ */
+declare const NonGTINNumericIdentifierTypes: Omit<Pick<{
+    readonly GTIN: "GTIN";
+    readonly GLN: "GLN";
+    readonly SSCC: "SSCC";
+    readonly GRAI: "GRAI";
+    readonly GIAI: "GIAI";
+    readonly GSRN: "GSRN";
+    readonly GDTI: "GDTI";
+    readonly GINC: "GINC";
+    readonly GSIN: "GSIN";
+    readonly GCN: "GCN";
+    readonly CPID: "CPID";
+    readonly GMN: "GMN";
+}, "GTIN" | "GLN" | "SSCC" | "GRAI" | "GSRN" | "GDTI" | "GSIN" | "GCN">, "GTIN">;
+/**
+ * Non-GTIN numeric identifier type key.
+ */
+type NonGTINNumericIdentifierTypeKey = keyof typeof NonGTINNumericIdentifierTypes;
+/**
+ * Non-GTIN numeric identifier type.
+ */
+type NonGTINNumericIdentifierType = typeof NonGTINNumericIdentifierTypes[NonGTINNumericIdentifierTypeKey];
+
+/**
+ * Non-serializable numeric identifier types.
+ */
+declare const NonSerializableNumericIdentifierTypes: Pick<Omit<Pick<{
+    readonly GTIN: "GTIN";
+    readonly GLN: "GLN";
+    readonly SSCC: "SSCC";
+    readonly GRAI: "GRAI";
+    readonly GIAI: "GIAI";
+    readonly GSRN: "GSRN";
+    readonly GDTI: "GDTI";
+    readonly GINC: "GINC";
+    readonly GSIN: "GSIN";
+    readonly GCN: "GCN";
+    readonly CPID: "CPID";
+    readonly GMN: "GMN";
+}, "GTIN" | "GLN" | "SSCC" | "GRAI" | "GSRN" | "GDTI" | "GSIN" | "GCN">, "GTIN">, "GLN" | "SSCC" | "GSRN" | "GSIN">;
+/**
+ * Non-serializable numeric identifier type key.
+ */
+type NonSerializableNumericIdentifierTypeKey = keyof typeof NonSerializableNumericIdentifierTypes;
+/**
+ * Non-serializable numeric identifier type.
+ */
+type NonSerializableNumericIdentifierType = typeof NonSerializableNumericIdentifierTypes[NonSerializableNumericIdentifierTypeKey];
+
+/**
+ * Serializable numeric identifier types.
+ */
+declare const SerializableNumericIdentifierTypes: Omit<Omit<Pick<{
+    readonly GTIN: "GTIN";
+    readonly GLN: "GLN";
+    readonly SSCC: "SSCC";
+    readonly GRAI: "GRAI";
+    readonly GIAI: "GIAI";
+    readonly GSRN: "GSRN";
+    readonly GDTI: "GDTI";
+    readonly GINC: "GINC";
+    readonly GSIN: "GSIN";
+    readonly GCN: "GCN";
+    readonly CPID: "CPID";
+    readonly GMN: "GMN";
+}, "GTIN" | "GLN" | "SSCC" | "GRAI" | "GSRN" | "GDTI" | "GSIN" | "GCN">, "GTIN">, "GLN" | "SSCC" | "GSRN" | "GSIN">;
+/**
+ * Serializable numeric identifier type key.
+ */
+type SerializableNumericIdentifierTypeKey = keyof typeof SerializableNumericIdentifierTypes;
+/**
+ * Serializable numeric identifier type.
+ */
+type SerializableNumericIdentifierType = typeof SerializableNumericIdentifierTypes[SerializableNumericIdentifierTypeKey];
+
+/**
+ * Non-numeric identifier types.
+ */
+declare const NonNumericIdentifierTypes: Omit<{
+    readonly GTIN: "GTIN";
+    readonly GLN: "GLN";
+    readonly SSCC: "SSCC";
+    readonly GRAI: "GRAI";
+    readonly GIAI: "GIAI";
+    readonly GSRN: "GSRN";
+    readonly GDTI: "GDTI";
+    readonly GINC: "GINC";
+    readonly GSIN: "GSIN";
+    readonly GCN: "GCN";
+    readonly CPID: "CPID";
+    readonly GMN: "GMN";
+}, "GTIN" | "GLN" | "SSCC" | "GRAI" | "GSRN" | "GDTI" | "GSIN" | "GCN">;
+/**
+ * Non-numeric identifier type key.
+ */
+type NonNumericIdentifierTypeKey = keyof typeof NonNumericIdentifierTypes;
+/**
+ * Non-numeric identifier type.
+ */
+type NonNumericIdentifierType = typeof NonNumericIdentifierTypes[NonNumericIdentifierTypeKey];
+
+/**
+ * Identifier descriptor. Instantiations of this type are used to parameterize validators and creators.
+ */
+interface IdentifierDescriptor {
+    /**
+     * Identifier type. Per the GS1 General Specifications, the identifier type determines the remaining properties.
+     */
+    readonly identifierType: IdentifierType;
+    /**
+     * 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.
+     */
+    readonly prefixType: PrefixType;
+    /**
+     * Length. For numeric identifier types, the length is fixed; for non-numeric identifier types, the length is the
+     * maximum.
+     */
+    readonly length: number;
+    /**
+     * Reference character set.
+     */
+    readonly referenceCharacterSet: ContentCharacterSet;
+}
+
+/**
+ * Numeric identifier descriptor.
+ */
+interface NumericIdentifierDescriptor extends IdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: NumericIdentifierType;
+    /**
+     * @inheritDoc
+     */
+    readonly referenceCharacterSet: typeof ContentCharacterSets.Numeric;
+    /**
+     * Leader type.
+     */
+    readonly leaderType: LeaderType;
+}
+
+/**
+ * GTIN lengths. The numeric values are equal to the lengths of the GTINs.
+ */
+declare const GTINLengths: {
+    /**
+     * GTIN-13.
+     */
+    readonly GTIN13: 13;
+    /**
+     * GTIN-12.
+     */
+    readonly GTIN12: 12;
+    /**
+     * GTIN-8.
+     */
+    readonly GTIN8: 8;
+    /**
+     * GTIN-14.
+     */
+    readonly GTIN14: 14;
+};
+/**
+ * GTIN length key.
+ */
+type GTINLengthKey = keyof typeof GTINLengths;
+/**
+ * GTIN length.
+ */
+type GTINLength = typeof GTINLengths[GTINLengthKey];
+/**
+ * GTIN base lengths (all except GTIN-14).
+ */
+declare const GTINBaseLengths: Omit<{
+    /**
+     * GTIN-13.
+     */
+    readonly GTIN13: 13;
+    /**
+     * GTIN-12.
+     */
+    readonly GTIN12: 12;
+    /**
+     * GTIN-8.
+     */
+    readonly GTIN8: 8;
+    /**
+     * GTIN-14.
+     */
+    readonly GTIN14: 14;
+}, "GTIN14">;
+/**
+ * GTIN base length key.
+ */
+type GTINBaseLengthKey = keyof typeof GTINBaseLengths;
+/**
+ * GTIN length.
+ */
+type GTINBaseLength = typeof GTINBaseLengths[GTINBaseLengthKey];
+/**
+ * GTIN base lengths by prefix type. Used to determine the GTIN length supported by a prefix type.
+ */
+declare const GTIN_BASE_TYPES: Readonly<Record<PrefixType, GTINBaseLength>>;
+
+/**
+ * GTIN descriptor.
+ */
+interface GTINDescriptor extends NumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: GTINType;
+    /**
+     * @inheritDoc
+     */
+    readonly length: GTINBaseLength;
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: typeof LeaderTypes.IndicatorDigit;
+}
+
+/**
+ * Non-GTIN numeric identifier descriptor.
+ */
+interface NonGTINNumericIdentifierDescriptor extends NumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: NonGTINNumericIdentifierType;
+    /**
+     * @inheritDoc
+     */
+    readonly prefixType: typeof PrefixTypes.GS1CompanyPrefix;
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: Exclude<LeaderType, typeof LeaderTypes.IndicatorDigit>;
+}
+
+/**
+ * Non-serializable numeric identifier descriptor.
+ */
+interface NonSerializableNumericIdentifierDescriptor extends NonGTINNumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: typeof LeaderTypes.None | typeof LeaderTypes.ExtensionDigit;
+}
+
+/**
+ * Serializable numeric identifier descriptor.
+ */
+interface SerializableNumericIdentifierDescriptor extends NonGTINNumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: SerializableNumericIdentifierType;
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: typeof LeaderTypes.None;
+    /**
+     * Serial component length.
+     */
+    readonly serialComponentLength: number;
+    /**
+     * Serial component character set.
+     */
+    readonly serialComponentCharacterSet: ContentCharacterSet;
+}
+
+/**
+ * Non-numeric identifier descriptor.
+ */
+interface NonNumericIdentifierDescriptor extends IdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: NonNumericIdentifierType;
+    /**
+     * @inheritDoc
+     */
+    readonly prefixType: typeof PrefixTypes.GS1CompanyPrefix;
+    /**
+     * @inheritDoc
+     */
+    readonly referenceCharacterSet: Exclude<ContentCharacterSet, typeof ContentCharacterSets.Numeric>;
+    /**
+     * True if identifier requires a check character pair.
+     */
+    readonly requiresCheckCharacterPair: boolean;
+}
+
+/**
+ * Identifier extension type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+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;
+
+/**
+ * Identifier descriptor type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+type IdentifierTypeDescriptor<TIdentifierType extends IdentifierType> = IdentifierTypeExtension<TIdentifierType, IdentifierDescriptor, NumericIdentifierDescriptor, GTINDescriptor, NonGTINNumericIdentifierDescriptor, NonSerializableNumericIdentifierDescriptor, SerializableNumericIdentifierDescriptor, NonNumericIdentifierDescriptor>;
+/**
+ * Identifier descriptors entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+type IdentifierDescriptorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends GTINType ? Readonly<Record<GTINBaseLength, GTINDescriptor>> : IdentifierTypeDescriptor<TIdentifierType>;
+/**
+ * Identifier descriptors record type.
+ */
+type IdentifierDescriptorsRecord = {
+    readonly [TIdentifierType in IdentifierType]: IdentifierDescriptorsEntry<TIdentifierType>;
+};
+/**
+ * Identifier descriptors for all identifier types.
+ */
+declare const IdentifierDescriptors: IdentifierDescriptorsRecord;
+/**
+ * Determine if identifier descriptors or descriptor is GTIN descriptors.
+ *
+ * @param identifierDescriptorsOrDescriptor
+ * Identifier descriptors or descriptor.
+ *
+ * @returns
+ * True if GTIN descriptors.
+ */
+declare function isGTINDescriptors(identifierDescriptorsOrDescriptor: IdentifierDescriptorsEntry<IdentifierType>): identifierDescriptorsOrDescriptor is Readonly<Record<GTINBaseLength, GTINDescriptor>>;
+/**
+ * Determine if identifier descriptor is a numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a numeric identifier descriptor.
+ */
+declare function isNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NumericIdentifierDescriptor;
+/**
+ * Determine if identifier descriptor is a GTIN descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a GTIN descriptor.
+ */
+declare function isGTINDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is GTINDescriptor;
+/**
+ * Determine if identifier descriptor is a non-GTIN numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a non-GTIN numeric identifier descriptor.
+ */
+declare function isNonGTINNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonGTINNumericIdentifierDescriptor;
+/**
+ * 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.
+ */
+declare function isNonSerializableNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonSerializableNumericIdentifierDescriptor;
+/**
+ * Determine if identifier descriptor is a serializable numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a serializable numeric identifier descriptor.
+ */
+declare function isSerializableNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is SerializableNumericIdentifierDescriptor;
+/**
+ * Determine if identifier descriptor is a non-numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a non-numeric identifier descriptor.
+ */
+declare function isNonNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonNumericIdentifierDescriptor;
+
+/**
+ * Identifier validation parameters.
+ */
+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}. Implements common functionality for an
+ * identifier validator.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ *
+ * @template TIdentifierValidation
+ * Identifier validation type.
+ */
+declare abstract class IdentifierValidator<TIdentifierType extends IdentifierType = IdentifierType, TIdentifierValidation extends IdentifierValidation = IdentifierValidation> implements IdentifierDescriptor, StringValidator<TIdentifierValidation> {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param identifierDescriptor
+     * Identifier descriptor.
+     */
+    protected constructor(identifierDescriptor: IdentifierTypeDescriptor<TIdentifierType>);
+    /**
+     * Get the identifier type. Per the GS1 General Specifications, the identifier type determines the remaining
+     * properties.
+     */
+    get identifierType(): IdentifierTypeDescriptor<TIdentifierType>["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(): IdentifierTypeDescriptor<TIdentifierType>["prefixType"];
+    /**
+     * Get the length. For numeric identifier types, the length is fixed; for alphanumeric identifier types, the length
+     * is the maximum.
+     */
+    get length(): IdentifierTypeDescriptor<TIdentifierType>["length"];
+    /**
+     * Get the reference character set.
+     */
+    get referenceCharacterSet(): IdentifierTypeDescriptor<TIdentifierType>["referenceCharacterSet"];
+    /**
+     * Get the reference creator.
+     */
+    get referenceCreator(): CharacterSetCreator;
+    /**
+     * 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;
+    /**
+     * Validate the prefix within an identifier.
+     *
+     * @param partialIdentifier
+     * Partial identifier.
+     */
+    protected validatePrefix(partialIdentifier: string): void;
+    /**
+     * Validate an identifier and throw an error if validation fails.
+     *
+     * @param identifier
+     * Identifier.
+     *
+     * @param validation
+     * Identifier validation parameters.
+     */
+    abstract validate(identifier: string, validation?: TIdentifierValidation): void;
+}
+
+/**
+ * Numeric identifier validation parameters.
+ */
+interface NumericIdentifierValidation extends IdentifierValidation {
+    /**
+     * Position offset within a larger string. Some numeric identifier types have the prefix offset by one.
+     */
+    positionOffset?: number | undefined;
+}
+/**
+ * Numeric identifier validator.
+ *
+ * @template TNumericIdentifierType
+ * Numeric identifier type type.
+ */
+declare abstract class NumericIdentifierValidator<TNumericIdentifierType extends NumericIdentifierType = NumericIdentifierType> extends IdentifierValidator<TNumericIdentifierType, NumericIdentifierValidation> implements NumericIdentifierDescriptor {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param identifierDescriptor
+     * Identifier descriptor.
+     */
+    constructor(identifierDescriptor: IdentifierTypeDescriptor<TNumericIdentifierType>);
+    /**
+     * @inheritDoc
+     */
+    get leaderType(): IdentifierTypeDescriptor<TNumericIdentifierType>["leaderType"];
+    /**
+     * @inheritDoc
+     */
+    validate(identifier: string, validation?: NumericIdentifierValidation): void;
+}
+
+/**
+ * Levels at which GTIN is to be validated.
+ */
+declare const GTINLevels: {
+    /**
+     * Any level (level is ignored).
+     */
+    readonly Any: 0;
+    /**
+     * Retail consumer trade item level, supporting GTIN-13, GTIN-12 (optionally zero-suppressed), and GTIN-8.
+     */
+    readonly RetailConsumer: 1;
+    /**
+     * Other than retail consumer trade item level, supporting GTIN-13, GTIN-12 (not zero-suppressed), and GTIN-14.
+     */
+    readonly OtherThanRetailConsumer: 2;
+};
+/**
+ * GTIN level key.
+ */
+type GTINLevelKey = keyof typeof GTINLevels;
+/**
+ * GTIN level.
+ */
+type GTINLevel = typeof GTINLevels[GTINLevelKey];
+/**
+ * GTIN validator.
+ */
+declare class GTINValidator extends NumericIdentifierValidator<GTINType> implements GTINDescriptor {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param gtinBaseLength
+     * GTIN base length (all except GTIN-14).
+     */
+    constructor(gtinBaseLength: GTINBaseLength);
+    /**
+     * @inheritDoc
+     */
+    get prefixType(): PrefixType;
+    /**
+     * @inheritDoc
+     */
+    protected validatePrefix(partialIdentifier: string): void;
+    /**
+     * Zero suppress a GTIN-12.
+     *
+     * @param gtin12
+     * GTIN-12.
+     *
+     * @returns
+     * Zero-suppressed GTIN-12.
+     */
+    static zeroSuppress(gtin12: string): string;
+    /**
+     * Zero expand a zero-suppressed GTIN-12.
+     *
+     * @param zeroSuppressedGTIN12
+     * Zero-suppressed GTIN-12.
+     *
+     * @returns
+     * GTIN-12.
+     */
+    static zeroExpand(zeroSuppressedGTIN12: 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;
+    /**
+     * 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 identifier validator.
+ *
+ * @template TNonGTINNumericIdentifierType
+ * Non-GTIN numeric identifier type type.
+ */
+declare abstract class NonGTINNumericIdentifierValidator<TNonGTINNumericIdentifierType extends NonGTINNumericIdentifierType = NonGTINNumericIdentifierType> extends NumericIdentifierValidator<TNonGTINNumericIdentifierType> implements NonGTINNumericIdentifierDescriptor {
+}
+
+/**
+ * Non-serializable numeric identifier validator.
+ */
+declare class NonSerializableNumericIdentifierValidator extends NonGTINNumericIdentifierValidator<NonSerializableNumericIdentifierType> implements NonSerializableNumericIdentifierDescriptor {
+    /**
+     * Constructor.
+     *
+     * @param identifierType
+     * Identifier type.
+     */
+    constructor(identifierType: NonSerializableNumericIdentifierType);
+}
+
+/**
+ * Serializable numeric identifier split.
+ */
+interface SerializableNumericIdentifierSplit {
+    /**
+     * Base identifier.
+     */
+    baseIdentifier: string;
+    /**
+     * Serial component.
+     */
+    serialComponent: string;
+}
+/**
+ * Serializable numeric identifier validator. Validates both serialized and non-serialized forms of numeric identifiers
+ * that support serialization.
+ */
+declare class SerializableNumericIdentifierValidator extends NonGTINNumericIdentifierValidator<SerializableNumericIdentifierType> implements SerializableNumericIdentifierDescriptor {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param identifierType
+     * Identifier type.
+     */
+    constructor(identifierType: SerializableNumericIdentifierType);
+    /**
+     * Get the serial component length.
+     */
+    get serialComponentLength(): number;
+    /**
+     * Get the serial component character set.
+     */
+    get serialComponentCharacterSet(): ContentCharacterSet;
+    /**
+     * Get the serial component validation parameters.
+     */
+    protected get serialComponentValidation(): CharacterSetValidation;
+    /**
+     * Get the serial component creator.
+     */
+    get serialComponentCreator(): CharacterSetCreator;
+    /**
+     * @inheritDoc
+     */
+    validate(identifier: string, validation?: IdentifierValidation): void;
+    /**
+     * Split a serializable numeric identifier into its component parts.
+     *
+     * @param identifier
+     * Identifier.
+     *
+     * @param validation
+     * Identifier validation parameters.
+     *
+     * @returns
+     * Base identifier and serial component (possibly empty) as object.
+     */
+    split(identifier: string, validation?: IdentifierValidation): SerializableNumericIdentifierSplit;
+}
+
+/**
+ * Non-numeric identifier validation parameters.
+ */
+interface NonNumericIdentifierValidation extends IdentifierValidation {
+    /**
+     * Exclusion support for reference. Prevents non-numeric identifier from being mistaken for numeric identifier.
+     */
+    exclusion?: typeof Exclusions.None | typeof Exclusions.AllNumeric | undefined;
+}
+/**
+ * Non-numeric identifier validator.
+ */
+declare class NonNumericIdentifierValidator extends IdentifierValidator<NonNumericIdentifierType, NonNumericIdentifierValidation> implements NonNumericIdentifierDescriptor {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param identifierType
+     * Identifier type.
+     */
+    constructor(identifierType: NonNumericIdentifierType);
+    /**
+     * Determine if the identifier requires a check character pair.
+     */
+    get requiresCheckCharacterPair(): boolean;
+    /**
+     * Validate a non-numeric identifier and throw an error if validation fails.
+     *
+     * @param identifier
+     * Identifier.
+     *
+     * @param validation
+     * Validation parameters.
+     */
+    validate(identifier: string, validation?: NonNumericIdentifierValidation): void;
+}
+
+/**
+ * Identifier validator type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+type IdentifierTypeValidator<TIdentifierType extends IdentifierType> = IdentifierTypeExtension<TIdentifierType, IdentifierValidator, NumericIdentifierValidator, GTINValidator, NonGTINNumericIdentifierValidator, NonSerializableNumericIdentifierValidator, SerializableNumericIdentifierValidator, NonNumericIdentifierValidator>;
+/**
+ * Identifier validators entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+type IdentifierValidatorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends GTINType ? Readonly<Record<GTINBaseLength, GTINValidator>> : IdentifierTypeValidator<TIdentifierType>;
+/**
+ * Identifier validators record type.
+ */
+type IdentifierValidatorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierValidatorsEntry<TIdentifierType>;
+};
+/**
+ * Identifier validators for all identifier types.
+ */
+declare const IdentifierValidators: Readonly<IdentifierValidatorsRecord>;
+/**
+ * GTIN validator constructor type.
+ */
+type GTINValidatorConstructor = new (gtinBaseLength: GTINBaseLength) => GTINValidator;
+/**
+ * Non-GTIN validator constructor type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+type NonGTINValidatorConstructor<TIdentifierType extends Exclude<IdentifierType, GTINType>> = new (identifierType: TIdentifierType) => IdentifierValidatorsRecord[TIdentifierType];
+/**
+ * Identifier validator constructors entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+type IdentifierValidatorConstructorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends GTINType ? GTINValidatorConstructor : NonGTINValidatorConstructor<Exclude<TIdentifierType, GTINType>>;
+/**
+ * Identifier validator constructors record type.
+ */
+type IdentifierValidatorConstructorsRecord = {
+    readonly [TIdentifierType in IdentifierType]: IdentifierValidatorConstructorsEntry<TIdentifierType>;
+};
+declare const IdentifierValidatorConstructors: IdentifierValidatorConstructorsRecord;
+/**
+ * Determine if identifier validators or validator is GTIN validators.
+ *
+ * @param identifierValidatorsOrValidator
+ * Identifier validators or validator.
+ *
+ * @returns
+ * True if GTIN validators.
+ */
+declare function isGTINValidators(identifierValidatorsOrValidator: IdentifierValidatorsEntry<IdentifierType>): identifierValidatorsOrValidator is Readonly<Record<GTINBaseLength, GTINValidator>>;
+/**
+ * Determine if identifier validator is a numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a numeric identifier validator.
+ */
+declare function isNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NumericIdentifierValidator;
+/**
+ * Determine if identifier validator is a GTIN validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a GTIN validator.
+ */
+declare function isGTINValidator(identifierValidator: IdentifierValidator): identifierValidator is GTINValidator;
+/**
+ * Determine if identifier validator is a non-GTIN numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a non-GTIN numeric identifier validator.
+ */
+declare function isNonGTINNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonGTINNumericIdentifierValidator;
+/**
+ * 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.
+ */
+declare function isNonSerializableNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonSerializableNumericIdentifierValidator;
+/**
+ * Determine if identifier validator is a serializable numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a serializable numeric identifier validator.
+ */
+declare function isSerializableNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is SerializableNumericIdentifierValidator;
+/**
+ * Determine if identifier validator is a non-numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a non-numeric identifier validator.
+ */
+declare function isNonNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonNumericIdentifierValidator;
+
+/**
+ * Create a Verified by GS1 hyperlink.
+ *
+ * @param identifierType
+ * Identifier type.
+ *
+ * @param identifier
+ * Identifier.
+ *
+ * @param text
+ * Text for hyperlink. If not provided, the identifier is used.
+ *
+ * @param details
+ * Details to display when hovering over hyperlink.
+ *
+ * @returns
+ * Verified by GS1 hyperlink.
+ */
+declare function verifiedByGS1(identifierType: IdentifierType, identifier: string, text?: string | undefined, details?: string): Hyperlink;
+
+/**
+ * Identifier creator. Creates an identifier based on its definition in section 3 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}.
+ *
+ * Keys are created based on a prefix defined in a prefix provider to which the identifier creator is bound.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ *
+ * @template TIdentifierValidation
+ * Identifier validation type.
+ */
+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.
+     */
+    get prefixProvider(): PrefixProvider;
+    /**
+     * Get the prefix, equivalent to calling {@linkcode PrefixProvider.prefix | prefixProvider.prefix} for a GTIN or
+     * {@linkcode PrefixProvider.gs1CompanyPrefix | prefixProvider.gs1CompanyPrefix} for all other identifier types.
+     */
+    get prefix(): string;
+    /**
+     * Get the reference length.
+     */
+    get referenceLength(): number;
+}
+
+/**
+ * Numeric identifier creator. Creates one or many numeric identifiers.
+ *
+ * @template TNumericIdentifierType
+ * Numeric identifier type type.
+ */
+interface NumericIdentifierCreator<TNumericIdentifierType extends NumericIdentifierType = NumericIdentifierType> extends NumericIdentifierValidator<TNumericIdentifierType>, IdentifierCreator<TNumericIdentifierType, NumericIdentifierValidation> {
+    /**
+     * Get the capacity (`10**referenceLength`).
+     */
+    get capacity(): number;
+    /**
+     * Get the tweak for sparse creation.
+     */
+    get tweak(): bigint;
+    /**
+     * Set the tweak for sparse creation.
+     */
+    set tweak(value: bigint);
+    /**
+     * Create identifier(s) with reference(s) based on numeric value(s). The value(s) is/are converted to references of
+     * the appropriate length using {@linkcode NUMERIC_CREATOR}.
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param valueOrValues
+     * Numeric value(s).
+     *
+     * @param sparse
+     * If true, the value(s) are mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * Identifier(s).
+     */
+    create: <TTransformerInput extends TransformerInput<number | bigint>>(valueOrValues: TTransformerInput, sparse?: boolean) => TransformerOutput<TTransformerInput, string>;
+    /**
+     * Create all identifiers for the prefix from `0` to `capacity - 1`.
+     *
+     * The implementation creates the strings only as needed using an internal generator function. Although the result
+     * is equivalent to calling `creator.create(new Sequence(0, creator.capacity))`, this method is significantly
+     * faster.
+     *
+     * @returns
+     * All identifiers for the prefix.
+     */
+    createAll: () => Iterable<string>;
+}
+
+/**
+ * Numeric identifier creator constructor type, which delegates to a numeric identifier validator constructor.
+ *
+ * @template TNumericIdentifierType
+ * Numeric identifier type type.
+ *
+ * @template TNumericIdentifierValidator
+ * Numeric identifier validator type.
+ */
+type NumericIdentifierCreatorConstructor<TNumericIdentifierType extends NumericIdentifierType, TNumericIdentifierValidator extends NumericIdentifierValidator<TNumericIdentifierType>> = AbstractConstructor<[
+    prefixProvider: PrefixProvider,
+    prefix: string,
+    ...args: ConstructorParameters<IdentifierValidatorConstructorsEntry<TNumericIdentifierType>>
+], TNumericIdentifierValidator & NumericIdentifierCreator<TNumericIdentifierType>>;
+
+declare const GTINCreator_base: NumericIdentifierCreatorConstructor<"GTIN", GTINValidator>;
+/**
+ * GTIN creator. Applicable to GTIN-13, GTIN-12, and GTIN-8 types; not applicable to GTIN-14 type.
+ */
+declare class GTINCreator extends GTINCreator_base {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param prefixProvider
+     * Prefix provider.
+     *
+     * @param gtinBaseLength
+     * GTIN base length (all except GTIN-14).
+     */
+    constructor(prefixProvider: PrefixProvider, gtinBaseLength: GTINBaseLength);
+    /**
+     * @inheritDoc
+     */
+    get prefix(): string;
+    /**
+     * Create GTIN-14(s) with an indicator digit and reference(s) based on numeric value(s). The value(s) is/are
+     * converted to reference(s) of the appropriate length using {@linkcode NUMERIC_CREATOR}.
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param indicatorDigit
+     * Indicator digit.
+     *
+     * @param valueOrValues
+     * Numeric value(s).
+     *
+     * @param sparse
+     * If true, the value(s) is/are mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * GTIN-14(s).
+     */
+    createGTIN14<TTransformerInput extends TransformerInput<number | bigint>>(indicatorDigit: string, valueOrValues: TTransformerInput, sparse?: boolean): TransformerOutput<TTransformerInput, string>;
+}
+
+/**
+ * Non-GTIN numeric identifier creator. Creates one or many non-GTIN numeric identifiers.
+ *
+ * @template TNonGTINNumericIdentifierType
+ * Non-GTIN numeric identifier type type.
+ */
+interface NonGTINNumericIdentifierCreator<TNonGTINNumericIdentifierType extends NonGTINNumericIdentifierType = NonGTINNumericIdentifierType> extends NonGTINNumericIdentifierValidator<TNonGTINNumericIdentifierType>, NumericIdentifierCreator<TNonGTINNumericIdentifierType> {
+}
+
+declare const NonSerializableNumericIdentifierCreator_base: abstract new (...args: [prefixProvider: PrefixProvider, identifierType: "GLN"] | [prefixProvider: PrefixProvider, identifierType: "SSCC"] | [prefixProvider: PrefixProvider, identifierType: "GSRN"] | [prefixProvider: PrefixProvider, identifierType: "GSIN"]) => NonSerializableNumericIdentifierValidator & NonGTINNumericIdentifierCreator<NonSerializableNumericIdentifierType>;
+/**
+ * Non-serializable numeric identifier creator.
+ */
+declare class NonSerializableNumericIdentifierCreator extends NonSerializableNumericIdentifierCreator_base {
+}
+
+declare const SerializableNumericIdentifierCreator_base: abstract new (...args: [prefixProvider: PrefixProvider, identifierType: "GRAI"] | [prefixProvider: PrefixProvider, identifierType: "GDTI"] | [prefixProvider: PrefixProvider, identifierType: "GCN"]) => SerializableNumericIdentifierValidator & NonGTINNumericIdentifierCreator<SerializableNumericIdentifierType>;
+/**
+ * Serializable numeric identifier creator.
+ */
+declare class SerializableNumericIdentifierCreator extends SerializableNumericIdentifierCreator_base {
+    #private;
+    /**
+     * Create serialized identifier(s) with a reference based on a numeric value concatenated with serial component(s).
+     * The value is converted to a reference of the appropriate length using {@linkcode NUMERIC_CREATOR}.
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param value
+     * Numeric value of the reference.
+     *
+     * @param serialComponentOrComponents
+     * Serial component(s).
+     *
+     * @param sparse
+     * If true, the value is mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * Serialized identifiers.
+     */
+    createSerialized<TTransformerInput extends TransformerInput<string>>(value: number, serialComponentOrComponents: TTransformerInput, sparse?: boolean): TransformerOutput<TTransformerInput, string>;
+    /**
+     * Concatenate a base identifier with serial component(s).
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param baseIdentifier
+     * Base identifier.
+     *
+     * @param serialComponentOrComponents
+     * Serial component(s).
+     *
+     * @returns
+     * Serialized identifier(s).
+     */
+    concatenate<TTransformerInput extends TransformerInput<string>>(baseIdentifier: string, serialComponentOrComponents: TTransformerInput): TransformerOutput<TTransformerInput, string>;
+}
+
+/**
+ * Identifier creator constructor type, which delegates to an identifier validator constructor.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ *
+ * @template TIdentifierValidation
+ * Identifier validation type.
+ *
+ * @template TIdentifierValidator
+ * Identifier validator type.
+ */
+type IdentifierCreatorConstructor<TIdentifierType extends IdentifierType, TIdentifierValidation extends IdentifierValidation, TIdentifierValidator extends IdentifierValidator<TIdentifierType, TIdentifierValidation>> = AbstractConstructor<[
+    prefixProvider: PrefixProvider,
+    prefix: string,
+    checkAllowance: number,
+    ...args: ConstructorParameters<IdentifierValidatorConstructorsEntry<TIdentifierType>>
+], TIdentifierValidator & IdentifierCreator<TIdentifierType, TIdentifierValidation>>;
+
+declare const NonNumericIdentifierCreator_base: IdentifierCreatorConstructor<NonNumericIdentifierType, NonNumericIdentifierValidation, NonNumericIdentifierValidator>;
+/**
+ * Non-numeric identifier creator.
+ */
+declare class NonNumericIdentifierCreator extends NonNumericIdentifierCreator_base {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param prefixProvider
+     * Prefix provider.
+     *
+     * @param identifierType
+     * Identifier type.
+     */
+    constructor(prefixProvider: PrefixProvider, identifierType: NonNumericIdentifierType);
+    /**
+     * Get the reference validation parameters.
+     */
+    protected get referenceValidation(): CharacterSetValidation;
+    /**
+     * Create identifier(s) with reference(s).
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param referenceOrReferences
+     * Reference(s).
+     *
+     * @returns
+     * Identifier(s).
+     */
+    create<TTransformerInput extends TransformerInput<string>>(referenceOrReferences: TTransformerInput): TransformerOutput<TTransformerInput, string>;
+}
+
+/**
+ * Identifier creator type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+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.
+ */
+type IdentifierCreatorsEntry<TIdentifierType extends IdentifierType> = IdentifierTypeCreator<TIdentifierType>;
+/**
+ * Identifier creators record type.
+ */
+type IdentifierCreatorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierCreatorsEntry<TIdentifierType>;
+};
+/**
+ * GTIN creator constructor type.
+ */
+type GTINCreatorConstructor = new (prefixProvider: PrefixProvider, gtinBaseLength: GTINBaseLength) => GTINCreator;
+/**
+ * Non-GTIN creator constructor type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+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.
+ */
+type IdentifierCreatorConstructorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends GTINType ? GTINCreatorConstructor : NonGTINCreatorConstructor<Exclude<TIdentifierType, GTINType>>;
+/**
+ * Identifier creator constructors record type.
+ */
+type IdentifierCreatorConstructorsRecord = {
+    readonly [TIdentifierType in IdentifierType]: IdentifierCreatorConstructorsEntry<TIdentifierType>;
+};
+declare const IdentifierCreatorConstructors: IdentifierCreatorConstructorsRecord;
+/**
+ * Determine if identifier creator is a numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a numeric identifier creator.
+ */
+declare function isNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NumericIdentifierCreator;
+/**
+ * Determine if identifier creator is a GTIN creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a GTIN creator.
+ */
+declare function isGTINCreator(identifierCreator: IdentifierCreator): identifierCreator is GTINCreator;
+/**
+ * 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.
+ */
+declare function isNonGTINNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonGTINNumericIdentifierCreator;
+/**
+ * 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.
+ */
+declare function isNonSerializableNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonSerializableNumericIdentifierCreator;
+/**
+ * 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.
+ */
+declare function isSerializableNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is SerializableNumericIdentifierCreator;
+/**
+ * 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.
+ */
+declare function isNonNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonNumericIdentifierCreator;
+
+/**
+ * Restricted Circulation Number reference.
+ */
+interface RCNReference {
+    /**
+     * Item reference.
+     */
+    itemReference: number;
+    /**
+     * Price or weight (whole number only).
+     */
+    priceOrWeight: number;
+}
+/**
+ * Variable measure trade item support functions.
+ */
+declare class VariableMeasure {
+    /**
+     * Parse a Restricted Circulation Number (RCN) using a variable measure trade item format. The format is a 12- or
+     * 13-character string (for RCN-12 or RCN-13 respectively), containing the following:
+     *
+     * - '2' - The first character of the RCN.
+     * - '0'-'9' - The second character of the RCN (RCN-13 only).
+     * - 'I' - One or more, in sequence, for the item reference.
+     * - 'P' - One or more, in sequence, for the price or weight.
+     * - 'V' - Zero or one, for the price or weight check digit.
+     * - 'C' - The check digit of the entire RCN.
+     *
+     * The 'I', 'P', and 'V' formats may be in any order.
+     *
+     * Some examples:
+     *
+     * - `2IIIIIVPPPPC` - RCN-12 with a five-digit item reference, a price or weight check digit, and a four-digit price
+     * or weight.
+     * - `23IIIIVPPPPPC` - RCN-13 with a four-digit item reference, a price or weight check digit, and a five-digit price
+     * or weight.
+     * - `2IIIIIIPPPPC` - RCN-12 with a six-digit item reference and a four-digit price or eight.
+     * - `29IIIIIPPPPPC` - RCN-13 with a five-digit item reference and a five-digit price or weight.
+     *
+     * @param format
+     * Format.
+     *
+     * @param rcn
+     * RCN.
+     *
+     * @returns
+     * RCN reference.
+     */
+    static parseRCN(format: string, rcn: string): RCNReference;
+    /**
+     * Create a Restricted Circulation Number (RCN) using a variable measure trade item format. See {@linkcode parseRCN}
+     * for format details.
+     *
+     * @param format
+     * Format.
+     *
+     * @param itemReference
+     * Item reference.
+     *
+     * @param priceOrWeight
+     * Price or weight (whole number only).
+     *
+     * @returns
+     * RCN-12 or RCN-13.
+     */
+    static createRCN(format: string, itemReference: number, priceOrWeight: number): string;
+}
+
+/**
+ * Prefix manager. This is the core class for identifier creation.
+ *
+ * A prefix manager may be constructed for any {@link PrefixType | prefix type}. Construction may be done directly or
+ * via the static {@linkcode PrefixManager.get | get()} method, which allows for caching and reuse. As most applications
+ * work with a limited number of prefixes for creating identifiers, caching and reuse may be a more efficient option.
+ *
+ * The prefix type and prefix are normalized before the prefix manager is constructed, so they may not match the input
+ * values. For example, the GS1 Company Prefix 0614141 is equivalent to U.P.C. Company Prefix 614141; both result in a
+ * prefix manager with prefix type equal to {@linkcode PrefixTypes.UPCCompanyPrefix} and prefix equal to "614141".
+ *
+ * To support the creation of sparse identifiers, a prefix manager maintains a {@link tweakFactor | tweak factor} which
+ * is used, along with a type-specific multiplier, as the tweak when creating numeric identifiers. 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 implements PrefixProvider {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param prefix
+     * Prefix.
+     */
+    constructor(prefixType: PrefixType, prefix: string);
+    /**
+     * 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 {@linkcode PrefixTypes.UPCCompanyPrefix} or undefined if not.
+     */
+    get upcCompanyPrefix(): string | undefined;
+    /**
+     * Get the GS1-8 Prefix if prefix type is {@linkcode PrefixTypes.GS18Prefix} or undefined if not.
+     */
+    get gs18Prefix(): string | undefined;
+    /**
+     * 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;
+    /**
+     * Get an identifier creator.
+     *
+     * @template TIdentifierType
+     * Identifier type type.
+     *
+     * @param identifierType
+     * Identifier type for which to retrieve or construct identifier creator.
+     *
+     * @returns
+     * Identifier creator.
+     */
+    getIdentifierCreator<TIdentifierType extends IdentifierType>(identifierType: TIdentifierType): IdentifierCreatorsRecord[TIdentifierType];
+    /**
+     * Get GTIN creator.
+     */
+    get gtinCreator(): GTINCreator;
+    /**
+     * Get GLN creator.
+     */
+    get glnCreator(): NonSerializableNumericIdentifierCreator;
+    /**
+     * Get SSCC creator.
+     */
+    get ssccCreator(): NonSerializableNumericIdentifierCreator;
+    /**
+     * Get GRAI creator.
+     */
+    get graiCreator(): SerializableNumericIdentifierCreator;
+    /**
+     * Get GIAI creator.
+     */
+    get giaiCreator(): NonNumericIdentifierCreator;
+    /**
+     * Get GSRN creator.
+     */
+    get gsrnCreator(): NonSerializableNumericIdentifierCreator;
+    /**
+     * Get GDTI creator.
+     */
+    get gdtiCreator(): SerializableNumericIdentifierCreator;
+    /**
+     * Get GINC creator.
+     */
+    get gincCreator(): NonNumericIdentifierCreator;
+    /**
+     * Get GSIN creator.
+     */
+    get gsinCreator(): NonSerializableNumericIdentifierCreator;
+    /**
+     * Get GCN creator.
+     */
+    get gcnCreator(): SerializableNumericIdentifierCreator;
+    /**
+     * Get CPID creator.
+     */
+    get cpidCreator(): NonNumericIdentifierCreator;
+    /**
+     * Get GMN creator.
+     */
+    get gmnCreator(): NonNumericIdentifierCreator;
+}
+
+/**
+ * GS1 Company Prefix length header.
+ */
+interface GCPLengthHeader {
+    /**
+     * Date/time the data was last updated.
+     */
+    readonly dateTime: Date;
+    /**
+     * Disclaimer.
+     */
+    readonly disclaimer: string;
+}
+/**
+ * Determine if application data object is GS1 Company Prefix length header.
+ *
+ * @param appData
+ * Application data object.
+ *
+ * @returns
+ * True if application data object is GS1 Company Prefix length header.
+ */
+declare function isGCPLengthHeader(appData: AppData | undefined): appData is GCPLengthHeader;
+/**
+ * GS1 Company Prefix length data.
+ */
+interface GCPLengthData extends GCPLengthHeader {
+    /**
+     * Tree data in binary form.
+     */
+    readonly data: Uint8Array;
+}
+/**
+ * Determine if application data object is GS1 Company Prefix length data.
+ *
+ * @param appData
+ * Application data object.
+ *
+ * @returns
+ * True if application data object is GS1 Company Prefix length data.
+ */
+declare function isGCPLengthData(appData: AppData | undefined): appData is GCPLengthData;
+/**
+ * GS1 Company Prefix length application data.
+ */
+interface GCPLengthAppData {
+    /**
+     * Next check date/time.
+     */
+    nextCheckDateTime: Date | undefined;
+    /**
+     * GS1 Company Prefix length data.
+     */
+    gcpLengthData: GCPLengthData | undefined;
+}
+/**
+ * Determine if application data object is GS1 Company Prefix length application data.
+ *
+ * @param appData
+ * Application data object.
+ *
+ * @returns
+ * True if application data object is GS1 Company Prefix length application data.
+ */
+declare function isGCPLengthAppData(appData: AppData | undefined): appData is GCPLengthAppData;
+/**
+ * GS1 Company Prefix length JSON source file format.
+ */
+interface GCPLengthSourceJSON {
+    /**
+     * Disclaimer.
+     */
+    _disclaimer: string[];
+    /**
+     * Format list.
+     */
+    GCPPrefixFormatList: {
+        /**
+         * ISO data/time the table was last updated.
+         */
+        date: string;
+        /**
+         * Entries.
+         */
+        entry: Array<{
+            /**
+             * Identification key prefix start.
+             */
+            prefix: string;
+            /**
+             * Length of GS1 Company Prefix.
+             */
+            gcpLength: number;
+        }>;
+    };
+}
+/**
+ * Determine if application data object is GS1 Company Prefix length source JSON.
+ *
+ * @param appData
+ * Application data object.
+ *
+ * @returns
+ * True if application data object is GS1 Company Prefix length source JSON.
+ */
+declare function isGCPLengthSourceJSON(appData: AppData | undefined): appData is GCPLengthSourceJSON;
+
+/**
+ * GS1 Company Prefix length cache.
+ */
+declare abstract class GCPLengthCache extends Cache<GCPLengthData, GCPLengthData | GCPLengthSourceJSON> {
+    #private;
+    /**
+     * Storage key for full application data object.
+     */
+    static APP_DATA_STORAGE_KEY: string;
+    /**
+     * Storage key for next check date/time.
+     */
+    static NEXT_CHECK_DATE_TIME_STORAGE_KEY: string;
+    /**
+     * Storage key for header information (date/time and disclaimer).
+     */
+    static HEADER_STORAGE_KEY: string;
+    /**
+     * Storage key for data only.
+     */
+    static DATA_STORAGE_KEY: string;
+    /**
+     * Constructor.
+     *
+     * @param appDataStorage
+     * Application data storage.
+     */
+    constructor(appDataStorage: AppDataStorage<boolean>);
+    /**
+     * Get the application data storage.
+     */
+    get appDataStorage(): AppDataStorage<boolean>;
+    /**
+     * @inheritDoc
+     */
+    get nextCheckDateTime(): Promise<Date | undefined>;
+    /**
+     * @inheritDoc
+     */
+    get cacheDateTime(): Promise<Date | undefined>;
+    /**
+     * @inheritDoc
+     */
+    get cacheData(): Promise<GCPLengthData>;
+    /**
+     * @inheritDoc
+     */
+    update(nextCheckDateTime: Date, _cacheDateTime?: Date, cacheData?: GCPLengthData): Promise<void>;
+}
+/**
+ * GS1 Company Prefix length cache with remote source. This class provides access to the data from a remote source, by
+ * default the AIDC Toolkit website. If any error occurs, the next check date/time is set to the current date/time plus
+ * ten minutes to prevent the network from being overloaded.
+ *
+ * The data on the AIDC Toolkit website is updated regularly with the data provided by GS1, and it's stored in binary
+ * format for faster retrieval.
+ */
+declare class RemoteGCPLengthCache extends GCPLengthCache {
+    #private;
+    /**
+     * Default base URL pointing to AIDC Toolkit website data directory.
+     */
+    static DEFAULT_BASE_URL: string;
+    /**
+     * Constructor.
+     *
+     * @param appDataStorage
+     * Application data storage.
+     *
+     * @param baseURL
+     * Base URL. The URL must not end with a slash and must host the `gcp-length-header.json` and `gcp-length-data.bin`
+     * files.
+     */
+    constructor(appDataStorage: AppDataStorage<boolean>, baseURL?: string);
+    /**
+     * @inheritDoc
+     */
+    get sourceDateTime(): Promise<Date>;
+    /**
+     * @inheritDoc
+     */
+    get sourceData(): Promise<GCPLengthData>;
+}
+
+/**
+ * Leaf of GS1 Company Prefix length tree.
+ */
+interface Leaf {
+    readonly length: number;
+}
+/**
+ * Branch of GS1 Company Prefix length tree.
+ */
+interface Branch {
+    readonly childNodes: ReadonlyArray<Node | undefined>;
+}
+/**
+ * Root of GS1 Company Prefix length tree.
+ */
+interface Root extends GCPLengthHeader, Branch {
+}
+/**
+ * Node in GS1 Company Prefix length tree.
+ */
+type Node = Branch | Leaf;
+/**
+ * Interim branch of GS1 Company Prefix length tree with writeable child nodes.
+ */
+interface InterimBranch {
+    readonly childNodes: Array<InterimBranch | Leaf | undefined>;
+}
+/**
+ * GS1 Company Prefix length service. The constructor takes a {@linkcode GCPLengthCache} object, which is responsible
+ * for managing the cache and source.
+ *
+ * The first step is to load the GS1 Company Prefix length data. This is done using the
+ * {@linkcode GCPLength.load | load()} method, which works as follows:
+ *
+ * - If the next check date/time is in the future, the method returns immediately, regardless of whether any data is
+ * available. It does this to prevent a large number of requests to the source in the event of a failure.
+ * - Otherwise, if the cache date/time is undefined or less than the source date/time, it loads from the source,
+ * converts the data if necessary, and updates the cache.
+ * - Otherwise, it continues with the cached data.
+ * - The next check date/time is updated to the later of the source date/time plus one week and the current date/time
+ * plus one day.
+ *
+ * The base class implementation of the `GCPLengthCache` manages only the cache itself, and it requires an
+ * application-provided storage implementation. The source is expected to be either a {@linkcode GCPLengthData} object
+ * (created via another cache implementation) or a {@linkcode GCPLengthSourceJSON} object, which is the format of the
+ * file provided by GS1.
+ *
+ * Once the data is loaded, the {@linkcode GCPLength.lengthOf | lengthOf()} method can be used to get the length of a
+ * GS1 Company Prefix for an identifier type and identifier.
+ */
+declare class GCPLength {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param gcpLengthCache
+     * GS1 Company Prefix length cache.
+     */
+    constructor(gcpLengthCache: GCPLengthCache);
+    /**
+     * Get the GS1 Company Prefix length tree root.
+     *
+     * @returns
+     * GS1 Company Prefix length tree root.
+     */
+    get root(): Root;
+    /**
+     * Get the date/time the GS1 Company Prefix length data was last updated.
+     */
+    get dateTime(): Date;
+    /**
+     * Get the disclaimer for the GS1 Company Prefix length data.
+     */
+    get disclaimer(): string;
+    /**
+     * Load the GS1 Company Prefix length data.
+     */
+    load(): Promise<void>;
+    /**
+     * Get the length of a GS1 Company Prefix for an identifier.
+     *
+     * @param identifierType
+     * Identifier type.
+     *
+     * @param identifier
+     * Identifier.
+     *
+     * @returns
+     * Length of GS1 Company Prefix, 0 if not a GS1 Company Prefix, or -1 if not found.
+     */
+    lengthOf(identifierType: IdentifierType, identifier: string): number;
+}
+
+export { AI39_CREATOR, AI39_VALIDATOR, AI64_VALIDATOR, AI82_CREATOR, AI82_VALIDATOR, type ContentCharacterSet, type ContentCharacterSetKey, ContentCharacterSets, GCPLength, type GCPLengthAppData, GCPLengthCache, type GCPLengthData, type GCPLengthHeader, type GCPLengthSourceJSON, type GS1LocaleResources, type GTINBaseLength, type GTINBaseLengthKey, GTINBaseLengths, GTINCreator, type GTINCreatorConstructor, type GTINDescriptor, type GTINLength, type GTINLengthKey, GTINLengths, type GTINLevel, type GTINLevelKey, GTINLevels, type GTINType, type GTINTypeKey, GTINTypes, GTINValidator, type GTINValidatorConstructor, GTIN_BASE_TYPES, type IdentifierCreator, IdentifierCreatorConstructors, type IdentifierCreatorConstructorsEntry, type IdentifierCreatorConstructorsRecord, type IdentifierCreatorsEntry, type IdentifierCreatorsRecord, type IdentifierDescriptor, IdentifierDescriptors, type IdentifierDescriptorsEntry, type IdentifierDescriptorsRecord, type IdentifierType, type IdentifierTypeCreator, type IdentifierTypeDescriptor, type IdentifierTypeKey, type IdentifierTypeValidator, IdentifierTypes, type IdentifierValidation, IdentifierValidator, IdentifierValidatorConstructors, type IdentifierValidatorConstructorsEntry, type IdentifierValidatorConstructorsRecord, IdentifierValidators, type IdentifierValidatorsEntry, type IdentifierValidatorsRecord, type InterimBranch, type LeaderType, type LeaderTypeKey, LeaderTypes, type NonGTINCreatorConstructor, type NonGTINNumericIdentifierCreator, type NonGTINNumericIdentifierDescriptor, type NonGTINNumericIdentifierType, type NonGTINNumericIdentifierTypeKey, NonGTINNumericIdentifierTypes, NonGTINNumericIdentifierValidator, type NonGTINValidatorConstructor, NonNumericIdentifierCreator, type NonNumericIdentifierDescriptor, type NonNumericIdentifierType, type NonNumericIdentifierTypeKey, NonNumericIdentifierTypes, type NonNumericIdentifierValidation, NonNumericIdentifierValidator, NonSerializableNumericIdentifierCreator, type NonSerializableNumericIdentifierDescriptor, type NonSerializableNumericIdentifierType, type NonSerializableNumericIdentifierTypeKey, NonSerializableNumericIdentifierTypes, NonSerializableNumericIdentifierValidator, type NumericIdentifierCreator, type NumericIdentifierDescriptor, type NumericIdentifierType, type NumericIdentifierTypeKey, NumericIdentifierTypes, type NumericIdentifierValidation, NumericIdentifierValidator, PrefixManager, type PrefixProvider, type PrefixType, type PrefixTypeKey, PrefixTypes, type PrefixValidation, PrefixValidator, type RCNReference, RemoteGCPLengthCache, SerializableNumericIdentifierCreator, type SerializableNumericIdentifierDescriptor, type SerializableNumericIdentifierSplit, type SerializableNumericIdentifierType, type SerializableNumericIdentifierTypeKey, SerializableNumericIdentifierTypes, SerializableNumericIdentifierValidator, VariableMeasure, checkCharacterPair, checkDigit, checkDigitSum, gs1NS, gs1ResourceBundle, hasValidCheckCharacterPair, hasValidCheckDigit, i18nGS1Init, i18nextGS1, isGCPLengthAppData, isGCPLengthData, isGCPLengthHeader, isGCPLengthSourceJSON, isGTINCreator, isGTINDescriptor, isGTINDescriptors, isGTINValidator, isGTINValidators, isNonGTINNumericIdentifierCreator, isNonGTINNumericIdentifierDescriptor, isNonGTINNumericIdentifierValidator, isNonNumericIdentifierCreator, isNonNumericIdentifierDescriptor, isNonNumericIdentifierValidator, isNonSerializableNumericIdentifierCreator, isNonSerializableNumericIdentifierDescriptor, isNonSerializableNumericIdentifierValidator, isNumericIdentifierCreator, isNumericIdentifierDescriptor, isNumericIdentifierValidator, isSerializableNumericIdentifierCreator, isSerializableNumericIdentifierDescriptor, isSerializableNumericIdentifierValidator, isValidPriceOrWeightCheckDigit, priceOrWeightCheckDigit, verifiedByGS1 };