@brightchain/brightchain-lib 0.1.4 → 0.1.6

package/src/lib/types/checksum.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Unified Checksum class that handles both Buffer and Uint8Array representations.
+ *
+ * This class provides a consistent interface for working with checksums,
+ * eliminating the need for manual type conversions between Buffer and Uint8Array.
+ *
+ * @example
+ * ```typescript
+ * // Create from Buffer
+ * const checksum1 = Checksum.fromBuffer(buffer);
+ *
+ * // Create from Uint8Array
+ * const checksum2 = Checksum.fromUint8Array(uint8Array);
+ *
+ * // Create from hex string
+ * const checksum3 = Checksum.fromHex('a1b2c3...');
+ *
+ * // Compare checksums
+ * if (checksum1.equals(checksum2)) {
+ *   console.log('Checksums match');
+ * }
+ *
+ * // Convert to different formats
+ * const buffer = checksum1.toBuffer();
+ * const uint8Array = checksum1.toUint8Array();
+ * const hex = checksum1.toHex();
+ * ```
+ *
+ * @see Requirements 1.1, 1.2, 1.3, 1.4, 1.5
+ */
+export { ChecksumErrorType } from '../errors/checksumError';
+/**
+ * Unified checksum class that handles both Buffer and Uint8Array representations.
+ *
+ * The class uses Uint8Array internally for efficiency and provides conversion
+ * methods to Buffer and hex string formats.
+ *
+ * @remarks
+ * - The constructor is private; use factory methods to create instances
+ * - All checksums must be exactly SHA3_BUFFER_LENGTH bytes (64 bytes for SHA3-512)
+ * - The equals() method performs byte-by-byte comparison
+ * - toString() is an alias for toHex()
+ *
+ * @see Requirements 1.1, 1.2, 1.3, 1.4, 1.5
+ */
+export declare class Checksum {
+    /**
+     * Internal storage for checksum data.
+     * Uses Uint8Array for efficiency.
+     */
+    private readonly data;
+    /**
+     * Private constructor to enforce factory pattern.
+     *
+     * @param data - The checksum data as Uint8Array
+     * @throws ChecksumError if data length is not equal to SHA3_BUFFER_LENGTH
+     *
+     * @internal
+     */
+    private constructor();
+    /**
+     * Create a Checksum from a Buffer.
+     *
+     * @param buffer - The buffer containing checksum data
+     * @returns A new Checksum instance
+     * @throws ChecksumError if buffer length is not equal to SHA3_BUFFER_LENGTH
+     *
+     * @example
+     * ```typescript
+     * const buffer = Buffer.from('a'.repeat(128), 'hex'); // 64 bytes
+     * const checksum = Checksum.fromBuffer(buffer);
+     * ```
+     *
+     * @see Requirement 1.2
+     */
+    static fromBuffer(buffer: Buffer): Checksum;
+    /**
+     * Create a Checksum from a Uint8Array.
+     *
+     * @param array - The Uint8Array containing checksum data
+     * @returns A new Checksum instance
+     * @throws ChecksumError if array length is not equal to SHA3_BUFFER_LENGTH
+     *
+     * @example
+     * ```typescript
+     * const array = new Uint8Array(64);
+     * crypto.getRandomValues(array);
+     * const checksum = Checksum.fromUint8Array(array);
+     * ```
+     *
+     * @see Requirement 1.2
+     */
+    static fromUint8Array(array: Uint8Array): Checksum;
+    /**
+     * Create a Checksum from a hex string.
+     *
+     * @param hex - The hex string representation of the checksum
+     * @returns A new Checksum instance
+     * @throws ChecksumError if hex string is invalid or results in wrong length
+     *
+     * @example
+     * ```typescript
+     * const hex = 'a1b2c3d4...'; // 128 hex characters = 64 bytes
+     * const checksum = Checksum.fromHex(hex);
+     * ```
+     *
+     * @see Requirement 1.2
+     */
+    static fromHex(hex: string): Checksum;
+    /**
+     * Compare this checksum with another for equality.
+     *
+     * Performs a byte-by-byte comparison of the underlying data.
+     *
+     * @param other - The other Checksum to compare with
+     * @returns true if the checksums are equal, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const checksum1 = Checksum.fromBuffer(buffer1);
+     * const checksum2 = Checksum.fromBuffer(buffer2);
+     * if (checksum1.equals(checksum2)) {
+     *   console.log('Checksums match');
+     * }
+     * ```
+     *
+     * @see Requirement 1.3
+     */
+    equals(other: Checksum): boolean;
+    /**
+     * Convert the checksum to a Buffer.
+     *
+     * @returns A new Buffer containing the checksum data
+     *
+     * @example
+     * ```typescript
+     * const checksum = Checksum.fromHex(hexString);
+     * const buffer = checksum.toBuffer();
+     * ```
+     *
+     * @see Requirement 1.5
+     */
+    toBuffer(): Buffer;
+    /**
+     * Convert the checksum to a Uint8Array.
+     *
+     * @returns A new Uint8Array containing the checksum data
+     *
+     * @remarks
+     * Returns a copy of the internal data to maintain immutability.
+     *
+     * @example
+     * ```typescript
+     * const checksum = Checksum.fromBuffer(buffer);
+     * const array = checksum.toUint8Array();
+     * ```
+     *
+     * @see Requirement 1.5
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Convert the checksum to a lowercase hex string.
+     *
+     * @returns The checksum as a lowercase hex string
+     *
+     * @example
+     * ```typescript
+     * const checksum = Checksum.fromBuffer(buffer);
+     * const hex = checksum.toHex(); // 'a1b2c3d4...'
+     * ```
+     *
+     * @see Requirement 1.4
+     */
+    toHex(): string;
+    /**
+     * Convert the checksum to a string representation.
+     *
+     * This is an alias for toHex() for consistent behavior.
+     *
+     * @returns The checksum as a lowercase hex string
+     *
+     * @example
+     * ```typescript
+     * const checksum = Checksum.fromBuffer(buffer);
+     * console.log(`Checksum: ${checksum}`); // Uses toString() implicitly
+     * ```
+     *
+     * @see Requirement 1.4
+     */
+    toString(): string;
+    /**
+     * Get the length of the checksum in bytes.
+     *
+     * @returns The length of the checksum data in bytes
+     */
+    get length(): number;
+}
+/**
+ * Type guard to check if a value is a Checksum instance.
+ *
+ * @param value - The value to check
+ * @returns true if the value is a Checksum instance
+ *
+ * @example
+ * ```typescript
+ * if (isChecksum(value)) {
+ *   // value is narrowed to Checksum type
+ *   console.log(value.toHex());
+ * }
+ * ```
+ *
+ * @see Requirement 14.1
+ */
+export declare function isChecksum(value: unknown): value is Checksum;
+//# sourceMappingURL=checksum.d.ts.map

