@aidc-toolkit/utility 0.9.14-beta → 0.9.15-beta

package/dist/locale/en/locale-strings.d.ts

@@ -0,0 +1,33 @@
+export declare const localeStrings: {
+    readonly Transformer: {
+        readonly domainMustBeGreaterThanZero: "Domain {{domain}} must be greater than 0";
+        readonly tweakMustBeGreaterThanOrEqualToZero: "Tweak {{tweak}} must be greater than or equal to 0";
+        readonly valueMustBeGreaterThanOrEqualToZero: "Value {{value}} must be greater than or equal to 0";
+        readonly valueMustBeLessThan: "Value {{value}} must be less than {{domain}}";
+        readonly minimumValueMustBeGreaterThanOrEqualToZero: "Minimum value {{minimumValue}} must be greater than or equal to 0";
+        readonly maximumValueMustBeLessThan: "Maximum value {{maximumValue}} must be less than {{domain}}";
+    };
+    readonly RegExpValidator: {
+        readonly stringDoesNotMatchPattern: "String {{s}} does not match pattern";
+    };
+    readonly CharacterSetValidator: {
+        readonly firstZeroFirstCharacter: "Character set must support zero as first character";
+        readonly allNumericAllNumericCharacters: "Character set must support all numeric characters in sequence";
+        readonly stringMustNotBeAllNumeric: "String must not be all numeric";
+        readonly lengthMustBeGreaterThanOrEqualTo: "Length {{length}} must be greater than or equal to {{minimumLength}}";
+        readonly lengthMustBeLessThanOrEqualTo: "Length {{length}} must be less than or equal to {{maximumLength}}";
+        readonly lengthMustBeEqualTo: "Length {{length}} must be equal to {{exactLength}}";
+        readonly lengthOfComponentMustBeGreaterThanOrEqualTo: "Length {{length}} of {{component}} must be greater than or equal to {{minimumLength}}";
+        readonly lengthOfComponentMustBeLessThanOrEqualTo: "Length {{length}} of {{component}} must be less than or equal to {{maximumLength}}";
+        readonly lengthOfComponentMustBeEqualTo: "Length {{length}} of {{component}} must be equal to {{exactLength}}";
+        readonly invalidCharacterAtPosition: "Invalid character '{{c}}' at position {{position}}";
+        readonly invalidCharacterAtPositionOfComponent: "Invalid character '{{c}}' at position {{position}} of {{component}}";
+        readonly exclusionNotSupported: "Exclusion value of {{exclusion}} is not supported";
+        readonly invalidTweakWithAllNumericExclusion: "Tweak must not be used with all-numeric exclusion";
+        readonly endSequenceValueMustBeLessThanOrEqualTo: "End sequence value (start sequence value + count - 1) must be less than {{domain}}";
+    };
+    readonly RecordValidator: {
+        readonly typeNameKeyNotFound: "{{typeName}} \"{{key}}\" not found";
+    };
+};
+//# sourceMappingURL=locale-strings.d.ts.map

package/dist/locale/en/locale-strings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-strings.d.ts","sourceRoot":"","sources":["../../../src/locale/en/locale-strings.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BhB,CAAC"}

package/dist/locale/fr/locale-strings.d.ts

