shogun-core 5.2.0 → 5.2.2

package/dist/types/crypto/pgp.d.ts

@@ -0,0 +1,95 @@
+/**
+ * PGP/OpenPGP Implementation
+ * Simple and immediate PGP functionality using openpgp library
+ * Provides encryption, decryption, signing, and key management
+ */
+export interface PGPKeyPair {
+    publicKey: string;
+    privateKey: string;
+    keyId: string;
+    fingerprint: string;
+    created: Date;
+}
+export interface PGPEncryptedMessage {
+    message: string;
+    signature?: string;
+    encrypted: boolean;
+    signed: boolean;
+}
+export interface PGPSignature {
+    message: string;
+    signature: string;
+    valid: boolean;
+    keyId?: string;
+}
+export declare class PGPManager {
+    private openpgp;
+    private initialized;
+    constructor();
+    /**
+     * Initialize PGP manager with openpgp library
+     */
+    initialize(): Promise<void>;
+    /**
+     * Generate a new PGP key pair
+     */
+    generateKeyPair(name: string, email: string, passphrase?: string): Promise<PGPKeyPair>;
+    /**
+     * Encrypt a message with public key
+     */
+    encryptMessage(message: string, publicKeyArmored: string, privateKeyArmored?: string, passphrase?: string): Promise<PGPEncryptedMessage>;
+    /**
+     * Decrypt a message with private key
+     */
+    decryptMessage(encryptedMessage: string, privateKeyArmored: string, passphrase?: string): Promise<string>;
+    /**
+     * Sign a message with private key
+     */
+    signMessage(message: string, privateKeyArmored: string, passphrase?: string): Promise<PGPSignature>;
+    /**
+     * Verify a message signature
+     */
+    verifySignature(message: string, signature: string, publicKeyArmored: string): Promise<PGPSignature>;
+    /**
+     * Get key information from armored key
+     */
+    getKeyInfo(keyArmored: string): Promise<any>;
+    /**
+     * Export key in different formats
+     */
+    exportKey(keyArmored: string, format?: "armored" | "binary"): Promise<string | Uint8Array>;
+    /**
+     * Import key from different formats
+     */
+    importKey(keyData: string | Uint8Array, format?: "armored" | "binary"): Promise<string>;
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+    /**
+     * Ensure the manager is initialized
+     */
+    private ensureInitialized;
+}
+export declare const createPGPManager: () => Promise<PGPManager>;
+export declare const generatePGPKeyPair: (name: string, email: string, passphrase?: string) => Promise<PGPKeyPair>;
+export declare const encryptPGPMessage: (message: string, publicKey: string, privateKey?: string, passphrase?: string) => Promise<PGPEncryptedMessage>;
+export declare const decryptPGPMessage: (encryptedMessage: string, privateKey: string, passphrase?: string) => Promise<string>;
+export declare const signPGPMessage: (message: string, privateKey: string, passphrase?: string) => Promise<PGPSignature>;
+export declare const verifyPGPSignature: (message: string, signature: string, publicKey: string) => Promise<PGPSignature>;
+export declare const demonstratePGP: () => Promise<{
+    success: boolean;
+    messageDecrypted: boolean;
+    signatureValid: boolean;
+    aliceKeyInfo: any;
+    bobKeyInfo: any;
+    demonstration: {
+        keyGeneration: boolean;
+        encryption: boolean;
+        decryption: boolean;
+        signing: boolean;
+        verification: boolean;
+        keyManagement: boolean;
+    };
+}>;
+export default PGPManager;

package/dist/types/crypto/random-generation.d.ts