package/src/lib/types/checksum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/types/checksum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAElC;;;;;;;OAOG;IACH,OAAO;IAeP;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ;IAI3C;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ;IAIlD;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;IAwBrC;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAYhC;;;;;;;;;;;;OAYG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;;;;;;;;;;;;OAeG;IACH,YAAY,IAAI,UAAU;IAI1B;;;;;;;;;;;;OAYG;IACH,KAAK,IAAI,MAAM;IAIf;;;;;;;;;;;;;;OAcG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;OAIG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D"}

package/src/lib/types/checksum.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * Unified Checksum class that handles both Buffer and Uint8Array representations.
+ *
+ * This class provides a consistent interface for working with checksums,
+ * eliminating the need for manual type conversions between Buffer and Uint8Array.
+ *
+ * @example
+ * ```typescript
+ * // Create from Buffer
+ * const checksum1 = Checksum.fromBuffer(buffer);
+ *
+ * // Create from Uint8Array
+ * const checksum2 = Checksum.fromUint8Array(uint8Array);
+ *
+ * // Create from hex string
+ * const checksum3 = Checksum.fromHex('a1b2c3...');
+ *
+ * // Compare checksums
+ * if (checksum1.equals(checksum2)) {
+ *   console.log('Checksums match');
+ * }
+ *
+ * // Convert to different formats
+ * const buffer = checksum1.toBuffer();
+ * const uint8Array = checksum1.toUint8Array();
+ * const hex = checksum1.toHex();
+ * ```
+ *
+ * @see Requirements 1.1, 1.2, 1.3, 1.4, 1.5
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checksum = exports.ChecksumErrorType = void 0;
+exports.isChecksum = isChecksum;
+const constants_1 = require("../constants");
+const checksumError_1 = require("../errors/checksumError");
+// Re-export ChecksumErrorType for backward compatibility
+var checksumError_2 = require("../errors/checksumError");
+Object.defineProperty(exports, "ChecksumErrorType", { enumerable: true, get: function () { return checksumError_2.ChecksumErrorType; } });
+/**
+ * Unified checksum class that handles both Buffer and Uint8Array representations.
+ *
+ * The class uses Uint8Array internally for efficiency and provides conversion
+ * methods to Buffer and hex string formats.
+ *
+ * @remarks
+ * - The constructor is private; use factory methods to create instances
+ * - All checksums must be exactly SHA3_BUFFER_LENGTH bytes (64 bytes for SHA3-512)
+ * - The equals() method performs byte-by-byte comparison
+ * - toString() is an alias for toHex()
+ *
+ * @see Requirements 1.1, 1.2, 1.3, 1.4, 1.5
+ */
+class Checksum {
+    /**
+     * Private constructor to enforce factory pattern.
+     *
+     * @param data - The checksum data as Uint8Array
+     * @throws ChecksumError if data length is not equal to SHA3_BUFFER_LENGTH
+     *
+     * @internal
+     */
+    constructor(data) {
+        if (data.length !== constants_1.CHECKSUM.SHA3_BUFFER_LENGTH) {
+            throw new checksumError_1.ChecksumError(checksumError_1.ChecksumErrorType.InvalidLength, `Checksum must be ${constants_1.CHECKSUM.SHA3_BUFFER_LENGTH} bytes, got ${data.length} bytes`, {
+                actualLength: data.length,
+                expectedLength: constants_1.CHECKSUM.SHA3_BUFFER_LENGTH,
+            });
+        }
+        // Create a copy to ensure immutability
+        this.data = new Uint8Array(data);
+    }
+    /**
+     * Create a Checksum from a Buffer.
+     *
+     * @param buffer - The buffer containing checksum data
+     * @returns A new Checksum instance
+     * @throws ChecksumError if buffer length is not equal to SHA3_BUFFER_LENGTH
+     *
+     * @example
+     * ```typescript
+     * const buffer = Buffer.from('a'.repeat(128), 'hex'); // 64 bytes
+     * const checksum = Checksum.fromBuffer(buffer);
+     * ```
+     *
+     * @see Requirement 1.2
+     */
+    static fromBuffer(buffer) {
+        return new Checksum(new Uint8Array(buffer));
+    }
+    /**
+     * Create a Checksum from a Uint8Array.
+     *
+     * @param array - The Uint8Array containing checksum data
+     * @returns A new Checksum instance
+     * @throws ChecksumError if array length is not equal to SHA3_BUFFER_LENGTH
+     *
+     * @example
+     * ```typescript
+     * const array = new Uint8Array(64);
+     * crypto.getRandomValues(array);
+     * const checksum = Checksum.fromUint8Array(array);
+     * ```
+     *
+     * @see Requirement 1.2
+     */
+    static fromUint8Array(array) {
+        return new Checksum(array);
+    }
+    /**
+     * Create a Checksum from a hex string.
+     *
+     * @param hex - The hex string representation of the checksum
+     * @returns A new Checksum instance
+     * @throws ChecksumError if hex string is invalid or results in wrong length
+     *
+     * @example
+     * ```typescript
+     * const hex = 'a1b2c3d4...'; // 128 hex characters = 64 bytes
+     * const checksum = Checksum.fromHex(hex);
+     * ```
+     *
+     * @see Requirement 1.2
+     */
+    static fromHex(hex) {
+        // Validate hex string format
+        if (!/^[0-9a-fA-F]*$/.test(hex)) {
+            throw new checksumError_1.ChecksumError(checksumError_1.ChecksumErrorType.InvalidHex, 'Invalid hex string: contains non-hexadecimal characters', { input: hex.substring(0, 20) + (hex.length > 20 ? '...' : '') });
+        }
+        // Check if hex string has correct length (2 hex chars per byte)
+        const expectedHexLength = constants_1.CHECKSUM.SHA3_BUFFER_LENGTH * 2;
+        if (hex.length !== expectedHexLength) {
+            throw new checksumError_1.ChecksumError(checksumError_1.ChecksumErrorType.InvalidLength, `Invalid hex string length: expected ${expectedHexLength} characters, got ${hex.length}`, { actualLength: hex.length, expectedLength: expectedHexLength });
+        }
+        const buffer = Buffer.from(hex, 'hex');
+        return Checksum.fromBuffer(buffer);
+    }
+    /**
+     * Compare this checksum with another for equality.
+     *
+     * Performs a byte-by-byte comparison of the underlying data.
+     *
+     * @param other - The other Checksum to compare with
+     * @returns true if the checksums are equal, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const checksum1 = Checksum.fromBuffer(buffer1);
+     * const checksum2 = Checksum.fromBuffer(buffer2);
+     * if (checksum1.equals(checksum2)) {
+     *   console.log('Checksums match');
+     * }
+     * ```
+     *
+     * @see Requirement 1.3
+     */
+    equals(other) {
+        if (this.data.length !== other.data.length) {
+            return false;
+        }
+        for (let i = 0; i < this.data.length; i++) {
+            if (this.data[i] !== other.data[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Convert the checksum to a Buffer.
+     *
+     * @returns A new Buffer containing the checksum data
+     *
+     * @example
+     * ```typescript
+     * const checksum = Checksum.fromHex(hexString);
+     * const buffer = checksum.toBuffer();
+     * ```
+     *
+     * @see Requirement 1.5
+     */
+    toBuffer() {
+        return Buffer.from(this.data);
+    }
+    /**
+     * Convert the checksum to a Uint8Array.
+     *
+     * @returns A new Uint8Array containing the checksum data
+     *
+     * @remarks
+     * Returns a copy of the internal data to maintain immutability.
+     *
+     * @example
+     * ```typescript
+     * const checksum = Checksum.fromBuffer(buffer);
+     * const array = checksum.toUint8Array();
+     * ```
+     *
+     * @see Requirement 1.5
+     */
+    toUint8Array() {
+        return new Uint8Array(this.data);
+    }
+    /**
+     * Convert the checksum to a lowercase hex string.
+     *
+     * @returns The checksum as a lowercase hex string
+     *
+     * @example
+     * ```typescript
+     * const checksum = Checksum.fromBuffer(buffer);
+     * const hex = checksum.toHex(); // 'a1b2c3d4...'
+     * ```
+     *
+     * @see Requirement 1.4
+     */
+    toHex() {
+        return this.toBuffer().toString('hex');
+    }
+    /**
+     * Convert the checksum to a string representation.
+     *
+     * This is an alias for toHex() for consistent behavior.
+     *
+     * @returns The checksum as a lowercase hex string
+     *
+     * @example
+     * ```typescript
+     * const checksum = Checksum.fromBuffer(buffer);
+     * console.log(`Checksum: ${checksum}`); // Uses toString() implicitly
+     * ```
+     *
+     * @see Requirement 1.4
+     */
+    toString() {
+        return this.toHex();
+    }
+    /**
+     * Get the length of the checksum in bytes.
+     *
+     * @returns The length of the checksum data in bytes
+     */
+    get length() {
+        return this.data.length;
+    }
+}
+exports.Checksum = Checksum;
+/**
+ * Type guard to check if a value is a Checksum instance.
+ *
+ * @param value - The value to check
+ * @returns true if the value is a Checksum instance
+ *
+ * @example
+ * ```typescript
+ * if (isChecksum(value)) {
+ *   // value is narrowed to Checksum type
+ *   console.log(value.toHex());
+ * }
+ * ```
+ *
+ * @see Requirement 14.1
+ */
+function isChecksum(value) {
+    return value instanceof Checksum;
+}
+//# sourceMappingURL=checksum.js.map

package/src/lib/types/checksum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksum.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/types/checksum.ts"],"names":[],"mappings":"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"}

package/src/lib/types/enumTranslation.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Enum Translation Types and Utilities
+ *
+ * Provides type-safe translation support for enumeration values.
+ *
+ * @module types/enumTranslation
+ */
+import { LanguageCodes } from '@digitaldefiance/i18n-lib';
+/**
+ * Type representing the language code values from the i18n-lib
+ */
+export type LanguageCodeValue = (typeof LanguageCodes)[keyof typeof LanguageCodes];
+/**
+ * Type representing translations for a specific enum type.
+ * Maps language codes to a record of enum values to their translated strings.
+ *
+ * @template T - The enum type being translated
+ *
+ * @example
+ * ```typescript
+ * type MyEnumTranslation = EnumLanguageTranslation<MyEnum>;
+ * const translations: MyEnumTranslation = {
+ *   'en-US': {
+ *     [MyEnum.Value1]: 'Value One',
+ *     [MyEnum.Value2]: 'Value Two',
+ *   },
+ * };
+ * ```
+ */
+export type EnumLanguageTranslation<T extends string | number> = {
+    [languageCode: string]: Record<T, string>;
+};
+/**
+ * Creates a type-safe translation object for an enum.
+ *
+ * This is a pass-through function that provides type checking
+ * for translation objects.
+ *
+ * @template T - The enum type being translated
+ * @param translations - The translation object mapping language codes to enum translations
+ * @returns The same translation object with proper typing
+ *
+ * @example
+ * ```typescript
+ * const translations = createTranslations<MyEnum>({
+ *   [LanguageCodes.EN_US]: {
+ *     [MyEnum.Value1]: 'Value One',
+ *     [MyEnum.Value2]: 'Value Two',
+ *   },
+ * });
+ * ```
+ */
+export declare function createTranslations<T extends string | number>(translations: EnumLanguageTranslation<T>): EnumLanguageTranslation<T>;
+//# sourceMappingURL=enumTranslation.d.ts.map

package/src/lib/types/enumTranslation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumTranslation.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/types/enumTranslation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAC3B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAC/D,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAC1D,YAAY,EAAE,uBAAuB,CAAC,CAAC,CAAC,GACvC,uBAAuB,CAAC,CAAC,CAAC,CAE5B"}

package/src/lib/types/enumTranslation.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Enum Translation Types and Utilities
+ *
+ * Provides type-safe translation support for enumeration values.
+ *
+ * @module types/enumTranslation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTranslations = createTranslations;
+/**
+ * Creates a type-safe translation object for an enum.
+ *
+ * This is a pass-through function that provides type checking
+ * for translation objects.
+ *
+ * @template T - The enum type being translated
+ * @param translations - The translation object mapping language codes to enum translations
+ * @returns The same translation object with proper typing
+ *
+ * @example
+ * ```typescript
+ * const translations = createTranslations<MyEnum>({
+ *   [LanguageCodes.EN_US]: {
+ *     [MyEnum.Value1]: 'Value One',
+ *     [MyEnum.Value2]: 'Value Two',
+ *   },
+ * });
+ * ```
+ */
+function createTranslations(translations) {
+    return translations;
+}
+//# sourceMappingURL=enumTranslation.js.map

package/src/lib/types/enumTranslation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumTranslation.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/types/enumTranslation.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAmDH,gDAIC;AAxBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,kBAAkB,CAChC,YAAwC;IAExC,OAAO,YAAY,CAAC;AACtB,CAAC"}

package/src/lib/types/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Types Module for BrightChain
+ *
+ * This module exports unified type classes and type guards for the BrightChain library.
+ *
+ * @module types
+ *
+ * @example
+ * ```typescript
+ * import { Checksum, isChecksum, ChecksumBuffer, ChecksumUint8Array } from 'brightchain-lib';
+ *
+ * // Create a checksum from different sources
+ * const checksum1 = Checksum.fromBuffer(buffer);
+ * const checksum2 = Checksum.fromUint8Array(uint8Array);
+ * const checksum3 = Checksum.fromHex(hexString);
+ *
+ * // Use type guard
+ * if (isChecksum(value)) {
+ *   console.log(value.toHex());
+ * }
+ * ```
+ */
+/**
+ * Checksum types and utilities.
+ *
+ * Exports:
+ * - Checksum: Unified checksum class
+ * - isChecksum: Type guard for Checksum instances
+ * - ChecksumBuffer: (deprecated) Legacy type alias
+ * - ChecksumUint8Array: (deprecated) Legacy type alias
+ * - ChecksumErrorType: Re-exported from errors for convenience
+ *
+ * @see {@link Checksum}
+ */
+export * from './checksum';
+/**
+ * Enum translation types and utilities.
+ *
+ * Exports:
+ * - EnumLanguageTranslation: Type for enum translations
+ * - createTranslations: Helper function for creating type-safe translations
+ *
+ * @see {@link EnumLanguageTranslation}
+ */
+export * from './enumTranslation';
+//# sourceMappingURL=index.d.ts.map

package/src/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/types/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;GAWG;AACH,cAAc,YAAY,CAAC;AAE3B;;;;;;;;GAQG;AACH,cAAc,mBAAmB,CAAC"}

package/src/lib/types/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Types Module for BrightChain
+ *
+ * This module exports unified type classes and type guards for the BrightChain library.
+ *
+ * @module types
+ *
+ * @example
+ * ```typescript
+ * import { Checksum, isChecksum, ChecksumBuffer, ChecksumUint8Array } from 'brightchain-lib';
+ *
+ * // Create a checksum from different sources
+ * const checksum1 = Checksum.fromBuffer(buffer);
+ * const checksum2 = Checksum.fromUint8Array(uint8Array);
+ * const checksum3 = Checksum.fromHex(hexString);
+ *
+ * // Use type guard
+ * if (isChecksum(value)) {
+ *   console.log(value.toHex());
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * Checksum types and utilities.
+ *
+ * Exports:
+ * - Checksum: Unified checksum class
+ * - isChecksum: Type guard for Checksum instances
+ * - ChecksumBuffer: (deprecated) Legacy type alias
+ * - ChecksumUint8Array: (deprecated) Legacy type alias
+ * - ChecksumErrorType: Re-exported from errors for convenience
+ *
+ * @see {@link Checksum}
+ */
+tslib_1.__exportStar(require("./checksum"), exports);
+/**
+ * Enum translation types and utilities.
+ *
+ * Exports:
+ * - EnumLanguageTranslation: Type for enum translations
+ * - createTranslations: Helper function for creating type-safe translations
+ *
+ * @see {@link EnumLanguageTranslation}
+ */
+tslib_1.__exportStar(require("./enumTranslation"), exports);
+//# sourceMappingURL=index.js.map

package/src/lib/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/types/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;AAEH;;;;;;;;;;;GAWG;AACH,qDAA2B;AAE3B;;;;;;;;GAQG;AACH,4DAAkC"}