@@ -0,0 +1,33 @@
+export declare const localeStrings: {
+    readonly Transformer: {
+        readonly domainMustBeGreaterThanZero: "Le domaine {{domain}} doit être supérieur à 0";
+        readonly tweakMustBeGreaterThanOrEqualToZero: "Le réglage {{tweak}} doit être supérieur ou égal à 0";
+        readonly valueMustBeGreaterThanOrEqualToZero: "La valeur {{value}} doit être supérieure ou égale à 0";
+        readonly valueMustBeLessThan: "La valeur {{value}} doit être inférieure à {{domain}}";
+        readonly minimumValueMustBeGreaterThanOrEqualToZero: "La valeur minimale {{minimumValue}} doit être supérieure ou égale à 0";
+        readonly maximumValueMustBeLessThan: "La valeur maximale {{maximumValue}} doit être inférieure à {{domain}}";
+    };
+    readonly RegExpValidator: {
+        readonly stringDoesNotMatchPattern: "La chaîne {{s}} ne correspond pas au modèle";
+    };
+    readonly CharacterSetValidator: {
+        readonly firstZeroFirstCharacter: "Le jeu de caractères doit prendre en charge zéro comme premier caractère";
+        readonly allNumericAllNumericCharacters: "Le jeu de caractères doit prendre en charge tous les caractères numériques en séquence";
+        readonly stringMustNotBeAllNumeric: "La chaîne ne doit pas être entièrement numérique";
+        readonly lengthMustBeGreaterThanOrEqualTo: "La longueur {{length}} doit être supérieure ou égale à {{minimumLength}}";
+        readonly lengthMustBeLessThanOrEqualTo: "La longueur {{length}} doit être inférieure ou égale à {{maximumLength}}";
+        readonly lengthMustBeEqualTo: "La longueur {{length}} doit être égale à {{exactLength}}";
+        readonly lengthOfComponentMustBeGreaterThanOrEqualTo: "La longueur {{length}} de {{component}} doit être supérieure ou égale à {{minimumLength}}";
+        readonly lengthOfComponentMustBeLessThanOrEqualTo: "La longueur {{length}} de {{component}} doit être inférieure ou égale à {{maximumLength}}";
+        readonly lengthOfComponentMustBeEqualTo: "La longueur {{length}} de {{component}} doit être égale à {{exactLength}}";
+        readonly invalidCharacterAtPosition: "Caractère non valide '{{c}}' à la position {{position}}";
+        readonly invalidCharacterAtPositionOfComponent: "Caractère non valide '{{c}}' à la position {{position}} de {{component}}";
+        readonly exclusionNotSupported: "La valeur d'exclusion de {{exclusion}} n'est pas prise en charge";
+        readonly invalidTweakWithAllNumericExclusion: "Le réglage ne doit pas être utilisé avec une exclusion entièrement numérique";
+        readonly endSequenceValueMustBeLessThanOrEqualTo: "La valeur de la séquence de fin (valeur de la séquence de début + nombre - 1) doit être inférieure à {{domaine}}";
+    };
+    readonly RecordValidator: {
+        readonly typeNameKeyNotFound: "{{typeName}} \"{{key}}\" introuvable";
+    };
+};
+//# sourceMappingURL=locale-strings.d.ts.map

package/dist/locale/fr/locale-strings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-strings.d.ts","sourceRoot":"","sources":["../../../src/locale/fr/locale-strings.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BhB,CAAC"}

package/dist/locale/i18n.d.ts

@@ -0,0 +1,27 @@
+import { type I18NEnvironment } from "@aidc-toolkit/core";
+import { type i18n, type Resource } from "i18next";
+import { localeStrings as enLocaleStrings } from "./en/locale-strings.js";
+export declare const utilityNS = "aidct_utility";
+/**
+ * Locale strings type is extracted from the English locale strings object.
+ */
+export type UtilityLocaleStrings = typeof enLocaleStrings;
+/**
+ * Utility resources.
+ */
+export declare const utilityResources: Resource;
+export declare const i18nextUtility: i18n;
+/**
+ * Initialize internationalization.
+ *
+ * @param environment
+ * Environment in which the application is running.
+ *
+ * @param debug
+ * Debug setting.
+ *
+ * @returns
+ * Void promise.
+ */
+export declare function i18nUtilityInit(environment: I18NEnvironment, debug?: boolean): Promise<void>;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/locale/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/locale/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0C,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAClG,OAAgB,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,EAAE,aAAa,IAAI,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG1E,eAAO,MAAM,SAAS,kBAAkB,CAAC;AAEzC;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,eAAe,CAAC;AAI1D;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAO9B,CAAC;AAGF,eAAO,MAAM,cAAc,EAAE,IAA+B,CAAC;AAE7D;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,WAAW,EAAE,eAAe,EAAE,KAAK,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhG"}