@@ -0,0 +1,35 @@
+export declare const generateRandomString: (length?: number, additionalSalt?: string) => string;
+export declare const randomBytes: (length: number) => Uint8Array;
+export declare const randomInt: (min: number, max: number) => number;
+export declare const randomFloat: () => number;
+export declare const randomBool: () => boolean;
+export declare const randomUUID: () => string;
+export declare class DeterministicRandom {
+    private seed;
+    constructor(seed: string | number);
+    private hashString;
+    private lcg;
+    integer(min?: number, max?: number): number;
+    floating(min?: number, max?: number, fixed?: number): number;
+    bool(): boolean;
+    string(length?: number, pool?: string): string;
+    guid(): string;
+    choice<T>(array: T[]): T;
+    shuffle<T>(array: T[]): T[];
+    color(): string;
+    date(start: Date, end: Date): Date;
+}
+export declare const createDeterministicRandom: (seed: string | number) => DeterministicRandom;
+export declare const chance: (seed: string | number) => DeterministicRandom;
+export declare const randomChoice: <T>(array: T[]) => T;
+export declare const randomShuffle: <T>(array: T[]) => T[];
+export declare const randomColor: () => string;
+export declare const randomPassword: (options?: {
+    length?: number;
+    includeUppercase?: boolean;
+    includeLowercase?: boolean;
+    includeNumbers?: boolean;
+    includeSymbols?: boolean;
+    excludeSimilar?: boolean;
+}) => string;
+export declare const randomSeedPhrase: (wordCount?: number) => string[];

package/dist/types/crypto/sframe.d.ts

@@ -0,0 +1,102 @@
+/**
+ * SFrame (Secure Frame) Manager
+ * End-to-end encryption for real-time media frames (audio/video)
+ * Designed for low overhead and high performance
+ *
+ * SFrame adds ~10 bytes per frame overhead
+ * Compatible with WebRTC Insertable Streams API
+ */
+export interface SFrameKey {
+    keyId: number;
+    key: CryptoKey;
+    salt: Uint8Array;
+}
+export interface SFrameEncryptedFrame {
+    frameCount: number;
+    keyId: number;
+    iv: Uint8Array;
+    ciphertext: Uint8Array;
+    authTag: Uint8Array;
+}
+export declare class SFrameManager {
+    private keys;
+    private currentKeyId;
+    private frameCounter;
+    private initialized;
+    constructor();
+    /**
+     * Initialize the SFrame manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Generate a new SFrame encryption key
+     */
+    generateKey(keyId: number): Promise<SFrameKey>;
+    /**
+     * Derive an SFrame key from MLS shared secret
+     * This allows SFrame to use keys derived from MLS for media encryption
+     * RFC 9605 Section 5.2: MLS-based key management
+     */
+    deriveKeyFromMLSSecret(mlsSecret: ArrayBuffer, keyId: number, context?: string): Promise<SFrameKey>;
+    /**
+     * Set the active encryption key
+     */
+    setActiveKey(keyId: number): void;
+    /**
+     * Encrypt a media frame using SFrame
+     */
+    encryptFrame(frameData: ArrayBuffer): Promise<Uint8Array>;
+    /**
+     * Decrypt a media frame using SFrame
+     */
+    decryptFrame(encryptedFrame: Uint8Array): Promise<ArrayBuffer>;
+    /**
+     * Encrypt transform function for Insertable Streams
+     * Use this with RTCRtpSender.createEncodedStreams()
+     */
+    createEncryptTransform(): TransformStream;
+    /**
+     * Decrypt transform function for Insertable Streams
+     * Use this with RTCRtpReceiver.createEncodedStreams()
+     */
+    createDecryptTransform(): TransformStream;
+    /**
+     * Rotate encryption keys
+     * RFC 9605: Frame counter should be reset on key rotation to prevent exhaustion
+     */
+    rotateKey(): Promise<number>;
+    /**
+     * Get current key ID
+     */
+    getCurrentKeyId(): number;
+    /**
+     * Get frame counter (for debugging)
+     */
+    getFrameCounter(): number;
+    /**
+     * Reset frame counter (use when rotating keys)
+     */
+    resetFrameCounter(): void;
+    /**
+     * Remove old keys to prevent memory bloat
+     */
+    cleanupOldKeys(keepLast?: number): void;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        keyCount: number;
+        currentKeyId: number;
+        frameCounter: number;
+        initialized: boolean;
+    };
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+    /**
+     * Ensure the manager is initialized
+     */
+    private ensureInitialized;
+}
+export default SFrameManager;

