@digitaldefiance/node-ecies-lib 4.10.6 → 4.10.8

package/README.md

@@ -2,13 +2,13 @@
 
 [![npm version](https://badge.fury.io/js/%40digitaldefiance%2Fnode-ecies-lib.svg)](https://www.npmjs.com/package/@digitaldefiance/node-ecies-lib)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Tests](https://img.shields.io/badge/tests-220%2B%20passing-brightgreen)](https://github.com/Digital-Defiance/ecies-lib)
+[![Tests](https://img.shields.io/badge/tests-1100%2B%20passing-brightgreen)](https://github.com/Digital-Defiance/ecies-lib)
 
 A Node.js-specific implementation of the Digital Defiance ECIES (Elliptic Curve Integrated Encryption Scheme) library, providing secure encryption, decryption, and key management capabilities using Node.js crypto primitives. This package is designed to be binary compatible with similarly numbered releases of the browser-based `@digitaldefiance/ecies-lib`, enabling seamless cross-platform cryptographic operations.
 
 Part of [Express Suite](https://github.com/Digital-Defiance/express-suite)
 
-> Current Version: v4.7.14
+> Current Version: v4.10.6
 
 This library implements a modern, enterprise-grade ECIES protocol (v4.0) featuring HKDF key derivation, AAD binding, and optimized multi-recipient encryption. It includes a pluggable ID provider system, memory-efficient streaming encryption, and comprehensive internationalization.
 
@@ -52,8 +52,9 @@ This library implements a modern, enterprise-grade ECIES protocol (v4.0) featuri
 
 A comprehensive voting system built on homomorphic encryption with 17 voting methods and 1100+ test cases:
 
-- **Fully Secure Methods**: Plurality, Approval, Weighted, Borda Count, Score, Yes/No, Supermajority
-- **Multi-Round Methods**: Ranked Choice (IRV), Two-Round, STAR, STV
+- **All 17 Methods Fully Implemented**: Plurality, Approval, Weighted, Borda Count, Score, Yes/No, Yes/No/Abstain, Supermajority, Ranked Choice (IRV), Two-Round, STAR, STV, Quadratic, Consensus, Consent-Based
+- **Node.js Optimized**: Uses Buffer instead of Uint8Array for better Node.js performance
+- **Extended PlatformID**: Supports Buffer and mongoose ObjectId in addition to base types
 - **Core Security Features**:
   - Homomorphic encryption (Paillier cryptosystem) - votes remain encrypted until tally
   - Verifiable receipts with ECDSA signatures
@@ -63,6 +64,7 @@ A comprehensive voting system built on homomorphic encryption with 17 voting met
   - Role separation (poll aggregator cannot decrypt votes)
   - Double-vote prevention
 - **Government Requirements (EARS)**: Audit Log, Bulletin Board, Event Logger
+- **Cross-Platform Compatible**: 100% binary compatible with browser implementation
 
 See [Voting System Documentation](src/lib/voting/README.md) for complete details.
 
@@ -161,7 +163,89 @@ const decrypted = ecies.decryptSimpleOrSingleWithHeader(false, privateKey, encry
 console.log(decrypted.toString()); // "Hello, Secure World!"
 ```
 
-### 2. Using Custom ID Providers (e.g., GUID)
+### 2. Strong Typing with ID Providers (New in v4.10.7)
+
+The Node.js library now includes a comprehensive strong typing system for ID providers, eliminating the need for manual type casting and providing compile-time type safety.
+
+#### The Problem (Before v4.10.7)
+
+```typescript
+const Constants = getNodeRuntimeConfiguration();
+const id = Constants.idProvider.generate(); // Returns Uint8Array (no strong typing)
+const obj = Constants.idProvider.fromBytes(bytes); // Returns unknown (requires casting)
+```
+
+#### The Solution (v4.10.7+)
+
+**Enhanced Provider (Drop-in Replacement):**
+```typescript
+import { getEnhancedNodeIdProvider } from '@digitaldefiance/node-ecies-lib';
+
+const provider = getEnhancedNodeIdProvider<ObjectId>();
+const id = provider.generateTyped(); // Returns ObjectId (strongly typed)
+const obj = provider.fromBytesTyped(bytes); // Returns ObjectId (no casting needed)
+
+// Original methods still work for backward compatibility
+const rawBytes = provider.generate(); // Returns Uint8Array
+```
+
+**Simple Typed Provider (Clean API):**
+```typescript
+import { getTypedNodeIdProvider } from '@digitaldefiance/node-ecies-lib';
+
+const provider = getTypedNodeIdProvider<ObjectId>();
+const id = provider.generateTyped(); // Returns ObjectId
+const bytes = provider.toBytesTyped(id); // Type-safe conversion
+const restored = provider.fromBytesTyped(bytes); // Type-safe restoration
+```
+
+**Complete Typed Configuration:**
+```typescript
+import { createNodeObjectIdConfiguration } from '@digitaldefiance/node-ecies-lib';
+
+const config = createNodeObjectIdConfiguration();
+const objectId = config.generateId(); // Returns ObjectId (strongly typed)
+const bytes = config.idToBytes(objectId); // Convert to bytes
+const restored = config.idFromBytes(bytes); // Convert back to ObjectId
+
+// Access full Node.js runtime configuration
+const constants = config.constants; // Complete IConstants with ObjectIdProvider
+```
+
+**Custom Provider Types:**
+```typescript
+import { 
+  createNodeTypedConfiguration,
+  GuidV4Provider,
+  UuidProvider 
+} from '@digitaldefiance/node-ecies-lib';
+
+// GUID configuration
+const guidConfig = createNodeTypedConfiguration<string>({
+  idProvider: new GuidV4Provider()
+});
+const guidId = guidConfig.generateId(); // Returns GUID object (strongly typed)
+
+// UUID configuration
+const uuidConfig = createNodeTypedConfiguration<string>({
+  idProvider: new UuidProvider()
+});
+const uuidId = uuidConfig.generateId(); // Returns UUID string (strongly typed)
+```
+
+**Integration with ECIESService:**
+```typescript
+import { ECIESService, createNodeObjectIdConfiguration } from '@digitaldefiance/node-ecies-lib';
+
+const config = createNodeObjectIdConfiguration();
+const service = new ECIESService(config.constants);
+
+// Service uses the configured typed provider
+console.log(service.idProvider.name); // "ObjectID"
+console.log(service.idProvider.byteLength); // 12
+```
+
+### 3. Using Custom ID Providers (e.g., GUID)
 
 ```typescript
 import { 
@@ -196,7 +280,7 @@ const ecies2 = new ECIESService({
 const ecies3 = new ECIESService();
 ```
 
-### 3. Streaming Encryption (Large Files)
+### 4. Streaming Encryption (Large Files)
 
 Encrypt gigabytes of data with minimal memory footprint (<10MB).
 
@@ -221,7 +305,71 @@ async function processFile(filePath: string, publicKey: Buffer) {
 }
 ```
 
-### 4. Member System
+### 5. Voting System (Node.js Optimized)
+
+The Node.js voting system extends the browser implementation with Buffer support and mongoose integration:
+
+```typescript
+import { Member, MemberType } from '@digitaldefiance/node-ecies-lib';
+import { EmailString } from '@digitaldefiance/ecies-lib';
+import { 
+  PollFactory, 
+  VoteEncoder, 
+  PollTallier, 
+  VotingMethod 
+} from '@digitaldefiance/node-ecies-lib';
+
+const ecies = new ECIESService();
+
+// Create authority with voting keys
+const { member: authority, mnemonic } = Member.newMember(
+  ecies,
+  MemberType.System,
+  'Election Authority',
+  new EmailString('authority@example.com')
+);
+await authority.deriveVotingKeys();
+
+// Create poll (returns Node.js Poll with Buffer support)
+const poll = PollFactory.createPlurality(
+  ['Alice', 'Bob', 'Charlie'],
+  authority
+);
+
+// Create voter and cast vote
+const { member: voter } = Member.newMember(
+  ecies,
+  MemberType.User,
+  'Voter',
+  new EmailString('voter@example.com')
+);
+await voter.deriveVotingKeys();
+
+// Vote encoding uses Buffer internally
+const encoder = new VoteEncoder(authority.votingPublicKey!);
+const vote = encoder.encodePlurality(0, 3); // Vote for Alice
+const receipt = poll.vote(voter, vote);
+
+// Close and tally
+poll.close();
+const tallier = new PollTallier(
+  authority,
+  authority.votingPrivateKey!,
+  authority.votingPublicKey!
+);
+const results = tallier.tally(poll);
+
+console.log('Winner:', results.choices[results.winner!]);
+console.log('Tallies:', results.tallies);
+```
+
+**Node.js Voting Features:**
+- **All 17 Methods**: Complete implementation of all voting methods
+- **Buffer Optimization**: Uses Node.js Buffer instead of Uint8Array for better performance
+- **Mongoose Integration**: Extended PlatformID supports `Types.ObjectId`
+- **Cross-Platform**: 100% binary compatible with browser voting system
+- **File Persistence**: Can save/load encrypted votes to/from disk
+- **Stream Processing**: Handle large voter datasets using Node.js streams
 
 The `Member` class provides a high-level user abstraction that integrates keys, IDs, and encryption.
 
@@ -245,7 +393,7 @@ console.log(member.id); // Buffer (size depends on provider)
 const encrypted = member.encryptData('My Secrets');
 ```
 
-## API Reference
+### 6. Member System
 
 ### Core Services
 
@@ -274,17 +422,22 @@ const encrypted = member.encryptData('My Secrets');
 
 ### Voting System
 
-- **`Poll`**: Core poll with vote aggregation and receipt issuance.
+- **`Poll`**: Core poll with vote aggregation and receipt issuance (generic over PlatformID, defaults to Buffer).
 - **`VotingPoll`**: High-level voting with encrypted receipts.
-- **`PollTallier`**: Decrypts and tallies votes (holds private key).
-- **`VoteEncoder`**: Encrypts votes using Paillier homomorphic encryption.
-- **`PollFactory`**: Convenient poll creation with method-specific configurations.
+- **`PollTallier`**: Decrypts and tallies votes (holds private key, generic over PlatformID).
+- **`VoteEncoder`**: Encrypts votes using Paillier homomorphic encryption (extends browser VoteEncoder with Buffer specialization).
+- **`PollFactory`**: Convenient poll creation with method-specific configurations (extends browser PollFactory).
 - **`VotingSecurityValidator`**: Security level validation and enforcement.
 - **`ImmutableAuditLog`**: Hash-chained audit trail for compliance.
 - **`PublicBulletinBoard`**: Append-only vote publication with Merkle tree.
 - **`PollEventLogger`**: Event tracking with microsecond timestamps.
 - **`VotingMethod`**: Enum with all 17 voting methods.
 - **`SecurityLevel`**: Enum for security classifications (FullyHomomorphic, MultiRound, Insecure).
+- **`EncryptedVote<TID extends PlatformID>`**: Encrypted vote structure with generic ID support (defaults to Buffer).
+- **`PollResults<TID extends PlatformID>`**: Tally results with winner(s) and generic ID support (defaults to Buffer).
+- **`VoteReceipt`**: Cryptographic vote receipt with signature verification.
+
+## API Reference
 
 ## Development
 
@@ -302,12 +455,13 @@ yarn format         # Fix all (prettier + lint)
 
 ### Testing Approach
 
-The node-ecies-lib package uses comprehensive testing with 220+ tests covering all Node.js-specific cryptographic operations and binary compatibility with the browser-based ecies-lib.
+The node-ecies-lib package uses comprehensive testing with 1100+ tests covering all Node.js-specific cryptographic operations, complete voting system functionality, and binary compatibility with the browser-based ecies-lib.
 
 **Test Framework**: Jest with TypeScript support  
 **Property-Based Testing**: fast-check for cryptographic properties  
 **Coverage Target**: 90%+ for all cryptographic operations  
-**Binary Compatibility**: Verified with @digitaldefiance/ecies-lib
+**Binary Compatibility**: Verified with @digitaldefiance/ecies-lib  
+**Voting System**: Complete test coverage for all 17 voting methods
 
 ### Test Structure
 
@@ -317,7 +471,19 @@ tests/
   ├── integration/       # Integration tests for protocol flows
   ├── e2e/               # End-to-end encryption/decryption tests
   ├── compatibility/     # Cross-platform compatibility with ecies-lib
-  └── streaming/         # Streaming encryption tests
+  ├── streaming/         # Streaming encryption tests
+  └── voting/            # Voting system tests (Node.js specific)
+      ├── voting.spec.ts           # Core voting functionality
+      ├── voting-stress.spec.ts    # Stress tests with large datasets
+      ├── poll-core.spec.ts        # Poll core functionality
+      ├── poll-audit.spec.ts       # Audit log integration
+      ├── factory.spec.ts          # Poll factory methods
+      ├── encoder.spec.ts          # Vote encoding for all methods
+      ├── security.spec.ts         # Security validation
+      ├── audit.spec.ts            # Immutable audit log
+      ├── bulletin-board.spec.ts   # Public bulletin board
+      ├── event-logger.spec.ts     # Event logging system
+      └── cross-platform-encryption.pbt.spec.ts # Cross-platform voting compatibility
 ```
 
 ### Running Tests
@@ -487,6 +653,115 @@ describe('Integration with suite-core-lib', () => {
 
 ## ChangeLog
 
+### v4.10.7 - Strong Typing for ID Providers
+
+**Major Features:**
+- **Strong Typing System**: Added comprehensive strong typing for Node.js ID provider operations
+  - `getEnhancedNodeIdProvider<T>()`: Drop-in replacement with both original and typed methods
+  - `getTypedNodeIdProvider<T>()`: Simple typed provider with minimal API surface
+  - `createNodeTypedConfiguration<T>()`: Complete typed configuration wrapper
+  - `createNodeObjectIdConfiguration()`: Pre-configured ObjectId setup
+- **Type Safety Benefits**: Eliminates manual casting and provides compile-time type safety
+  - `generateTyped()`: Returns strongly-typed IDs (ObjectId, string, etc.)
+  - `fromBytesTyped()`: Type-safe byte conversion without casting
+  - `toBytesTyped()`, `serializeTyped()`, `deserializeTyped()`: Complete typed API
+- **Backward Compatibility**: Enhanced providers include original methods for seamless migration
+- **Integration Ready**: Works seamlessly with ECIESService and Member system
+
+**Usage Examples:**
+```typescript
+// Enhanced provider (drop-in replacement)
+const provider = getEnhancedNodeIdProvider<ObjectId>();
+const id = provider.generateTyped(); // Returns ObjectId (strongly typed)
+
+// Complete typed configuration
+const config = createNodeObjectIdConfiguration();
+const objectId = config.generateId(); // Returns ObjectId
+const bytes = config.idToBytes(objectId); // Type-safe conversion
+
+// Custom provider types
+const guidConfig = createNodeTypedConfiguration<string>({
+  idProvider: new GuidV4Provider()
+});
+const guidId = guidConfig.generateId(); // Returns GUID object (strongly typed)
+```
+
+**Breaking Changes:** None - fully backward compatible
+
+**Files Added:**
+- `src/typed-configuration.ts` - Main implementation
+- `src/typed-configuration.spec.ts` - Comprehensive tests
+- `src/examples/typed-configuration-usage.ts` - Usage examples
+
+### v4.10.6 - Voting System & PlatformID Integration
+
+**Major Features:**
+- **Complete Cryptographic Voting System**: Added comprehensive voting system with 17+ methods
+  - All methods fully implemented: Plurality, Approval, Weighted, Borda, Score, Yes/No, Yes/No/Abstain, Supermajority, Ranked Choice (IRV), Two-Round, STAR, STV, Quadratic, Consensus, Consent-Based
+  - Node.js optimized with Buffer instead of Uint8Array for better performance
+  - Government-grade security: Immutable audit logs, public bulletin board, event logging
+  - Role separation: Poll aggregators cannot decrypt votes until closure
+- **Extended PlatformID Type System**: Enhanced ID provider system with Node.js-specific extensions
+  - `PlatformID = BasePlatformID | Buffer | Types.ObjectId`
+  - Seamless integration with mongoose and MongoDB applications
+  - Generic interfaces: `EncryptedVote<TID extends PlatformID>`, `PollResults<TID extends PlatformID>`
+- **Enhanced Member System**: Added voting key derivation and management
+  - `deriveVotingKeys()`: Generate Paillier keypairs for homomorphic encryption
+  - `votingPublicKey` and `votingPrivateKey` properties for voting operations
+  - Full integration with voting system interfaces
+
+**Node.js Voting System Components:**
+- `Poll`: Core vote aggregation with receipt generation (extends browser Poll with Buffer support)
+- `VotingPoll`: High-level voting with encrypted receipts
+- `PollTallier`: Secure vote decryption and tallying (separate entity)
+- `VoteEncoder`: Paillier homomorphic encryption for all voting methods (extends browser VoteEncoder)
+- `PollFactory`: Convenient poll creation with method-specific configurations (extends browser PollFactory)
+- `VotingSecurityValidator`: Security level validation and enforcement
+- `ImmutableAuditLog`: Cryptographic hash chain for audit compliance
+- `PublicBulletinBoard`: Transparent vote publication with Merkle tree integrity
+- `PollEventLogger`: Comprehensive event tracking with microsecond timestamps
+
+**Breaking Changes:**
+- Voting interfaces now use generic `PlatformID` types with Buffer as default
+- Member interface extended with voting key properties
+- New voting system exports in main package
+
+**Compatibility:**
+- Fully backward compatible for existing ECIES operations
+- New voting system is opt-in and doesn't affect existing functionality
+- 100% binary compatible with `@digitaldefiance/ecies-lib` voting system
+- Cross-platform vote encryption/decryption verified
+
+### v4.8.2 - Voting System Foundation
+
+**Features:**
+- Initial voting system architecture
+- Core voting method implementations
+- Basic showcase application structure
+
+### v4.8.1 - Voting System Initialization
+
+**Features:**
+- Foundation for cryptographic voting system
+- Initial voting method definitions
+- Enhanced Member system for voting key management
+
+### v4.8.0 - Voting System Introduction
+
+**Major Features:**
+- **Initial Voting System**: Introduced cryptographic voting system architecture
+- **Voting Method Enumerations**: Defined all 17+ voting methods with security classifications
+- **Enhanced Member System**: Added voting key derivation capabilities
+- **Showcase Application**: Started development of interactive voting demos
+
+### v4.7.15 - Pre-Voting System Enhancements
+
+**Improvements:**
+- Enhanced core ECIES functionality
+- Improved ID provider system
+- Bug fixes and stability improvements
+- Updated showcase components
+
 ### v4.7.14
 
 **Bug Fix: idProvider Configuration Now Respected by Member.newMember()**
@@ -1143,3 +1418,32 @@ Special thanks to the architecture improvements that enabled this clean migratio
 ### Version 1.0.3
 
 - Initial release.
+
+## Summary
+
+The Node.js implementation of `@digitaldefiance/node-ecies-lib` provides a **complete, production-ready cryptographic library** with comprehensive voting system support:
+
+### ✅ Complete Implementation
+- **All 17 Voting Methods**: Every voting method from Plurality to Consent-Based is fully implemented and tested
+- **Node.js Optimized**: Uses Buffer instead of Uint8Array for optimal Node.js performance
+- **Extended PlatformID**: Supports Buffer and mongoose ObjectId for seamless database integration
+- **Cross-Platform**: 100% binary compatible with browser `@digitaldefiance/ecies-lib`
+
+### ✅ Government-Grade Security
+- **Homomorphic Encryption**: Paillier cryptosystem for privacy-preserving vote aggregation
+- **Immutable Audit Log**: Cryptographic hash chain for complete audit trail
+- **Public Bulletin Board**: Transparent, verifiable vote publication
+- **Event Logging**: Microsecond-precision event tracking
+- **Role Separation**: Poll aggregators cannot decrypt votes until closure
+
+### ✅ Production Ready
+- **1100+ Tests**: Comprehensive test coverage including all voting methods and cross-platform compatibility
+- **Stress Tested**: Handles 1000+ voters and complex elimination scenarios
+- **Attack Resistant**: Prevents double voting, vote manipulation, and unauthorized decryption
+- **Node.js Native**: Optimized for Node.js crypto module and Buffer operations
+
+The system is ready for production use in government elections, corporate governance, and any application requiring secure, verifiable voting with Node.js backend systems.
+
+## License
+
+MIT © Digital Defiance

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitaldefiance/node-ecies-lib",
-  "version": "4.10.6",
+  "version": "4.10.8",
   "description": "Digital Defiance Node ECIES Library",
   "homepage": "https://github.com/Digital-Defiance/node-ecies-lib",
   "repository": {
@@ -62,7 +62,7 @@
   "license": "MIT",
   "packageManager": "yarn@4.10.3",
   "dependencies": {
-    "@digitaldefiance/ecies-lib": "4.10.6",
+    "@digitaldefiance/ecies-lib": "4.10.8",
     "@digitaldefiance/express-suite-test-utils": "1.0.14",
     "@digitaldefiance/i18n-lib": "3.8.16",
     "@ethereumjs/wallet": "^10.0.0",

package/src/examples/typed-configuration-usage.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Usage examples for Node.js ECIES typed configuration system
+ *
+ * This file demonstrates how to use the strongly-typed ID provider system
+ * in Node.js applications for better type safety and developer experience.
+ *
+ * @version 4.10.7
+ * @since 4.10.7
+ */
+/**
+ * Example 1: Enhanced ID Provider (Drop-in Replacement)
+ *
+ * The enhanced provider includes both original and typed methods,
+ * making it a perfect drop-in replacement for existing code.
+ */
+declare function enhancedProviderExample(): void;
+/**
+ * Example 2: Simple Typed Provider (Minimal API)
+ *
+ * The typed provider only exposes strongly-typed methods,
+ * providing a clean API surface for new code.
+ */
+declare function typedProviderExample(): void;
+/**
+ * Example 3: Complete Typed Configuration
+ *
+ * The typed configuration provides access to the full Node.js runtime
+ * configuration plus convenient typed ID helpers.
+ */
+declare function typedConfigurationExample(): void;
+/**
+ * Example 4: Custom Provider Configuration
+ *
+ * Demonstrates how to use different ID providers with strong typing.
+ */
+declare function customProviderExample(): void;
+/**
+ * Example 5: Type Safety Demonstration
+ *
+ * Shows how the typed system prevents common type-related errors.
+ */
+declare function typeSafetyExample(): void;
+/**
+ * Example 6: Integration with ECIESService
+ *
+ * Shows how to use typed configurations with the ECIES service.
+ */
+declare function eciesIntegrationExample(): void;
+/**
+ * Run all examples
+ */
+declare function runAllExamples(): void;
+export { enhancedProviderExample, typedProviderExample, typedConfigurationExample, customProviderExample, typeSafetyExample, eciesIntegrationExample, runAllExamples, };
+//# sourceMappingURL=typed-configuration-usage.d.ts.map

package/src/examples/typed-configuration-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-configuration-usage.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-node-ecies-lib/src/examples/typed-configuration-usage.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH;;;;;GAKG;AACH,iBAAS,uBAAuB,SAkB/B;AAED;;;;;GAKG;AACH,iBAAS,oBAAoB,SAqB5B;AAED;;;;;GAKG;AACH,iBAAS,yBAAyB,SAkBjC;AAED;;;;GAIG;AACH,iBAAS,qBAAqB,SAqB7B;AAED;;;;GAIG;AACH,iBAAS,iBAAiB,SAwBzB;AAED;;;;GAIG;AACH,iBAAS,uBAAuB,SAmB/B;AAED;;GAEG;AACH,iBAAS,cAAc,SAsBtB;AAGD,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,yBAAyB,EACzB,qBAAqB,EACrB,iBAAiB,EACjB,uBAAuB,EACvB,cAAc,GACf,CAAC"}

package/src/examples/typed-configuration-usage.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * @fileoverview Usage examples for Node.js ECIES typed configuration system
+ *
+ * This file demonstrates how to use the strongly-typed ID provider system
+ * in Node.js applications for better type safety and developer experience.
+ *
+ * @version 4.10.7
+ * @since 4.10.7
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enhancedProviderExample = enhancedProviderExample;
+exports.typedProviderExample = typedProviderExample;
+exports.typedConfigurationExample = typedConfigurationExample;
+exports.customProviderExample = customProviderExample;
+exports.typeSafetyExample = typeSafetyExample;
+exports.eciesIntegrationExample = eciesIntegrationExample;
+exports.runAllExamples = runAllExamples;
+const ecies_lib_1 = require("@digitaldefiance/ecies-lib");
+const typed_configuration_1 = require("../typed-configuration");
+/**
+ * Example 1: Enhanced ID Provider (Drop-in Replacement)
+ *
+ * The enhanced provider includes both original and typed methods,
+ * making it a perfect drop-in replacement for existing code.
+ */
+function enhancedProviderExample() {
+    console.log('=== Enhanced Provider Example ===');
+    // Get enhanced provider with strong typing
+    const provider = (0, typed_configuration_1.getEnhancedNodeIdProvider)();
+    // Original methods still work (backward compatibility)
+    const rawBytes = provider.generate(); // Returns Uint8Array
+    // const _unknownObj = provider.fromBytes(rawBytes); // Returns unknown (requires casting)
+    // New typed methods provide type safety
+    const typedId = provider.generateTyped(); // Returns ObjectId (strongly typed)
+    const typedFromBytes = provider.fromBytesTyped(rawBytes); // Returns ObjectId (no casting needed)
+    console.log('Provider name:', provider.name);
+    console.log('Byte length:', provider.byteLength);
+    console.log('Typed ID generated:', typedId);
+    console.log('Round-trip successful:', typedFromBytes);
+}
+/**
+ * Example 2: Simple Typed Provider (Minimal API)
+ *
+ * The typed provider only exposes strongly-typed methods,
+ * providing a clean API surface for new code.
+ */
+function typedProviderExample() {
+    console.log('=== Typed Provider Example ===');
+    // Get simple typed provider
+    const provider = (0, typed_configuration_1.getTypedNodeIdProvider)();
+    // Only typed methods available
+    const typedId = provider.generateTyped(); // Returns ObjectId
+    const bytes = provider.toBytesTyped(typedId); // Convert to bytes
+    const restored = provider.fromBytesTyped(bytes); // Convert back to ObjectId
+    // Serialization methods
+    const serialized = provider.serializeTyped(typedId);
+    const deserialized = provider.deserializeTyped(serialized);
+    console.log('Provider name:', provider.name);
+    console.log('Byte length:', provider.byteLength);
+    console.log('Original ID:', typedId);
+    console.log('Restored ID:', restored);
+    console.log('Serialized:', serialized);
+    console.log('Deserialized:', deserialized);
+}
+/**
+ * Example 3: Complete Typed Configuration
+ *
+ * The typed configuration provides access to the full Node.js runtime
+ * configuration plus convenient typed ID helpers.
+ */
+function typedConfigurationExample() {
+    console.log('=== Typed Configuration Example ===');
+    // Create ObjectId configuration
+    const config = (0, typed_configuration_1.createNodeObjectIdConfiguration)();
+    // Access full Node.js runtime configuration
+    console.log('PBKDF2 algorithm:', config.constants.PBKDF2.ALGORITHM);
+    console.log('Member ID length:', config.constants.MEMBER_ID_LENGTH);
+    // Use convenient typed methods
+    const objectId = config.generateId(); // Returns ObjectId
+    const bytes = config.idToBytes(objectId);
+    const restored = config.idFromBytes(bytes);
+    console.log('Generated ObjectId:', objectId);
+    console.log('Byte length:', bytes.length);
+    console.log('Restored ObjectId:', restored);
+}
+/**
+ * Example 4: Custom Provider Configuration
+ *
+ * Demonstrates how to use different ID providers with strong typing.
+ */
+function customProviderExample() {
+    console.log('=== Custom Provider Example ===');
+    // GUID configuration
+    const guidConfig = (0, typed_configuration_1.createNodeTypedConfiguration)({
+        idProvider: new ecies_lib_1.GuidV4Provider(),
+    });
+    // UUID configuration
+    const uuidConfig = (0, typed_configuration_1.createNodeTypedConfiguration)({
+        idProvider: new ecies_lib_1.UuidProvider(),
+    });
+    // Generate typed IDs
+    // const _guidId = guidConfig.generateId(); // Returns GUID object (strongly typed)
+    // const _uuidId = uuidConfig.generateId(); // Returns UUID string (strongly typed)
+    console.log('GUID provider name:', guidConfig.constants.idProvider.name);
+    console.log('GUID byte length:', guidConfig.constants.idProvider.byteLength);
+    console.log('UUID provider name:', uuidConfig.constants.idProvider.name);
+    console.log('UUID byte length:', uuidConfig.constants.idProvider.byteLength);
+}
+/**
+ * Example 5: Type Safety Demonstration
+ *
+ * Shows how the typed system prevents common type-related errors.
+ */
+function typeSafetyExample() {
+    console.log('=== Type Safety Example ===');
+    const objectIdConfig = (0, typed_configuration_1.createNodeObjectIdConfiguration)();
+    const guidConfig = (0, typed_configuration_1.createNodeTypedConfiguration)({
+        idProvider: new ecies_lib_1.GuidV4Provider(),
+    });
+    // Generate strongly-typed IDs
+    const objectId = objectIdConfig.generateId(); // ObjectId type
+    const guidId = guidConfig.generateId(); // GUID object type
+    // Type-safe operations (no casting needed)
+    const objectIdBytes = objectIdConfig.idToBytes(objectId);
+    const guidBytes = guidConfig.idToBytes(guidId);
+    // Restore with type safety
+    const restoredObjectId = objectIdConfig.idFromBytes(objectIdBytes);
+    const restoredGuid = guidConfig.idFromBytes(guidBytes);
+    console.log('ObjectId bytes length:', objectIdBytes.length);
+    console.log('GUID bytes length:', guidBytes.length);
+    console.log('ObjectId restored:', restoredObjectId);
+    console.log('GUID restored:', restoredGuid);
+}
+/**
+ * Example 6: Integration with ECIESService
+ *
+ * Shows how to use typed configurations with the ECIES service.
+ */
+function eciesIntegrationExample() {
+    console.log('=== ECIES Integration Example ===');
+    // Import ECIESService (commented out to avoid circular dependencies in examples)
+    // import { ECIESService } from '../services/ecies/service';
+    // Create typed configuration
+    const config = (0, typed_configuration_1.createNodeObjectIdConfiguration)();
+    // Use with ECIESService
+    // const service = new ECIESService(config.constants);
+    // The service will use the configured ID provider
+    // console.log('Service ID provider:', service.idProvider.name);
+    // console.log('Service ID byte length:', service.idProvider.byteLength);
+    console.log('Configuration ready for ECIESService');
+    console.log('ID provider:', config.constants.idProvider.name);
+    console.log('Byte length:', config.constants.idProvider.byteLength);
+}
+/**
+ * Run all examples
+ */
+function runAllExamples() {
+    console.log('Node.js ECIES Typed Configuration Examples\n');
+    enhancedProviderExample();
+    console.log();
+    typedProviderExample();
+    console.log();
+    typedConfigurationExample();
+    console.log();
+    customProviderExample();
+    console.log();
+    typeSafetyExample();
+    console.log();
+    eciesIntegrationExample();
+    console.log();
+    console.log('All examples completed successfully!');
+}
+// Run examples if this file is executed directly
+if (require.main === module) {
+    runAllExamples();
+}
+//# sourceMappingURL=typed-configuration-usage.js.map