package/dist/record.d.ts

@@ -0,0 +1,41 @@
+import type { StringValidator } from "./string.js";
+/**
+ * Record validator. Validation is performed against a record with a string key type and throws an error if the key is
+ * not found.
+ */
+export declare class RecordValidator<T> implements StringValidator {
+    /**
+     * Type name for error message.
+     */
+    private readonly _typeName;
+    /**
+     * Record in which to look up keys.
+     */
+    private readonly _record;
+    /**
+     * Constructor.
+     *
+     * @param typeName
+     * Type name for error message.
+     *
+     * @param record
+     * Record in which to look up keys.
+     */
+    constructor(typeName: string, record: Readonly<Record<string, T>>);
+    /**
+     * Get the type name.
+     */
+    get typeName(): string;
+    /**
+     * Get the record.
+     */
+    get record(): Readonly<Record<string, T>>;
+    /**
+     * Validate a key by looking it up in the record.
+     *
+     * @param key
+     * Record key.
+     */
+    validate(key: string): void;
+}
+//# sourceMappingURL=record.d.ts.map

package/dist/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../src/record.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;GAGG;AACH,qBAAa,eAAe,CAAC,CAAC,CAAE,YAAW,eAAe;IACtD;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IAEtD;;;;;;;;OAQG;gBACS,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAKjE;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAExC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAQ9B"}

package/dist/reg-exp.d.ts

@@ -0,0 +1,43 @@
+import type { StringValidator } from "./string.js";
+/**
+ * Regular expression validator. The regular expression applies to the full string only if constructed as such. For
+ * example, <code>&#x2F;\d&#x2A;&#x2F;</code> (0 or more digits) matches every string, <code>&#x2F;\d+&#x2F;</code>
+ * (1 or more digits) matches strings with at least one digit, <code>&#x2F;^\d&#x2A;$&#x2F;</code> matches strings that
+ * are all digits or empty, and <code>&#x2F;^\d+$&#x2F;</code> matches strings that are all digits and not empty.
+ *
+ * Clients of this class are recommended to override the {@link createErrorMessage} method create a more suitable error
+ * message for their use case.
+ */
+export declare class RegExpValidator implements StringValidator {
+    /**
+     * Regular expression.
+     */
+    private readonly _regExp;
+    /**
+     * Constructor.
+     *
+     * @param regExp
+     * Regular expression. See {@link RegExpValidator | class documentation} for notes.
+     */
+    constructor(regExp: RegExp);
+    /**
+     * Get the regular expression.
+     */
+    get regExp(): RegExp;
+    /**
+     * Create an error message for a string. The generic error message is sufficient for many use cases but a more
+     * domain-specific error message, possibly including the pattern itself, is often required.
+     *
+     * @param s
+     * String.
+     *
+     * @returns
+     * Error message.
+     */
+    protected createErrorMessage(s: string): string;
+    /**
+     * @inheritDoc
+     */
+    validate(s: string): void;
+}
+//# sourceMappingURL=reg-exp.d.ts.map

package/dist/reg-exp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reg-exp.d.ts","sourceRoot":"","sources":["../src/reg-exp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;;;;;GAQG;AACH,qBAAa,eAAgB,YAAW,eAAe;IACnD;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC;;;;;OAKG;gBACS,MAAM,EAAE,MAAM;IAI1B;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;;;OASG;IACH,SAAS,CAAC,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAM/C;;OAEG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;CAK5B"}