package/dist/types/crypto/signal-protocol.d.ts

@@ -0,0 +1,26 @@
+import { SignalUser, SignalPublicKeyBundle, X3DHExchangeResult } from "./types";
+export declare const generateSignalKeyPair: () => Promise<CryptoKeyPair>;
+export declare const generateSignalSigningKeyPair: () => Promise<CryptoKeyPair>;
+export declare const exportSignalPublicKey: (publicKey: CryptoKey) => Promise<ArrayBuffer>;
+export declare const importSignalPublicKey: (keyBytes: ArrayBuffer) => Promise<CryptoKey>;
+export declare const importSignalSigningPublicKey: (keyBytes: ArrayBuffer) => Promise<CryptoKey>;
+export declare const performSignalDH: (privateKey: CryptoKey, publicKey: CryptoKey) => Promise<ArrayBuffer>;
+export declare const signSignalData: (privateKey: CryptoKey, data: ArrayBuffer) => Promise<ArrayBuffer>;
+export declare const verifySignalSignature: (publicKey: CryptoKey, signature: ArrayBuffer, data: ArrayBuffer) => Promise<boolean>;
+export declare const deriveSignalKey: (inputKeyMaterial: ArrayBuffer, salt: ArrayBuffer, info: ArrayBuffer, length?: number) => Promise<CryptoKey>;
+export declare const concatSignalArrayBuffers: (...buffers: ArrayBuffer[]) => ArrayBuffer;
+export declare const bufferToSignalHex: (buffer: ArrayBuffer) => string;
+export declare const initializeSignalUser: (name: string) => Promise<SignalUser>;
+export declare const getSignalPublicKeyBundle: (user: SignalUser) => Promise<SignalPublicKeyBundle>;
+export declare const consumeSignalOneTimePrekey: (user: SignalUser) => CryptoKeyPair | undefined;
+export declare const performSignalX3DHKeyExchange: (alice: SignalUser, bobBundle: SignalPublicKeyBundle) => Promise<X3DHExchangeResult>;
+export declare const deriveSignalSharedSecret: (bob: SignalUser, aliceEphemeralPublic: ArrayBuffer, aliceIdentityPublic: ArrayBuffer, usedOneTimePrekey: boolean, oneTimePrekeyBytes?: ArrayBuffer | null) => Promise<ArrayBuffer>;
+export declare const demonstrateSignalProtocol: () => Promise<{
+    success: boolean;
+    aliceSecret: string;
+    bobSecret: string;
+    usedOneTimePrekey: boolean;
+    alice: SignalUser;
+    bob: SignalUser;
+    exchangeResult: X3DHExchangeResult;
+}>;

package/dist/types/crypto/symmetric.d.ts

@@ -0,0 +1,9 @@
+import { EncryptedData } from "./types";
+export declare const generateSymmetricKey: () => Promise<JsonWebKey>;
+export declare const deserializeSymmetricKey: (key: JsonWebKey | string) => Promise<CryptoKey>;
+export declare const encryptWithSymmetricKey: (message: string, key: CryptoKey) => Promise<EncryptedData>;
+export declare const decryptWithSymmetricKey: (encryptedData: EncryptedData, key: CryptoKey) => Promise<string>;
+export declare const deriveKeyFromPassword: (password: string, salt?: ArrayBuffer) => Promise<{
+    key: CryptoKey;
+    salt: ArrayBuffer;
+}>;

package/dist/types/crypto/types.d.ts

