@aidc-toolkit/app-extension 1.0.22-beta → 1.0.24-beta

package/dist/index.d.cts

@@ -0,0 +1,1747 @@
+import { I18nEnvironment, TypedSyncFunction, TypedFunction, TypedAsyncFunction, Nullishable } from '@aidc-toolkit/core';
+import { Resource, i18n } from 'i18next';
+import { StringValidation, StringValidator, CharacterSetCreator, Exclusion } from '@aidc-toolkit/utility';
+import { NumericIdentifierValidator, IdentifierValidation, IdentifierValidator, GTINValidator, GTINLevel, NonGTINNumericIdentifierValidator, SerializableNumericIdentifierValidator, NonNumericIdentifierValidation, NonNumericIdentifierValidator, PrefixType, NumericIdentifierCreator, IdentifierCreator, PrefixManager, GTINCreator, NonGTINNumericIdentifierCreator, SerializableNumericIdentifierCreator, NonNumericIdentifierCreator } from '@aidc-toolkit/gs1';
+
+declare const _default: {
+    AppExtension: {
+        sequenceCountMustBeLessThanOrEqualTo: string;
+    };
+    Proxy: {
+        vSpillMustBeHorizontalArray: string;
+        hSpillMustBeVerticalArray: string;
+        matrixMustBeArray: string;
+    };
+    IdentifierCreatorProxy: {
+        prefixDefinitionMustBeOneDimensional: string;
+        prefixDefinitionMustHaveMaximumThreeElements: string;
+        prefixMustBeString: string;
+        prefixTypeMustBeNumber: string;
+        tweakFactorMustBeNumber: string;
+    };
+    Parameters: {
+        spillMatrix: {
+            name: string;
+            description: string;
+        };
+        spillMaximumWidth: {
+            name: string;
+            description: string;
+        };
+        spillMaximumHeight: {
+            name: string;
+            description: string;
+        };
+        domain: {
+            name: string;
+            description: string;
+        };
+        value: {
+            name: string;
+            description: string;
+        };
+        startValue: {
+            name: string;
+            description: string;
+        };
+        count: {
+            name: string;
+            description: string;
+        };
+        transformedValue: {
+            name: string;
+            description: string;
+        };
+        tweak: {
+            name: string;
+            description: string;
+        };
+        regExp: {
+            name: string;
+            description: string;
+        };
+        validateS: {
+            name: string;
+            description: string;
+        };
+        valueForS: {
+            name: string;
+            description: string;
+        };
+        errorMessage: {
+            name: string;
+            description: string;
+        };
+        exclusionNone: {
+            name: string;
+            description: string;
+        };
+        exclusionFirstZero: {
+            name: string;
+            description: string;
+        };
+        exclusionAllNumeric: {
+            name: string;
+            description: string;
+        };
+        exclusionAny: {
+            name: string;
+            description: string;
+        };
+        length: {
+            name: string;
+            description: string;
+        };
+        numericS: {
+            name: string;
+            description: string;
+        };
+        numericSFourOrFiveDigits: {
+            name: string;
+            description: string;
+        };
+        numericSWithCheckDigit: {
+            name: string;
+            description: string;
+        };
+        checkDigit: {
+            name: string;
+            description: string;
+        };
+        ai82S: {
+            name: string;
+            description: string;
+        };
+        ai82SWithCheckCharacterPair: {
+            name: string;
+            description: string;
+        };
+        validateIdentifier: {
+            name: string;
+            description: string;
+        };
+        zeroSuppressibleGTIN12: {
+            name: string;
+            description: string;
+        };
+        zeroSuppressedGTIN12: {
+            name: string;
+            description: string;
+        };
+        convertGTIN: {
+            name: string;
+            description: string;
+        };
+        normalizeGTIN: {
+            name: string;
+            description: string;
+        };
+        validateGTIN: {
+            name: string;
+            description: string;
+        };
+        validateGTIN14: {
+            name: string;
+            description: string;
+        };
+        baseIdentifier: {
+            name: string;
+            description: string;
+        };
+        indicatorDigit: {
+            name: string;
+            description: string;
+        };
+        gtinLevel: {
+            name: string;
+            description: string;
+        };
+        rcnFormat: {
+            name: string;
+            description: string;
+        };
+        rcn: {
+            name: string;
+            description: string;
+        };
+        prefix: {
+            name: string;
+            description: string;
+        };
+        prefixType: {
+            name: string;
+            description: string;
+        };
+        tweakFactor: {
+            name: string;
+            description: string;
+        };
+        prefixDefinitionAny: {
+            name: string;
+            description: string;
+        };
+        prefixDefinitionGS1UPC: {
+            name: string;
+            description: string;
+        };
+        sparse: {
+            name: string;
+            description: string;
+        };
+        rcnItemReference: {
+            name: string;
+            description: string;
+        };
+        rcnPriceOrWeight: {
+            name: string;
+            description: string;
+        };
+        serialComponent: {
+            name: string;
+            description: string;
+        };
+        reference: {
+            name: string;
+            description: string;
+        };
+    };
+    Functions: {
+        version: {
+            name: string;
+            description: string;
+        };
+        vSpill: {
+            name: string;
+            description: string;
+        };
+        hSpill: {
+            name: string;
+            description: string;
+        };
+        forwardTransform: {
+            name: string;
+            description: string;
+        };
+        forwardTransformSequence: {
+            name: string;
+            description: string;
+        };
+        reverseTransform: {
+            name: string;
+            description: string;
+        };
+        validateRegExp: {
+            name: string;
+            description: string;
+        };
+        isValidRegExp: {
+            name: string;
+            description: string;
+        };
+        validateNumeric: {
+            name: string;
+            description: string;
+        };
+        isValidNumeric: {
+            name: string;
+            description: string;
+        };
+        createNumeric: {
+            name: string;
+            description: string;
+        };
+        createNumericSequence: {
+            name: string;
+            description: string;
+        };
+        valueForNumeric: {
+            name: string;
+            description: string;
+        };
+        validateHexadecimal: {
+            name: string;
+            description: string;
+        };
+        isValidHexadecimal: {
+            name: string;
+            description: string;
+        };
+        createHexadecimal: {
+            name: string;
+            description: string;
+        };
+        createHexadecimalSequence: {
+            name: string;
+            description: string;
+        };
+        valueForHexadecimal: {
+            name: string;
+            description: string;
+        };
+        validateAlphabetic: {
+            name: string;
+            description: string;
+        };
+        isValidAlphabetic: {
+            name: string;
+            description: string;
+        };
+        createAlphabetic: {
+            name: string;
+            description: string;
+        };
+        createAlphabeticSequence: {
+            name: string;
+            description: string;
+        };
+        valueForAlphabetic: {
+            name: string;
+            description: string;
+        };
+        validateAlphanumeric: {
+            name: string;
+            description: string;
+        };
+        isValidAlphanumeric: {
+            name: string;
+            description: string;
+        };
+        createAlphanumeric: {
+            name: string;
+            description: string;
+        };
+        createAlphanumericSequence: {
+            name: string;
+            description: string;
+        };
+        valueForAlphanumeric: {
+            name: string;
+            description: string;
+        };
+        GS1: {
+            validateAI82: {
+                name: string;
+                description: string;
+            };
+            isValidAI82: {
+                name: string;
+                description: string;
+            };
+            createAI82: {
+                name: string;
+                description: string;
+            };
+            createAI82Sequence: {
+                name: string;
+                description: string;
+            };
+            valueForAI82: {
+                name: string;
+                description: string;
+            };
+            validateAI39: {
+                name: string;
+                description: string;
+            };
+            isValidAI39: {
+                name: string;
+                description: string;
+            };
+            createAI39: {
+                name: string;
+                description: string;
+            };
+            createAI39Sequence: {
+                name: string;
+                description: string;
+            };
+            valueForAI39: {
+                name: string;
+                description: string;
+            };
+            checkDigit: {
+                name: string;
+                description: string;
+            };
+            hasValidCheckDigit: {
+                name: string;
+                description: string;
+            };
+            priceOrWeightCheckDigit: {
+                name: string;
+                description: string;
+            };
+            isValidPriceOrWeightCheckDigit: {
+                name: string;
+                description: string;
+            };
+            checkCharacterPair: {
+                name: string;
+                description: string;
+            };
+            hasValidCheckCharacterPair: {
+                name: string;
+                description: string;
+            };
+            validateGTIN13: {
+                name: string;
+                description: string;
+            };
+            validateGTIN12: {
+                name: string;
+                description: string;
+            };
+            validateGTIN8: {
+                name: string;
+                description: string;
+            };
+            zeroSuppressGTIN12: {
+                name: string;
+                description: string;
+            };
+            zeroExpandGTIN12: {
+                name: string;
+                description: string;
+            };
+            convertToGTIN14: {
+                name: string;
+                description: string;
+            };
+            normalizeGTIN: {
+                name: string;
+                description: string;
+            };
+            validateGTIN: {
+                name: string;
+                description: string;
+            };
+            validateGTIN14: {
+                name: string;
+                description: string;
+            };
+            parseVariableMeasureRCN: {
+                name: string;
+                description: string;
+            };
+            validateGLN: {
+                name: string;
+                description: string;
+            };
+            validateSSCC: {
+                name: string;
+                description: string;
+            };
+            validateGRAI: {
+                name: string;
+                description: string;
+            };
+            validateGIAI: {
+                name: string;
+                description: string;
+            };
+            validateGSRN: {
+                name: string;
+                description: string;
+            };
+            validateGDTI: {
+                name: string;
+                description: string;
+            };
+            validateGINC: {
+                name: string;
+                description: string;
+            };
+            validateGSIN: {
+                name: string;
+                description: string;
+            };
+            validateGCN: {
+                name: string;
+                description: string;
+            };
+            validateCPID: {
+                name: string;
+                description: string;
+            };
+            validateGMN: {
+                name: string;
+                description: string;
+            };
+            definePrefix: {
+                name: string;
+                description: string;
+            };
+            createGTIN: {
+                name: string;
+                description: string;
+            };
+            createGTINSequence: {
+                name: string;
+                description: string;
+            };
+            createAllGTIN: {
+                name: string;
+                description: string;
+            };
+            createGTIN14: {
+                name: string;
+                description: string;
+            };
+            createVariableMeasureRCN: {
+                name: string;
+                description: string;
+            };
+            createGLN: {
+                name: string;
+                description: string;
+            };
+            createGLNSequence: {
+                name: string;
+                description: string;
+            };
+            createAllGLN: {
+                name: string;
+                description: string;
+            };
+            createSSCC: {
+                name: string;
+                description: string;
+            };
+            createSSCCSequence: {
+                name: string;
+                description: string;
+            };
+            createAllSSCC: {
+                name: string;
+                description: string;
+            };
+            createGRAI: {
+                name: string;
+                description: string;
+            };
+            createGRAISequence: {
+                name: string;
+                description: string;
+            };
+            createAllGRAI: {
+                name: string;
+                description: string;
+            };
+            createSerializedGRAI: {
+                name: string;
+                description: string;
+            };
+            concatenateGRAI: {
+                name: string;
+                description: string;
+            };
+            createGIAI: {
+                name: string;
+                description: string;
+            };
+            createGSRN: {
+                name: string;
+                description: string;
+            };
+            createGSRNSequence: {
+                name: string;
+                description: string;
+            };
+            createAllGSRN: {
+                name: string;
+                description: string;
+            };
+            createGDTI: {
+                name: string;
+                description: string;
+            };
+            createGDTISequence: {
+                name: string;
+                description: string;
+            };
+            createAllGDTI: {
+                name: string;
+                description: string;
+            };
+            createSerializedGDTI: {
+                name: string;
+                description: string;
+            };
+            concatenateGDTI: {
+                name: string;
+                description: string;
+            };
+            createGINC: {
+                name: string;
+                description: string;
+            };
+            createGSIN: {
+                name: string;
+                description: string;
+            };
+            createGSINSequence: {
+                name: string;
+                description: string;
+            };
+            createAllGSIN: {
+                name: string;
+                description: string;
+            };
+            createGCN: {
+                name: string;
+                description: string;
+            };
+            createGCNSequence: {
+                name: string;
+                description: string;
+            };
+            createAllGCN: {
+                name: string;
+                description: string;
+            };
+            createSerializedGCN: {
+                name: string;
+                description: string;
+            };
+            concatenateGCN: {
+                name: string;
+                description: string;
+            };
+            createCPID: {
+                name: string;
+                description: string;
+            };
+            createGMN: {
+                name: string;
+                description: string;
+            };
+        };
+    };
+};
+
+declare const appExtensionNS = "aidct_app_extension";
+/**
+ * Locale resources type is extracted from the English locale resources object.
+ */
+type AppExtensionLocaleResources = typeof _default;
+/**
+ * App extension resources.
+ */
+declare const appExtensionResources: Resource;
+declare const i18nextAppExtension: i18n;
+/**
+ * Initialize internationalization.
+ *
+ * @param environment
+ * Environment in which the application is running.
+ *
+ * @param debug
+ * Debug setting.
+ *
+ * @returns
+ * Void promise.
+ */
+declare function i18nAppExtensionInit(environment: I18nEnvironment, debug?: boolean): Promise<void>;
+
+/**
+ * Type that error type is expected to extend. If the application framework reports errors through the throw/catch
+ * mechanism, the error type is expected to extend {@link Error}. Otherwise, it may extend any object type.
+ *
+ * @template ThrowError
+ * If true, errors are reported through the throw/catch mechanism.
+ */
+type ErrorExtends<ThrowError extends boolean> = ThrowError extends true ? Error : object;
+/**
+ * Sheet.
+ */
+interface Sheet {
+    /**
+     * Sheet name.
+     */
+    readonly name: string;
+}
+/**
+ * Single cell address.
+ */
+interface Address {
+    /**
+     * Zero-indexed row.
+     */
+    readonly rowIndex: number;
+    /**
+     * Zero-indexed column.
+     */
+    readonly columnIndex: number;
+}
+/**
+ * Sheet address.
+ */
+interface SheetAddress extends Sheet, Address {
+}
+/**
+ * Range of cells.
+ */
+interface Range {
+    /**
+     * Start address, inclusive.
+     */
+    readonly startAddress: Address;
+    /**
+     * End address, exclusive.
+     */
+    readonly endAddress: Address;
+}
+/**
+ * Sheet range.
+ */
+interface SheetRange extends Sheet, Range {
+}
+/**
+ * Matrix type; shorthand for defining a two-dimensional matrix (array of array) of a type.
+ *
+ * @template T
+ * Type.
+ */
+type Matrix<T> = T[][];
+/**
+ * Function result, possibly including an error result. If the application framework reports errors through the return
+ * value, the result is the union of the result type and the error type; otherwise, it's just the result type.
+ *
+ * @template TResult
+ * Result type.
+ *
+ * @template ThrowError
+ * If true, errors are reported through the throw/catch mechanism.
+ *
+ * @template TError
+ * Error type.
+ */
+type ResultError<TResult, ThrowError extends boolean, TError extends ErrorExtends<ThrowError>> = ThrowError extends false ? TResult | TError : TResult;
+/**
+ * Function result as matrix, possibly including an error result in each element. If the application framework reports
+ * errors through the return value, the individual element result is the union of the result type and the error type;
+ * otherwise, it's just the result type.
+ *
+ * @template TResult
+ * Result type.
+ *
+ * @template ThrowError
+ * If true, errors are reported through the throw/catch mechanism.
+ *
+ * @template TError
+ * Error type.
+ */
+type MatrixResultError<TResult, ThrowError extends boolean, TError extends ErrorExtends<ThrowError>> = Matrix<ResultError<TResult, ThrowError, TError>>;
+
+/**
+ * Application extension.
+ *
+ * @template TBigInt
+ * Type to which big integer is mapped.
+ *
+ * @template ThrowError
+ * If true, errors are reported through the throw/catch mechanism.
+ *
+ * @template TError
+ * Error type.
+ */
+declare abstract class AppExtension<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> {
+    /**
+     * Application version.
+     */
+    private readonly _version;
+    /**
+     * Maximum sequence count supported by application.
+     */
+    private readonly _maximumSequenceCount;
+    /**
+     * If true, errors are reported through the throw/catch mechanism.
+     */
+    private readonly _throwError;
+    /**
+     * Maximum width supported by application.
+     */
+    private _maximumWidth?;
+    /**
+     * Maximum height supported by application.
+     */
+    private _maximumHeight?;
+    /**
+     * Constructor.
+     *
+     * @param version
+     * Application version.
+     *
+     * @param maximumSequenceCount
+     * Maximum sequence count supported by application.
+     *
+     * @param throwError
+     * If true, errors are reported through the throw/catch mechanism.
+     */
+    protected constructor(version: string, maximumSequenceCount: number, throwError: ThrowError);
+    /**
+     * Get the version.
+     *
+     * @returns
+     * Version.
+     */
+    get version(): string;
+    /**
+     * Determine if errors are reported through the throw/catch mechanism.
+     */
+    get throwError(): ThrowError;
+    /**
+     * Get the maximum width supported by the application.
+     *
+     * @returns
+     * Maximum width supported by the application.
+     */
+    maximumWidth(): Promise<number>;
+    /**
+     * Get the maximum width supported by the application.
+     *
+     * @returns
+     * Maximum width supported by the application.
+     */
+    protected abstract getMaximumWidth(): Promise<number>;
+    /**
+     * Get the maximum height supported by the application.
+     *
+     * @returns
+     * Maximum height supported by the application.
+     */
+    maximumHeight(): Promise<number>;
+    /**
+     * Get the maximum height supported by the application.
+     *
+     * @returns
+     * Maximum height supported by the application.
+     */
+    protected abstract getMaximumHeight(): Promise<number>;
+    /**
+     * Get the sheet address from an invocation context.
+     *
+     * @param invocationContext
+     * Invocation context.
+     *
+     * @returns
+     * Sheet address.
+     */
+    abstract getSheetAddress(invocationContext: TInvocationContext): Promise<SheetAddress>;
+    /**
+     * Get a parameter range from an invocation context.
+     *
+     * @param invocationContext
+     * Invocation context.
+     *
+     * @param parameterNumber
+     * Parameter number.
+     *
+     * @returns
+     * Sheet range or null if parameter is not a range.
+     */
+    abstract getParameterSheetRange(invocationContext: TInvocationContext, parameterNumber: number): Promise<SheetRange | null>;
+    /**
+     * Validate a sequence count against the maximum supported by application.
+     *
+     * @param sequenceCount
+     * Sequence count.
+     */
+    validateSequenceCount(sequenceCount: number): void;
+    /**
+     * Map big integer to another type if necessary.
+     *
+     * @param value
+     * Big integer value to map.
+     *
+     * @returns
+     * Mapped big integer value.
+     */
+    abstract mapBigInt(value: bigint): ResultError<TBigInt, ThrowError, TError>;
+    /**
+     * Map a range error (thrown by the library) to an application-specific error. If errors are reported through the
+     * throw/catch mechanism, the implementation may return the range error unmodified if that is supported.
+     *
+     * @param rangeError
+     */
+    abstract mapRangeError(rangeError: RangeError): TError;
+    /**
+     * Handle an error with a message; called when an exception occurs outside the control of the AIDC Toolkit library.
+     * Implementation must not return, most likely by throwing the message wrapped in an error type.
+     *
+     * @param message
+     * Message to include in the error.
+     */
+    abstract handleError(message: string): never;
+    /**
+     * Bind a synchronous method and wrap it in a try/catch for comprehensive error handling.
+     *
+     * @param thisArg
+     * The value to be passed as the `this` parameter to the method.
+     *
+     * @param method
+     * Method to call.
+     *
+     * @returns
+     * Function wrapped around the method.
+     */
+    bindSync<TMethod extends TypedSyncFunction<TMethod>>(thisArg: ThisParameterType<TMethod>, method: TMethod): TypedFunction<TMethod>;
+    /**
+     * Bind an asynchronous method and wrap it in a try/catch for comprehensive error handling.
+     *
+     * @param thisArg
+     * The value to be passed as the `this` parameter to the method.
+     *
+     * @param method
+     * Method to call.
+     *
+     * @returns
+     * Function wrapped around the method.
+     */
+    bindAsync<TMethod extends TypedAsyncFunction<TMethod>>(thisArg: ThisParameterType<TMethod>, method: TMethod): TypedAsyncFunction<TMethod>;
+}
+
+/**
+ * Library proxy.
+ *
+ * @template TBigInt
+ * Type to which big integer is mapped.
+ *
+ * @template ThrowError
+ * If true, errors are reported through the throw/catch mechanism.
+ *
+ * @template TError
+ * Error type.
+ */
+declare abstract class LibProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> {
+    /**
+     * Application extension.
+     */
+    private readonly _appExtension;
+    /**
+     * Constructor.
+     *
+     * @param appExtension
+     * Application extension.
+     */
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+    /**
+     * Get the application extension.
+     */
+    protected get appExtension(): AppExtension<ThrowError, TError, TInvocationContext, TBigInt>;
+    /**
+     * Map big integer to another type if necessary.
+     *
+     * @param value
+     * Big integer value to map.
+     *
+     * @returns
+     * Mapped big integer value.
+     */
+    mapBigInt(value: bigint): ResultError<TBigInt, ThrowError, TError>;
+    /**
+     * Handle an error thrown by a function call.
+     *
+     * @param e
+     * Error.
+     *
+     * @returns
+     * Error if errors are not thrown.
+     */
+    private handleError;
+    /**
+     * Do the callback for a simple return.
+     *
+     * @param value
+     * Value.
+     *
+     * @param callback
+     * Callback.
+     *
+     * @returns
+     * Callback result or error if errors are not thrown.
+     */
+    private doCallback;
+    /**
+     * Map a matrix of values using a callback.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param callback
+     * Callback.
+     *
+     * @returns
+     * Matrix of callback results and errors if errors are not thrown.
+     */
+    protected mapMatrix<TValue, TResult>(matrixValues: Matrix<TValue>, callback: (value: TValue) => TResult): MatrixResultError<TResult, ThrowError, TError>;
+    /**
+     * Do the callback for an array return.
+     *
+     * @param value
+     * Value.
+     *
+     * @param callback
+     * Callback.
+     *
+     * @returns
+     * Callback result or error as array if errors are not thrown.
+     */
+    private doArrayCallback;
+    /**
+     * Map a one-dimensional matrix of values using a callback.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param callback
+     * Callback.
+     *
+     * @returns
+     * Matrix of callback results and errors if errors are not thrown.
+     */
+    protected mapArray<TValue, TResult>(matrixValues: Matrix<TValue>, callback: (value: TValue) => TResult[]): MatrixResultError<TResult, ThrowError, TError>;
+    /**
+     * Map a matrix of values to a matrix of strings via a callback that either returns or throws a range error. If the
+     * callback returns, the result for that element is the empty string; otherwise, if it's a range error, the result
+     * for that element is the error message.
+     *
+     * @param matrixValues
+     * Matrix to map.
+     *
+     * @param callback
+     * Callback that either returns or throws an exception.
+     *
+     * @returns
+     * Matrix of strings.
+     *
+     * @template TValue
+     * Value type.
+     */
+    protected static mapMatrixRangeError<TValue>(matrixValues: Matrix<TValue>, callback: (value: TValue) => void): Matrix<string>;
+    /**
+     * Convert an iterable result of a callback to a matrix result. Although the natural approach would be to map to a
+     * single-element array containing an array of *N* results (i.e., [[r0, r1, r2, ..., r*N*]]), this is rendered
+     * visually as a single row. The more readable approach is as a single column, so the mapping is to an *N*-element
+     * array of single-element result arrays (i.e., [[r0], [r1], [r2], ..., [r*N*]]).
+     *
+     * @param iterableResult
+     * Iterable result.
+     *
+     * @returns
+     * Matrix of callback results.
+     */
+    protected static matrixResult<TResult>(iterableResult: Iterable<TResult>): Matrix<TResult>;
+}
+
+/**
+ * Core descriptor.
+ */
+interface Descriptor {
+    /**
+     * Name.
+     */
+    readonly name: string;
+}
+/**
+ * Types supported by proxy methods.
+ */
+declare const Types: {
+    /**
+     * String.
+     */
+    readonly String: 0;
+    /**
+     * Number or enumeration.
+     */
+    readonly Number: 1;
+    /**
+     * Boolean.
+     */
+    readonly Boolean: 2;
+    /**
+     * Any.
+     */
+    readonly Any: 3;
+};
+/**
+ * Type.
+ */
+type Type = typeof Types[keyof typeof Types];
+/**
+ * Type descriptor.
+ */
+interface TypeDescriptor extends Descriptor {
+    /**
+     * Type.
+     */
+    readonly type: Type;
+    /**
+     * True if type is a matrix (method accepts or returns a two-dimensional array).
+     */
+    readonly isMatrix: boolean;
+}
+/**
+ * Base parameter descriptor; all attributes required.
+ */
+interface BaseParameterDescriptor extends TypeDescriptor {
+    /**
+     * True if required.
+     */
+    readonly isRequired: boolean;
+}
+/**
+ * Extends parameter descriptor; extends a parameter descriptor and overrides select attributes.
+ */
+interface ExtendsParameterDescriptor extends Partial<BaseParameterDescriptor> {
+    /**
+     * Base parameter descriptor that this one extends.
+     */
+    readonly extendsDescriptor: ParameterDescriptor;
+    /**
+     * Sort order within base parameter descriptor if applicable.
+     */
+    readonly sortOrder?: number;
+}
+/**
+ * Parameter descriptor, either base or extends.
+ */
+type ParameterDescriptor = BaseParameterDescriptor | ExtendsParameterDescriptor;
+/**
+ * Expand a parameter descriptor to its full form with all required attributes.
+ *
+ * @param parameterDescriptor
+ * Parameter descriptor.
+ *
+ * @returns
+ * Parameter descriptor in its full form.
+ */
+declare function expandParameterDescriptor(parameterDescriptor: ParameterDescriptor): BaseParameterDescriptor;
+/**
+ * Method descriptor.
+ */
+interface MethodDescriptor extends TypeDescriptor {
+    /**
+     * If true, application-specific invocation context is required.
+     */
+    readonly requiresContext?: boolean;
+    /**
+     * If true, method infix is ignored.
+     */
+    readonly ignoreInfix?: boolean;
+    /**
+     * String before which method infix appears. If undefined, infix is appended to the method name. Ignored if
+     * `ignoreInfix` is true.
+     */
+    readonly infixBefore?: string;
+    /**
+     * Parameter descriptors.
+     */
+    readonly parameterDescriptors: readonly ParameterDescriptor[];
+}
+/**
+ * Class descriptor.
+ */
+interface ClassDescriptor extends Descriptor {
+    /**
+     * Class namespace. If not provided, class is at the top level.
+     */
+    readonly namespace?: string;
+    /**
+     * Method infix. If undefined, method name is generated verbatim.
+     */
+    readonly methodInfix?: string;
+    /**
+     * Replace parameter descriptors for class hierarchies where enumeration parameter descriptors can change.
+     */
+    readonly replaceParameterDescriptors?: ReadonlyArray<{
+        readonly name: string;
+        readonly replacement: ParameterDescriptor;
+    }>;
+    /**
+     * Method descriptors.
+     */
+    readonly methodDescriptors: readonly MethodDescriptor[];
+}
+/**
+ * Proxy class type with fixed constructor.
+ */
+type ProxyClassType<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, T extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt>> = (new (appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) => T) & typeof LibProxy;
+/**
+ * Proxy parameter decorator.
+ *
+ * @param parameterDescriptor
+ * Parameter descriptor.
+ *
+ * @returns
+ * Function defining metadata for the parameter.
+ */
+declare function ProxyParameter<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, T extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt>>(parameterDescriptor: ParameterDescriptor): ((target: T, propertyKey: string, parameterIndex: number) => void);
+/**
+ * Proxy method decorator.
+ *
+ * @param methodDescriptor
+ * Method descriptor.
+ *
+ * @returns
+ * Function defining metadata for the method.
+ */
+declare function ProxyMethod<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, T extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt>>(methodDescriptor: Omit<MethodDescriptor, "name" | "parameterDescriptors">): ((target: T, propertyKey: string, propertyDescriptor: PropertyDescriptor) => void);
+/**
+ * Proxy class decorator.
+ *
+ * @param classDescriptor
+ * Class descriptor.
+ *
+ * @returns
+ * Function defining metadata for the class.
+ */
+declare function ProxyClass<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, T extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt>>(classDescriptor?: Omit<ClassDescriptor, "name" | "methodDescriptors">): ((classType: ProxyClassType<ThrowError, TError, TInvocationContext, TBigInt, T>) => void);
+/**
+ * Get class descriptors map.
+ *
+ * @returns
+ * Class descriptors map.
+ */
+declare function getClassDescriptorsMap(): ReadonlyMap<string, ClassDescriptor>;
+
+/**
+ * Application utilities.
+ */
+declare class AppUtilityProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    /**
+     * Get the version.
+     *
+     * @returns
+     * Version.
+     */
+    version(): string;
+    /**
+     * Provide default values for maximum width and height if required.
+     *
+     * @param maximumDimensions
+     * Maximum dimensions provided to function.
+     *
+     * @param invocationContext
+     * Invocation context.
+     *
+     * @returns
+     * Array of maximum width and maximum height.
+     */
+    private defaultMaximums;
+    /**
+     * Spill a horizontal matrix vertically to fit within a maximum width and height.
+     *
+     * @param hMatrixValues
+     * Horizontal matrix values. Matrix has length 1 and contains a single array with the values.
+     *
+     * @param maximumWidth
+     * Maximum width.
+     *
+     * @param maximumHeight
+     * Maximum height.
+     *
+     * @param invocationContext
+     * Invocation context.
+     *
+     * @returns
+     * Matrix spilled within maximum width and maximum height.
+     */
+    vSpill(hMatrixValues: Matrix<unknown>, maximumWidth: Nullishable<number>, maximumHeight: Nullishable<number>, invocationContext: Nullishable<TInvocationContext>): Promise<Matrix<unknown>>;
+    /**
+     * Spill a vertical matrix horizontally to fit within a maximum width and height.
+     *
+     * @param vMatrixValues
+     * Vertical matrix values. Matrix contains arrays of length 1 with the values.
+     *
+     * @param maximumHeight
+     * Maximum height.
+     *
+     * @param maximumWidth
+     * Maximum width.
+     *
+     * @param invocationContext
+     * Invocation context.
+     *
+     * @returns
+     * Matrix spilled within maximum height and maximum width.
+     */
+    hSpill(vMatrixValues: Matrix<unknown>, maximumHeight: Nullishable<number>, maximumWidth: Nullishable<number>, invocationContext: Nullishable<TInvocationContext>): Promise<Matrix<unknown>>;
+}
+
+declare class TransformerProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    forward(domain: number | bigint, matrixValues: Matrix<number | bigint>, tweak: Nullishable<number | bigint>): MatrixResultError<ResultError<TBigInt, ThrowError, TError>, ThrowError, TError>;
+    forwardSequence(domain: number | bigint, startValue: number, count: number, tweak: Nullishable<number | bigint>): Matrix<ResultError<TBigInt, ThrowError, TError>>;
+    reverse(domain: number | bigint, matrixTransformedValues: Matrix<number | bigint>, tweak: Nullishable<number | bigint>): MatrixResultError<ResultError<TBigInt, ThrowError, TError>, ThrowError, TError>;
+}
+
+declare abstract class StringProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    protected validateString<TStringValidation extends StringValidation>(validator: StringValidator<TStringValidation>, matrixSs: Matrix<string>, validation?: TStringValidation): Matrix<string>;
+    protected isValidString(matrixValidateResults: MatrixResultError<string, ThrowError, TError>): MatrixResultError<boolean, ThrowError, TError>;
+}
+
+declare class RegExpProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends StringProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    validate(regExp: string, matrixSs: Matrix<string>, errorMessage: Nullishable<string>): MatrixResultError<string, ThrowError, TError>;
+    isValid(regExp: string, matrixSs: Matrix<string>): MatrixResultError<boolean, ThrowError, TError>;
+}
+
+declare abstract class CharacterSetProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends StringProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    private readonly _characterSetCreator;
+    protected constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>, characterSetCreator: CharacterSetCreator);
+    validate(matrixSs: Matrix<string>, exclusion: Nullishable<Exclusion>): MatrixResultError<string, ThrowError, TError>;
+    isValid(matrixSs: Matrix<string>, exclusion: Nullishable<Exclusion>): MatrixResultError<boolean, ThrowError, TError>;
+    create(length: number, matrixValues: Matrix<number | bigint>, exclusion: Nullishable<Exclusion>, tweak: Nullishable<number | bigint>): MatrixResultError<string, ThrowError, TError>;
+    createSequence(length: number, startValue: number, count: number, exclusion: Nullishable<Exclusion>, tweak: Nullishable<number | bigint>): Matrix<string>;
+    valueFor(matrixSs: Matrix<string>, exclusion: Nullishable<Exclusion>, tweak: Nullishable<number | bigint>): MatrixResultError<ResultError<TBigInt, ThrowError, TError>, ThrowError, TError>;
+}
+declare class NumericProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class HexadecimalProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class AlphabeticProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class AlphanumericProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+
+declare class AI82Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class AI39Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+
+declare class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    checkDigit(matrixSs: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+    hasValidCheckDigit(matrixSs: Matrix<string>): MatrixResultError<boolean, ThrowError, TError>;
+    priceOrWeightCheckDigit(matrixSs: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+    isValidPriceOrWeightCheckDigit(s: string, checkDigit: string): ResultError<boolean, ThrowError, TError>;
+    checkCharacterPair(matrixSs: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+    hasValidCheckCharacterPair(matrixSs: Matrix<string>): MatrixResultError<boolean, ThrowError, TError>;
+}
+
+declare abstract class IdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TIdentifierValidation extends IdentifierValidation, TIdentifierValidator extends IdentifierValidator<TIdentifierValidation>> extends StringProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    private readonly _validator;
+    protected constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>, validator: TIdentifierValidator);
+    protected get validator(): TIdentifierValidator;
+}
+declare abstract class NumericIdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TNumericIdentifierValidator extends NumericIdentifierValidator> extends IdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, IdentifierValidation, TNumericIdentifierValidator> {
+    validate(matrixIdentifiers: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+}
+declare abstract class GTINValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, GTINValidator> {
+}
+declare abstract class NonGTINNumericIdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TNonGTINNumericIdentifierValidator extends NonGTINNumericIdentifierValidator> extends NumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, TNonGTINNumericIdentifierValidator> {
+}
+declare abstract class SerializableNumericIdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, SerializableNumericIdentifierValidator> {
+}
+declare abstract class NonNumericIdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends IdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonNumericIdentifierValidation, NonNumericIdentifierValidator> {
+    validate(matrixIdentifiers: Matrix<string>, exclusion: Nullishable<NonNumericIdentifierValidation["exclusion"]>): MatrixResultError<string, ThrowError, TError>;
+}
+declare class GTIN13ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends GTINValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GTIN12ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends GTINValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GTIN8ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends GTINValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GTINValidatorStaticProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    zeroSuppressGTIN12(matrixGTIN12s: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+    zeroExpandGTIN12(matrixZeroSuppressedGTIN12s: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+    convertToGTIN14(indicatorDigit: string, matrixGTINs: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+    normalizeGTIN(matrixGTINs: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+    validateGTIN(matrixGTINs: Matrix<string>, gtinLevel: Nullishable<GTINLevel>): Matrix<string>;
+    validateGTIN14(matrixGTIN14s: Matrix<string>): Matrix<string>;
+    parseVariableMeasureRCN(format: string, matrixRCNs: Matrix<string>): MatrixResultError<number, ThrowError, TError>;
+}
+declare class GLNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonGTINNumericIdentifierValidator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class SSCCValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonGTINNumericIdentifierValidator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GRAIValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GIAIValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GSRNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonGTINNumericIdentifierValidator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GDTIValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GINCValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GSINValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonGTINNumericIdentifierValidator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GCNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class CPIDValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GMNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class PrefixManagerProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    definePrefix(prefix: string, prefixType: Nullishable<PrefixType>, tweakFactor: Nullishable<number>): Matrix<unknown>;
+}
+declare abstract class IdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TIdentifierCreator extends IdentifierCreator> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    private static readonly PREFIX_TYPES;
+    private readonly _getCreator;
+    protected constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>, getCreator: (prefixManager: PrefixManager) => TIdentifierCreator);
+    protected getCreator(prefixDefinition: Matrix<unknown>): TIdentifierCreator;
+}
+declare abstract class NumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TNumericIdentifierCreator extends NumericIdentifierCreator> extends IdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, TNumericIdentifierCreator> {
+    create(prefixDefinition: Matrix<unknown>, matrixValues: Matrix<number | bigint>, sparse: Nullishable<boolean>): MatrixResultError<string, ThrowError, TError>;
+    createSequence(prefixDefinition: Matrix<unknown>, startValue: number, count: number, sparse: Nullishable<boolean>): Matrix<string>;
+    createAll(prefixDefinition: Matrix<unknown>): Matrix<string>;
+}
+declare abstract class NonGTINNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TNonGTINNumericIdentifierCreator extends NonGTINNumericIdentifierCreator> extends NumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, TNonGTINNumericIdentifierCreator> {
+}
+declare abstract class SerializableNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, SerializableNumericIdentifierCreator> {
+    createSerialized(prefixDefinition: Matrix<unknown>, value: number, matrixSerialComponents: Matrix<string>, sparse: Nullishable<boolean>): MatrixResultError<string, ThrowError, TError>;
+    concatenate(baseIdentifier: string, matrixSerialComponents: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+}
+declare abstract class NonNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends IdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonNumericIdentifierCreator> {
+    create(prefixDefinition: Matrix<unknown>, matrixReferences: Matrix<string>): MatrixResultError<string, ThrowError, TError>;
+}
+declare class GTINCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, GTINCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+    createGTIN14(indicatorDigit: string, prefixDefinition: Matrix<unknown>, matrixValues: Matrix<number | bigint>, sparse: Nullishable<boolean>): MatrixResultError<string, ThrowError, TError>;
+    createVariableMeasureRCN(format: string, itemReference: number, matrixPricesOrWeights: Matrix<number>): MatrixResultError<string, ThrowError, TError>;
+}
+declare class GLNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonGTINNumericIdentifierCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class SSCCCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonGTINNumericIdentifierCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GRAICreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GIAICreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GSRNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonGTINNumericIdentifierCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GDTICreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GINCCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GSINCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonGTINNumericIdentifierCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GCNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class CPIDCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+declare class GMNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>);
+}
+
+type index_AI39Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = AI39Proxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_AI39Proxy: typeof AI39Proxy;
+type index_AI82Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = AI82Proxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_AI82Proxy: typeof AI82Proxy;
+type index_CPIDCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = CPIDCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_CPIDCreatorProxy: typeof CPIDCreatorProxy;
+type index_CPIDValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = CPIDValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_CPIDValidatorProxy: typeof CPIDValidatorProxy;
+type index_CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = CheckProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_CheckProxy: typeof CheckProxy;
+type index_GCNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GCNCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GCNCreatorProxy: typeof GCNCreatorProxy;
+type index_GCNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GCNValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GCNValidatorProxy: typeof GCNValidatorProxy;
+type index_GDTICreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GDTICreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GDTICreatorProxy: typeof GDTICreatorProxy;
+type index_GDTIValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GDTIValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GDTIValidatorProxy: typeof GDTIValidatorProxy;
+type index_GIAICreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GIAICreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GIAICreatorProxy: typeof GIAICreatorProxy;
+type index_GIAIValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GIAIValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GIAIValidatorProxy: typeof GIAIValidatorProxy;
+type index_GINCCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GINCCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GINCCreatorProxy: typeof GINCCreatorProxy;
+type index_GINCValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GINCValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GINCValidatorProxy: typeof GINCValidatorProxy;
+type index_GLNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GLNCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GLNCreatorProxy: typeof GLNCreatorProxy;
+type index_GLNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GLNValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GLNValidatorProxy: typeof GLNValidatorProxy;
+type index_GMNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GMNCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GMNCreatorProxy: typeof GMNCreatorProxy;
+type index_GMNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GMNValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GMNValidatorProxy: typeof GMNValidatorProxy;
+type index_GRAICreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GRAICreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GRAICreatorProxy: typeof GRAICreatorProxy;
+type index_GRAIValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GRAIValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GRAIValidatorProxy: typeof GRAIValidatorProxy;
+type index_GSINCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GSINCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GSINCreatorProxy: typeof GSINCreatorProxy;
+type index_GSINValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GSINValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GSINValidatorProxy: typeof GSINValidatorProxy;
+type index_GSRNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GSRNCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GSRNCreatorProxy: typeof GSRNCreatorProxy;
+type index_GSRNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GSRNValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GSRNValidatorProxy: typeof GSRNValidatorProxy;
+type index_GTIN12ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GTIN12ValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GTIN12ValidatorProxy: typeof GTIN12ValidatorProxy;
+type index_GTIN13ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GTIN13ValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GTIN13ValidatorProxy: typeof GTIN13ValidatorProxy;
+type index_GTIN8ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GTIN8ValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GTIN8ValidatorProxy: typeof GTIN8ValidatorProxy;
+type index_GTINCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GTINCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GTINCreatorProxy: typeof GTINCreatorProxy;
+type index_GTINValidatorStaticProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = GTINValidatorStaticProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_GTINValidatorStaticProxy: typeof GTINValidatorStaticProxy;
+type index_PrefixManagerProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = PrefixManagerProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_PrefixManagerProxy: typeof PrefixManagerProxy;
+type index_SSCCCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = SSCCCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_SSCCCreatorProxy: typeof SSCCCreatorProxy;
+type index_SSCCValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> = SSCCValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt>;
+declare const index_SSCCValidatorProxy: typeof SSCCValidatorProxy;
+declare namespace index {
+  export { index_AI39Proxy as AI39Proxy, index_AI82Proxy as AI82Proxy, index_CPIDCreatorProxy as CPIDCreatorProxy, index_CPIDValidatorProxy as CPIDValidatorProxy, index_CheckProxy as CheckProxy, index_GCNCreatorProxy as GCNCreatorProxy, index_GCNValidatorProxy as GCNValidatorProxy, index_GDTICreatorProxy as GDTICreatorProxy, index_GDTIValidatorProxy as GDTIValidatorProxy, index_GIAICreatorProxy as GIAICreatorProxy, index_GIAIValidatorProxy as GIAIValidatorProxy, index_GINCCreatorProxy as GINCCreatorProxy, index_GINCValidatorProxy as GINCValidatorProxy, index_GLNCreatorProxy as GLNCreatorProxy, index_GLNValidatorProxy as GLNValidatorProxy, index_GMNCreatorProxy as GMNCreatorProxy, index_GMNValidatorProxy as GMNValidatorProxy, index_GRAICreatorProxy as GRAICreatorProxy, index_GRAIValidatorProxy as GRAIValidatorProxy, index_GSINCreatorProxy as GSINCreatorProxy, index_GSINValidatorProxy as GSINValidatorProxy, index_GSRNCreatorProxy as GSRNCreatorProxy, index_GSRNValidatorProxy as GSRNValidatorProxy, index_GTIN12ValidatorProxy as GTIN12ValidatorProxy, index_GTIN13ValidatorProxy as GTIN13ValidatorProxy, index_GTIN8ValidatorProxy as GTIN8ValidatorProxy, index_GTINCreatorProxy as GTINCreatorProxy, index_GTINValidatorStaticProxy as GTINValidatorStaticProxy, index_PrefixManagerProxy as PrefixManagerProxy, index_SSCCCreatorProxy as SSCCCreatorProxy, index_SSCCValidatorProxy as SSCCValidatorProxy };
+}
+
+/**
+ * Localization.
+ */
+interface Localization {
+    /**
+     * Name.
+     */
+    name: string;
+    /**
+     * Description.
+     */
+    description: string;
+}
+/**
+ * Function localization.
+ */
+interface FunctionLocalization extends Localization {
+    /**
+     * Documentation URL.
+     */
+    documentationURL: string;
+}
+/**
+ * Parameter localization.
+ */
+interface ParameterLocalization extends Localization {
+}
+/**
+ * Localization descriptor.
+ */
+interface LocalizationDescriptor<T extends Localization> {
+    /**
+     * Localizations map by locale.
+     */
+    readonly localizationsMap: ReadonlyMap<string, T>;
+}
+/**
+ * Proxy namespace descriptor.
+ */
+interface ProxyNamespaceDescriptor {
+    /**
+     * Namespace if any.
+     */
+    readonly namespace: string | undefined;
+}
+/**
+ * Proxy class descriptor.
+ */
+interface ProxyClassDescriptor extends ProxyNamespaceDescriptor {
+    /**
+     * Class name.
+     */
+    readonly className: string;
+    /**
+     * Namespace-qualified class name.
+     */
+    readonly namespaceClassName: string;
+    /**
+     * Class descriptor.
+     */
+    readonly classDescriptor: ClassDescriptor;
+}
+/**
+ * Proxy object descriptor.
+ */
+interface ProxyObjectDescriptor extends ProxyClassDescriptor {
+    /**
+     * Object name.
+     */
+    readonly objectName: string;
+}
+/**
+ * Proxy parameter descriptor.
+ */
+interface ProxyParameterDescriptor extends ProxyNamespaceDescriptor, LocalizationDescriptor<ParameterLocalization> {
+    /**
+     * Function name.
+     */
+    readonly parameterName: string;
+    /**
+     * Parameter descriptor.
+     */
+    readonly parameterDescriptor: BaseParameterDescriptor;
+}
+/**
+ * Proxy function descriptor.
+ */
+interface ProxyFunctionDescriptor extends ProxyObjectDescriptor, LocalizationDescriptor<FunctionLocalization> {
+    /**
+     * Function name.
+     */
+    readonly functionName: string;
+    /**
+     * Namespace-qualified function name.
+     */
+    readonly namespaceFunctionName: string;
+    /**
+     * Proxy parameter descriptors
+     */
+    readonly proxyParameterDescriptors: ProxyParameterDescriptor[];
+    /**
+     * Method descriptor.
+     */
+    readonly methodDescriptor: MethodDescriptor;
+}
+
+/**
+ * Abstract generator.
+ */
+declare abstract class Generator {
+    /**
+     * Documentation base URL.
+     */
+    private static readonly DOCUMENTATION_BASE_URL;
+    /**
+     * Documentation path, optionally preceded by locale.
+     */
+    private static readonly DOCUMENTATION_PATH;
+    /**
+     * Locales.
+     */
+    private readonly _locales;
+    /**
+     * Default locale.
+     */
+    private readonly _defaultLocale;
+    /**
+     * Map of function localizations maps by namespace function name.
+     */
+    private readonly _functionLocalizationsMapsMap;
+    /**
+     * Map of parameter localizations maps by namespace function parameter name.
+     */
+    private readonly _parameterLocalizationsMapsMap;
+    /**
+     *
+     */
+    /**
+     * Constructor.
+     *
+     * @param includeLocalizations
+     * Include localizations if true.
+     */
+    constructor(includeLocalizations?: boolean);
+    /**
+     * Get the locales.
+     */
+    protected get locales(): readonly string[];
+    /**
+     * Get the default locale.
+     */
+    protected get defaultLocale(): string;
+    /**
+     * Get function localization.
+     *
+     * @param namespaceFunctionName
+     * Namespace function name.
+     *
+     * @param locale
+     * Locale.
+     *
+     * @returns
+     * Function localization.
+     */
+    protected getFunctionLocalization(namespaceFunctionName: string, locale: string): FunctionLocalization;
+    /**
+     * Get parameter localization.
+     *
+     * @param namespaceFunctionName
+     * Namespace function name.
+     *
+     * @param parameterName
+     * Parameter name.
+     *
+     * @param locale
+     * Locale.
+     *
+     * @returns
+     * Function localization.
+     */
+    protected getParameterLocalization(namespaceFunctionName: string, parameterName: string, locale: string): ParameterLocalization;
+    /**
+     * Initialize the generation of the output.
+     */
+    protected abstract initialize(): void;
+    /**
+     * Create a proxy object.
+     *
+     * @param proxyObjectDescriptor
+     * Proxy object descriptor.
+     */
+    protected abstract createProxyObject(proxyObjectDescriptor: ProxyObjectDescriptor): void;
+    /**
+     * Create a proxy function.
+     *
+     * @param proxyFunctionDescriptor
+     * Proxy function descriptor.
+     */
+    protected abstract createProxyFunction(proxyFunctionDescriptor: ProxyFunctionDescriptor): void;
+    /**
+     * Finalize the generation of the output.
+     *
+     * @param success
+     * True if successful.
+     */
+    protected abstract finalize(success: boolean): void | Promise<void>;
+    /**
+     * Generate localizations map.
+     *
+     * @param localizedKeyPrefix
+     * Localized key prefix.
+     *
+     * @param localizationCallback
+     * Callback to finalize localization.
+     *
+     * @returns
+     * Localization map.
+     */
+    private generateLocalizationsMap;
+    /**
+     * Generate by processing individual imports.
+     */
+    generate(): Promise<void>;
+}
+
+export { type Address, AlphabeticProxy, AlphanumericProxy, AppExtension, type AppExtensionLocaleResources, AppUtilityProxy, type BaseParameterDescriptor, CharacterSetProxy, type ClassDescriptor, type ErrorExtends, type ExtendsParameterDescriptor, type FunctionLocalization, index as GS1, Generator, HexadecimalProxy, LibProxy, type Localization, type LocalizationDescriptor, type Matrix, type MatrixResultError, type MethodDescriptor, NumericProxy, type ParameterDescriptor, type ParameterLocalization, ProxyClass, type ProxyClassDescriptor, type ProxyFunctionDescriptor, ProxyMethod, type ProxyNamespaceDescriptor, type ProxyObjectDescriptor, ProxyParameter, type ProxyParameterDescriptor, type Range, RegExpProxy, type ResultError, type Sheet, type SheetAddress, type SheetRange, TransformerProxy, type Type, Types, appExtensionNS, appExtensionResources, expandParameterDescriptor, getClassDescriptorsMap, i18nAppExtensionInit, i18nextAppExtension };