package/dist/sequence.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Sequence. Defines an ascending or descending sequence of big integers implemented as an iterable.
+ */
+export declare class Sequence implements Iterable<bigint> {
+    /**
+     * Start value (inclusive).
+     */
+    private readonly _startValue;
+    /**
+     * End value (exclusive).
+     */
+    private readonly _endValue;
+    /**
+     * Count of values.
+     */
+    private readonly _count;
+    /**
+     * Delta to the next value; equal to the sign of the count.
+     */
+    private readonly _nextDelta;
+    /**
+     * Minimum value (inclusive).
+     */
+    private readonly _minimumValue;
+    /**
+     * Maximum value (inclusive).
+     */
+    private readonly _maximumValue;
+    /**
+     * Constructor.
+     *
+     * @param startValue
+     * Start value.
+     *
+     * @param count
+     * Count of values. If count is zero or positive, iteration ascends from start value, otherwise it descends from
+     * start value.
+     */
+    constructor(startValue: number | bigint, count: number);
+    /**
+     * Get the start value (inclusive).
+     */
+    get startValue(): bigint;
+    /**
+     * Get the end value (exclusive).
+     */
+    get endValue(): bigint;
+    /**
+     * Get the count of values.
+     */
+    get count(): number;
+    /**
+     * Get the minimum value (inclusive).
+     */
+    get minimumValue(): bigint;
+    /**
+     * Get the maximum value (inclusive).
+     */
+    get maximumValue(): bigint;
+    /**
+     * Iterable implementation.
+     *
+     * @yields
+     * Next value in sequence.
+     */
+    [Symbol.iterator](): Generator<bigint>;
+}
+//# sourceMappingURL=sequence.d.ts.map

package/dist/sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../src/sequence.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,QAAS,YAAW,QAAQ,CAAC,MAAM,CAAC;IAC7C;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAW;IAEtC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC;;;;;;;;;OASG;gBACS,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM;IAgBtD;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;;;OAKG;IACD,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC;CAK3C"}

package/dist/string.d.ts

@@ -0,0 +1,22 @@
+/**
+ * String validation interface. To ensure signature compatibility in implementing classes, string validation is
+ * controlled by validation interfaces specific to each validator type.
+ */
+export interface StringValidation {
+}
+/**
+ * String validator interface.
+ */
+export interface StringValidator<V extends StringValidation = StringValidation> {
+    /**
+     * Validate a string and throw an error if validation fails.
+     *
+     * @param s
+     * String.
+     *
+     * @param validation
+     * String validation parameters.
+     */
+    validate: (s: string, validation?: V) => void;
+}
+//# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,gBAAgB;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB;IAC1E;;;;;;;;OAQG;IACH,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;CACjD"}

package/dist/transformer.d.ts