@@ -0,0 +1,144 @@
+export interface CryptoKeyPair {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+}
+export interface JWKKeyPair {
+    publicKey: JsonWebKey;
+    privateKey: JsonWebKey;
+}
+export interface SymmetricKey {
+    key: CryptoKey;
+    jwk: JsonWebKey;
+}
+export interface EncryptedData {
+    ciphertext: string;
+    iv: string;
+}
+export interface EncryptedFilePackage {
+    encryptedData: string;
+    iv: string;
+    salt: string;
+    fileName: string;
+    timestamp: string;
+    originalSize: number;
+    mimeType?: string;
+    fileSize?: number;
+}
+export interface DecryptedFileResult {
+    data: ArrayBuffer;
+    fileName: string;
+    originalSize: number;
+    decryptedSize: number;
+    blob?: Blob;
+    mimeType?: string;
+    textContent?: string;
+    isTextFile?: boolean;
+    metadata?: any;
+}
+export interface SignalUser {
+    name: string;
+    identityKeyPair: CryptoKeyPair;
+    identitySigningKeyPair: CryptoKeyPair;
+    signedPrekeyPair: CryptoKeyPair;
+    signedPrekeySignature: ArrayBuffer;
+    oneTimePrekeyPairs: CryptoKeyPair[];
+}
+export interface SignalPublicKeyBundle {
+    identityKey: ArrayBuffer;
+    identitySigningKey: ArrayBuffer;
+    signedPrekey: ArrayBuffer;
+    signedPrekeySignature: ArrayBuffer;
+    oneTimePrekey: ArrayBuffer | null;
+}
+export interface X3DHExchangeResult {
+    masterSecret: ArrayBuffer;
+    aliceEphemeralPublic: ArrayBuffer;
+    usedOneTimePrekey: boolean;
+}
+export interface DoubleRatchetState {
+    rootKey: ArrayBuffer;
+    sendingChainKey: ArrayBuffer | null;
+    receivingChainKey: ArrayBuffer | null;
+    sendingDHKeyPair: CryptoKeyPair | null;
+    receivingDHPublicKey: CryptoKey | null;
+    sendingMessageNumber: number;
+    receivingMessageNumber: number;
+    previousChainLength: number;
+    skippedMessageKeys: Map<string, Uint8Array>;
+    isInitiator: boolean;
+    initialized: number;
+}
+export interface MessageEnvelope {
+    dhPublicKey: Uint8Array;
+    messageNumber: number;
+    previousChainLength: number;
+    ciphertext: Uint8Array;
+    iv: Uint8Array;
+    timestamp: number;
+}
+export interface CryptoConfig {
+    enabled: boolean;
+    algorithms: string[];
+    keySize?: number;
+    iterations?: number;
+}
+export interface CryptoMethods {
+    randomString: (additionalSalt?: string) => string;
+    sha256Hash: (input: any) => Promise<string>;
+    sha512Hash: (input: any) => Promise<string>;
+    sha3_512Hash: (input: any) => Promise<string>;
+    generateKeyPair: () => Promise<JWKKeyPair>;
+    deserializePublicKey: (key: JsonWebKey | string) => Promise<CryptoKey>;
+    deserializePrivateKey: (key: JsonWebKey | string) => Promise<CryptoKey>;
+    encrypt: (message: string, publicKey: CryptoKey) => Promise<string>;
+    decrypt: (encryptedMessage: string, privateKey: CryptoKey) => Promise<string>;
+    generateSymmetricKey: () => Promise<JsonWebKey>;
+    deserializeSymmetricKey: (key: JsonWebKey | string) => Promise<CryptoKey>;
+    encryptWithSymmetricKey: (message: string, key: CryptoKey) => Promise<EncryptedData>;
+    decryptWithSymmetricKey: (encryptedData: EncryptedData, key: CryptoKey) => Promise<string>;
+    deriveKeyFromPassword: (password: string, salt?: ArrayBuffer) => Promise<{
+        key: CryptoKey;
+        salt: ArrayBuffer;
+    }>;
+    encryptFile: (fileContent: string | ArrayBuffer | File, password: string, fileName?: string) => Promise<EncryptedFilePackage>;
+    decryptFile: (encryptedPackage: EncryptedFilePackage, password: string) => Promise<DecryptedFileResult>;
+    encryptTextFile: (textContent: string, password: string, fileName?: string) => Promise<EncryptedFilePackage>;
+    decryptTextFile: (encryptedPackage: EncryptedFilePackage, password: string) => Promise<DecryptedFileResult & {
+        textContent: string;
+    }>;
+    encryptBinaryFile: (file: File, password: string) => Promise<EncryptedFilePackage>;
+    decryptBinaryFile: (encryptedPackage: EncryptedFilePackage, password: string) => Promise<DecryptedFileResult & {
+        blob: Blob;
+    }>;
+    createSecureFileDownload: (data: ArrayBuffer | string | Blob, fileName: string, mimeType?: string) => void;
+    parseEncryptedFilePackage: (file: File) => Promise<{
+        isValid: boolean;
+        package?: EncryptedFilePackage;
+        metadata?: any;
+        error?: string;
+    }>;
+    decryptUploadedFile: (encryptedFilePackage: File, password: string) => Promise<DecryptedFileResult>;
+    generateSignalKeyPair: () => Promise<CryptoKeyPair>;
+    generateSignalSigningKeyPair: () => Promise<CryptoKeyPair>;
+    exportSignalPublicKey: (publicKey: CryptoKey) => Promise<ArrayBuffer>;
+    importSignalPublicKey: (keyBytes: ArrayBuffer) => Promise<CryptoKey>;
+    importSignalSigningPublicKey: (keyBytes: ArrayBuffer) => Promise<CryptoKey>;
+    performSignalDH: (privateKey: CryptoKey, publicKey: CryptoKey) => Promise<ArrayBuffer>;
+    signSignalData: (privateKey: CryptoKey, data: ArrayBuffer) => Promise<ArrayBuffer>;
+    verifySignalSignature: (publicKey: CryptoKey, signature: ArrayBuffer, data: ArrayBuffer) => Promise<boolean>;
+    deriveSignalKey: (inputKeyMaterial: ArrayBuffer, salt: ArrayBuffer, info: ArrayBuffer, length?: number) => Promise<CryptoKey>;
+    concatSignalArrayBuffers: (...buffers: ArrayBuffer[]) => ArrayBuffer;
+    bufferToSignalHex: (buffer: ArrayBuffer) => string;
+    initializeSignalUser: (name: string) => Promise<SignalUser>;
+    getSignalPublicKeyBundle: (user: SignalUser) => Promise<SignalPublicKeyBundle>;
+    consumeSignalOneTimePrekey: (user: SignalUser) => CryptoKeyPair | undefined;
+    performSignalX3DHKeyExchange: (alice: SignalUser, bobBundle: SignalPublicKeyBundle) => Promise<X3DHExchangeResult>;
+    deriveSignalSharedSecret: (bob: SignalUser, aliceEphemeralPublic: ArrayBuffer, aliceIdentityPublic: ArrayBuffer, usedOneTimePrekey: boolean, oneTimePrekeyBytes?: ArrayBuffer | null) => Promise<ArrayBuffer>;
+    demonstrateSignalProtocol: () => Promise<any>;
+    initializeDoubleRatchet: (sharedSecret: ArrayBuffer, isInitiator: boolean, remotePublicKey?: CryptoKey | null) => Promise<DoubleRatchetState>;
+    doubleRatchetEncrypt: (state: DoubleRatchetState, plaintext: string) => Promise<MessageEnvelope>;
+    doubleRatchetDecrypt: (state: DoubleRatchetState, messageEnvelope: MessageEnvelope) => Promise<string>;
+    serializeDoubleRatchetState: (state: DoubleRatchetState) => Promise<string>;
+    demonstrateDoubleRatchet: () => Promise<any>;
+    cleanupSkippedMessageKeys: (state: DoubleRatchetState, maxAge?: number) => void;
+}

package/dist/types/crypto/utils.d.ts

@@ -0,0 +1,22 @@
+export declare const validatePassword: (password: string) => boolean;
+export declare const generateSecurePassword: (length?: number) => string;
+export declare const measurePerformance: <T>(operation: () => Promise<T>, operationName: string) => Promise<{
+    result: T;
+    duration: number;
+}>;
+export declare const formatBytes: (bytes: number) => string;
+export declare const formatDuration: (ms: number) => string;
+export declare const createProgressCallback: (onProgress: (progress: number) => void, total: number) => {
+    increment: (amount?: number) => void;
+    setProgress: (progress: number) => void;
+    complete: () => void;
+};
+export declare const sanitizeFileName: (fileName: string) => string;
+export declare const getFileExtension: (fileName: string) => string;
+export declare const isTextFile: (fileName: string) => boolean;
+export declare const createFileHash: (file: File) => Promise<string>;
+export declare const compareFiles: (file1: File, file2: File) => Promise<boolean>;
+export declare const createBackup: (data: any) => string;
+export declare const restoreBackup: (backupString: string) => any;
+export declare const debounce: <T extends (...args: any[]) => any>(func: T, wait: number) => ((...args: Parameters<T>) => void);
+export declare const throttle: <T extends (...args: any[]) => any>(func: T, limit: number) => ((...args: Parameters<T>) => void);