@@ -0,0 +1,377 @@
+/**
+ * Transformer primitive type.
+ */
+export type TransformerPrimitive = string | number | bigint | boolean;
+/**
+ * Transformer input type, one of:
+ *
+ * - TInput (primitive type)
+ * - Iterable<TInput>
+ *
+ * @template TInput
+ * Transformer input primitive type.
+ */
+export type TransformerInput<TInput extends TransformerPrimitive> = TInput | Iterable<TInput>;
+/**
+ * Transformer callback, used to convert transformed value to its final value.
+ *
+ * @template TInput
+ * Transformer input primitive type.
+ *
+ * @template TOutput
+ * Transformer output type.
+ *
+ * @param input
+ * Input value.
+ *
+ * @param index
+ * Index in sequence (0 for single transformation).
+ *
+ * @returns
+ * Output value.
+ */
+export type TransformerCallback<TInput extends TransformerPrimitive, TOutput> = (input: TInput, index: number) => TOutput;
+/**
+ * Transformer output, based on transformer input:
+ *
+ * - If type TTransformerInput is primitive, result is type TOutput.
+ * - If type TTransformerInput is Iterable, result is type Iterable<TOutput>.
+ *
+ * @template TTransformerInput
+ * Transformer input type.
+ *
+ * @template TOutput
+ * Output base type.
+ */
+export type TransformerOutput<TTransformerInput extends TransformerInput<TransformerPrimitive>, TOutput> = TTransformerInput extends (TTransformerInput extends TransformerInput<infer TInput> ? TInput : never) ? TOutput : Iterable<TOutput>;
+/**
+ * Transform an input iterable to an output iterable that applies a transformer callback to each value in the input.
+ *
+ * @param values
+ * Input values iterable.
+ *
+ * @param transformerCallback
+ * Callback to transform input value to output value.
+ *
+ * @returns
+ * Output values iterable.
+ */
+export declare function transformIterable<TInput extends TransformerPrimitive, TOutput>(values: Iterable<TInput>, transformerCallback: TransformerCallback<TInput, TOutput>): Iterable<TOutput>;
+/**
+ * Transformer that transforms values in a numeric domain to values in a range equal to the domain or to another range
+ * defined by a callback function. In other words, the domain determines valid input values and, without a callback, the
+ * range of valid output values.
+ *
+ * The concept is similar to {@link https://en.wikipedia.org/wiki/Format-preserving_encryption | format-preserving
+ * encryption}, where input values within a specified domain (e.g., {@link
+ * https://en.wikipedia.org/wiki/Payment_card_number | payment card numbers} ranging from 8-19 digits) are transformed
+ * into values in the same domain, typically for storage in a database where the data type and length are already fixed
+ * and exfiltration of the data can have significant repercussions.
+ *
+ * Two subclasses are supported directly by this class: {@link IdentityTransformer} (which operates based on a domain
+ * only) and {@link EncryptionTransformer} (which operates based on a domain and a tweak). If an application is expected
+ * to make repeated use of a transformer with the same domain and (optional) tweak and can't manage the transformer
+ * object, an in-memory cache is available via the {@link get} method. Properties in {@link IdentityTransformer} and
+ * {@link EncryptionTransformer} are read-only once constructed, so there is no issue with their shared use.
+ */
+export declare abstract class Transformer {
+    /**
+     * Transformers cache, mapping a domain to another map, which maps an optional tweak to a transformer.
+     */
+    private static readonly TRANSFORMER_MAPS_MAP;
+    /**
+     * Domain.
+     */
+    private readonly _domain;
+    /**
+     * Constructor.
+     *
+     * @param domain
+     * Domain.
+     */
+    constructor(domain: number | bigint);
+    /**
+     * Get a transformer, constructing it if necessary. The type returned is {@link IdentityTransformer} if tweak is
+     * undefined, {@link EncryptionTransformer} if tweak is defined. Note that although an {@link EncryptionTransformer}
+     * with a zero tweak operates as an {@link IdentityTransformer}, {@link EncryptionTransformer} is still the type
+     * returned if a zero tweak is explicitly specified.
+     *
+     * @param domain
+     * Domain.
+     *
+     * @param tweak
+     * Tweak.
+     *
+     * @returns
+     * {@link IdentityTransformer} if tweak is undefined, {@link EncryptionTransformer} if tweak is defined.
+     */
+    static get(domain: number | bigint, tweak?: number | bigint): Transformer;
+    /**
+     * Get the domain.
+     */
+    get domain(): bigint;
+    /**
+     * Validate that a value is within the domain.
+     *
+     * @param value
+     * Value.
+     */
+    private validate;
+    /**
+     * Do the work of transforming a value forward.
+     *
+     * @param value
+     * Value.
+     *
+     * @returns
+     * Transformed value.
+     */
+    protected abstract doForward(value: bigint): bigint;
+    /**
+     * Validate that a value is within the domain and do the work of transforming it forward.
+     *
+     * @param value
+     * Value.
+     *
+     * @returns
+     * Transformed value.
+     */
+    private validateDoForward;
+    /**
+     * Validate that a value is within the domain, do the work of transforming it forward, and apply a callback.
+     *
+     * @param transformerCallback
+     * Called after each value is transformed to convert it to its final value.
+     *
+     * @param value
+     * Value.
+     *
+     * @param index
+     * Index in sequence (0 for single transformation).
+     *
+     * @returns
+     * Transformed value.
+     */
+    private validateDoForwardCallback;
+    /**
+     * Transform value(s) forward.
+     *
+     * @template TTransformerInput
+     * Value(s) input type.
+     *
+     * @param valueOrValues
+     * Value(s). If this is an instance of {@link Sequence}, the minimum and maximum values are validated prior to
+     * transformation. Otherwise, the individual value(s) is/are validated at the time of transformation.
+     *
+     * @returns
+     * Transformed value(s).
+     */
+    forward<TTransformerInput extends TransformerInput<number | bigint>>(valueOrValues: TTransformerInput): TransformerOutput<TTransformerInput, bigint>;
+    /**
+     * Transform value(s) forward, optionally applying a transformation.
+     *
+     * @template TTransformerInput
+     * Value(s) input type.
+     *
+     * @template TOutput
+     * Transformation callback output type.
+     *
+     * @param valueOrValues
+     * Value(s). If this is an instance of {@link Sequence}, the minimum and maximum values are validated prior to
+     * transformation. Otherwise, the individual value(s) is/are validated at the time of transformation.
+     *
+     * @param transformerCallback
+     * Called after each value is transformed to convert it to its final value.
+     *
+     * @returns
+     * Transformed value(s).
+     */
+    forward<TTransformerInput extends TransformerInput<number | bigint>, TOutput>(valueOrValues: TTransformerInput, transformerCallback: TransformerCallback<bigint, TOutput>): TransformerOutput<TTransformerInput, TOutput>;
+    /**
+     * Do the work of transforming a value in reverse.
+     *
+     * @param transformedValue
+     * Transformed value.
+     *
+     * @returns
+     * Value.
+     */
+    protected abstract doReverse(transformedValue: bigint): bigint;
+    /**
+     * Transform a value in reverse.
+     *
+     * @param transformedValue
+     * Transformed value.
+     *
+     * @returns
+     * Value.
+     */
+    reverse(transformedValue: number | bigint): bigint;
+}
+/**
+ * Identity transformer. Values are transformed to themselves.
+ */
+export declare class IdentityTransformer extends Transformer {
+    /**
+     * @inheritDoc
+     */
+    protected doForward(value: bigint): bigint;
+    /**
+     * @inheritDoc
+     */
+    protected doReverse(transformedValue: bigint): bigint;
+}
+/**
+ * Encryption transformer. Values are transformed using repeated shuffle and xor operations, similar to those found in
+ * many cryptography algorithms, particularly AES. While sufficient for obfuscation of numeric sequences (e.g., serial
+ * number generation, below), if true format-preserving encryption is required, a more robust algorithm such as
+ * {@link https://doi.org/10.6028/NIST.SP.800-38Gr1-draft | FF1} is recommended. Furthermore, no work has been done to
+ * mitigate {@link https://timing.attacks.cr.yp.to/index.html | timing attacks} for key detection.
+ *
+ * The purpose of the encryption transformer is to generate pseudo-random values in a deterministic manner to obscure
+ * the sequence of values generated over time. A typical example is for serial number generation, where knowledge of the
+ * sequence can infer production volumes (e.g., serial number 1000 implies that at least 1,000 units have been
+ * manufactured) or can be used in counterfeiting (e.g., a counterfeiter can generate serial numbers 1001, 1002, ...
+ * with reasonable confidence that they would be valid if queried).
+ *
+ * The domain and the tweak together determine the encryption key, which in turn determines the number of rounds of
+ * shuffle and xor operations. The minimum number of rounds is 4, except where the domain is less than or equal to 256,
+ * which results in single-byte operations. To ensure that the operations are effective for single-byte domains, the
+ * number of rounds is 1 and only the xor operation is applied (shuffling a single byte is an identity operation).
+ *
+ * Another exception is when there is a tweak value of 0; this results in identity operations where the output value is
+ * identical to the input value, as no shuffle or xor takes place.
+ */
+export declare class EncryptionTransformer extends Transformer {
+    /**
+     * Individual bits, pre-calculated for performance.
+     */
+    private static readonly BITS;
+    /**
+     * Inverse individual bits, pre-calculated for performance.
+     */
+    private static readonly INVERSE_BITS;
+    /**
+     * Number of bytes covered by the domain.
+     */
+    private readonly _domainBytes;
+    /**
+     * Xor bytes array generated from the domain and tweak.
+     */
+    private readonly _xorBytes;
+    /**
+     * Bits array generated from the domain and tweak.
+     */
+    private readonly _bits;
+    /**
+     * Inverse bits array generated from the domain and tweak.
+     */
+    private readonly _inverseBits;
+    /**
+     * Number of rounds (length of arrays) generated from the domain and tweak.
+     */
+    private readonly _rounds;
+    /**
+     * Constructor.
+     *
+     * @param domain
+     * Domain.
+     *
+     * @param tweak
+     * Tweak.
+     */
+    constructor(domain: number | bigint, tweak: number | bigint);
+    /**
+     * Convert a value to a byte array big enough to handle the entire domain.
+     *
+     * @param value
+     * Value.
+     *
+     * @returns
+     * Big-endian byte array equivalent to the value.
+     */
+    private valueToBytes;
+    /**
+     * Convert a byte array to a value.
+     *
+     * @param bytes
+     * Big-endian byte array equivalent to the value.
+     *
+     * @returns
+     * Value.
+     */
+    private static bytesToValue;
+    /**
+     * Shuffle a byte array.
+     *
+     * The input array to the forward operation (output from the reverse operation) is `bytes` and the output array from
+     * the forward operation (input to the reverse operation) is `bytes'`.
+     *
+     * The shuffle operation starts by testing the bit at `bits[round]` for each `byte` in `bytes`. The indexes for all
+     * bytes with that bit set are put into one array (`shuffleIndexes1`) and the rest are put into another
+     * (`shuffleIndexes0`). The two arrays are concatenated and used to shuffle the input array, using their values
+     * (`shuffleIndex`) and the indexes of those values (`index`) in the concatenated array.
+     *
+     * Forward shuffling moves the entry at `shuffleIndex` to the `index` position.
+     *
+     * Reverse shuffling moves the entry at `index` to the `shuffleIndex` position.
+     *
+     * As each byte is moved, the bit at `bits[round]` is preserved in its original position. This ensures that the
+     * process is reversible.
+     *
+     * @param bytes
+     * Byte array.
+     *
+     * @param round
+     * Round number.
+     *
+     * @param forward
+     * True if operating forward (encrypting), false if operating in reverse (decrypting).
+     *
+     * @returns
+     * Shuffled byte array.
+     */
+    private shuffle;
+    /**
+     * Xor a byte array.
+     *
+     * The input array to the forward operation (output from the reverse operation) is `bytes` and the output array from
+     * the forward operation (input to the reverse operation) is `bytes'`.
+     *
+     * Forward:
+     * - `bytes'[0] = bytes[0] ^ xorBytes[round]`
+     * - `bytes'[1] = bytes[1] ^ bytes'[0]`
+     * - `bytes'[2] = bytes[2] ^ bytes'[1]`
+     * - `...`
+     * - `bytes'[domainBytes - 1] = bytes[domainBytes - 1] ^ bytes'[domainBytes - 2]`
+     *
+     * Reverse:
+     * - `bytes[0] = bytes'[0] ^ xorBytes[round]`
+     * - `bytes[1] = bytes'[1] ^ bytes'[0]`
+     * - `bytes[2] = bytes'[2] ^ bytes'[1]`
+     * - `...`
+     * - `bytes[domainBytes - 1] = bytes'[domainBytes - 1] ^ bytes'[domainBytes - 2]`
+     *
+     * @param bytes
+     * Byte array.
+     *
+     * @param round
+     * Round number.
+     *
+     * @param forward
+     * True if operating forward (encrypting), false if operating in reverse (decrypting).
+     *
+     * @returns
+     * Xored byte array.
+     */
+    private xor;
+    /**
+     * @inheritDoc
+     */
+    protected doForward(value: bigint): bigint;
+    /**
+     * @inheritDoc
+     */
+    protected doReverse(transformedValue: bigint): bigint;
+}
+//# sourceMappingURL=transformer.d.ts.map