package/dist/types/examples/auth-test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Authentication Test Script
+ *
+ * Tests signup and login functionality with username and password
+ * Includes timeout handling and error recovery testing
+ */
+declare function authTest(): Promise<void>;
+export { authTest };

package/dist/types/examples/crypto-identity-example.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Esempio di utilizzo del CryptoIdentityManager
+ * Mostra come le identità crypto vengono generate automaticamente dopo l'autenticazione SEA
+ */
+export declare function runCryptoIdentityExamples(): Promise<void>;

package/dist/types/examples/crypto-working-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/examples/double-ratchet-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/examples/mls-advanced-example.d.ts

@@ -0,0 +1,53 @@
+/**
+ * MLS Advanced Example
+ * Demonstrates advanced MLS features including:
+ * - Group creation and management
+ * - Member addition/removal
+ * - Key rotation and forward secrecy
+ * - Message encryption/decryption
+ * - Commit processing and synchronization
+ */
+declare class MLSGroupDemo {
+    private users;
+    private groupId;
+    private creator;
+    constructor(groupId: string, creatorId: string);
+    /**
+     * Add a user to the demo
+     */
+    addUser(userId: string): Promise<void>;
+    /**
+     * Create the group with the creator
+     */
+    createGroup(): Promise<void>;
+    /**
+     * Add members to the group
+     */
+    addMembers(memberIds: string[]): Promise<void>;
+    /**
+     * Send a message from one user to the group
+     */
+    sendMessage(senderId: string, message: string): Promise<void>;
+    /**
+     * Perform key rotation
+     */
+    rotateKeys(initiatorId: string): Promise<void>;
+    /**
+     * Remove members from the group
+     */
+    removeMembers(memberIds: string[]): Promise<void>;
+    /**
+     * Get group information
+     */
+    getGroupInfo(): Promise<any>;
+    /**
+     * Demonstrate codec functionality
+     */
+    demonstrateCodec(): Promise<void>;
+    /**
+     * Clean up resources
+     */
+    cleanup(): Promise<void>;
+}
+declare function demonstrateMLSAdvanced(): Promise<void>;
+export { MLSGroupDemo, demonstrateMLSAdvanced };

package/dist/types/examples/mls-sframe-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/examples/pgp-example.d.ts

@@ -0,0 +1,75 @@
+/**
+ * PGP Example - Simple and Immediate
+ * Demonstrates basic PGP functionality:
+ * - Key generation
+ * - Message encryption/decryption
+ * - Digital signing
+ * - Signature verification
+ */
+declare function simplePGPExample(): Promise<{
+    success: boolean;
+    messageDecrypted: boolean;
+    signatureValid: boolean;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    messageDecrypted?: undefined;
+    signatureValid?: undefined;
+}>;
+declare function advancedPGPExample(): Promise<{
+    success: boolean;
+    groupMessaging: boolean;
+    keyManagement: boolean;
+    exportImport: boolean;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    groupMessaging?: undefined;
+    keyManagement?: undefined;
+    exportImport?: undefined;
+}>;
+declare function runAllPGPExamples(): Promise<{
+    simple: {
+        success: boolean;
+        messageDecrypted: boolean;
+        signatureValid: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        messageDecrypted?: undefined;
+        signatureValid?: undefined;
+    };
+    advanced: {
+        success: boolean;
+        groupMessaging: boolean;
+        keyManagement: boolean;
+        exportImport: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        groupMessaging?: undefined;
+        keyManagement?: undefined;
+        exportImport?: undefined;
+    };
+    demo: {
+        success: boolean;
+        messageDecrypted: boolean;
+        signatureValid: boolean;
+        aliceKeyInfo: any;
+        bobKeyInfo: any;
+        demonstration: {
+            keyGeneration: boolean;
+            encryption: boolean;
+            decryption: boolean;
+            signing: boolean;
+            verification: boolean;
+            keyManagement: boolean;
+        };
+    };
+    allPassed: boolean;
+}>;
+export { simplePGPExample, advancedPGPExample, runAllPGPExamples };

package/dist/types/examples/quick-auth-test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Quick Auth Test Script
+ *
+ * Simple script to quickly test signup and login functionality
+ * Run this to verify that the authentication system is working
+ */
+declare function quickAuthTest(): Promise<void>;
+export { quickAuthTest };

package/dist/types/examples/random-generation-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/examples/signal-protocol-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/examples/simple-api-test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Example showing how to use the simplified ShogunCore API
+ *
+ * The API has been streamlined:
+ * - AutoQuickStart: Quick initialization helper
+ * - api.database: Direct access to DataBase for basic operations (get, put, set, remove, auth)
+ * - api helper methods: High-level helpers for profile, settings, collections, and array utilities
+ */
+declare function simpleAPITest(): Promise<void>;
+export { simpleAPITest };

package/dist/types/examples/simple-crypto-identity-example.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Esempio semplificato del CryptoIdentityManager
+ * Focus sulla funzionalità principale senza plugin opzionali
+ */
+declare function simpleCryptoIdentityExample(): Promise<void>;
+export { simpleCryptoIdentityExample };

package/dist/types/examples/timeout-test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Timeout Test Script
+ *
+ * Tests the timeout mechanism for signup and login operations
+ * This script specifically tests the fixes we implemented to prevent hanging
+ */
+declare function timeoutTest(): Promise<void>;
+export { timeoutTest };

package/dist/types/examples/zkproof-credentials-example.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ZK-Proof Verifiable Credentials Example
+ *
+ * This demonstrates how to use ZK-Proof for proving attributes
+ * about documents and identity without revealing sensitive data
+ */
+declare function ageVerificationExample(): Promise<void>;
+declare function citizenshipExample(): Promise<void>;
+declare function educationExample(): Promise<void>;
+declare function incomeExample(): Promise<void>;
+declare function customCredentialExample(): Promise<void>;
+export { ageVerificationExample, citizenshipExample, educationExample, incomeExample, customCredentialExample, };

package/dist/types/examples/zkproof-example.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Zero-Knowledge Proof Authentication Example
+ *
+ * This example demonstrates how to use the ZK-Proof plugin with Shogun Core
+ * for privacy-preserving authentication using Semaphore protocol.
+ */
+declare function basicExample(): Promise<void>;
+declare function deterministicExample(): Promise<void>;
+declare function proofExample(): Promise<void>;
+declare function multiDeviceExample(): Promise<void>;
+export { basicExample, deterministicExample, proofExample, multiDeviceExample };