@ufdevsllc/auth-me/index.d.ts

Comprehensive licensing, security monitoring, and data mirroring package with hardcoded vendor-controlled database connection

import { Schema } from 'mongoose';

/**
 * Deployment fingerprint object
 */
export interface DeploymentFingerprint {
    /** Unique machine identifier */
    machineId: string;
    /** Server hostname */
    hostname: string;
    /** Server IP address */
    ipAddress: string;
    /** Project name */
    projectName: string;
    /** Node.js version */
    nodeVersion: string;
    /** Fingerprint generation time */
    timestamp: Date;
    /** Consistent hash of fingerprint data */
    hash: string;
}

/**
 * System information object
 */
export interface SystemInfo {
    /** Operating system platform */
    platform: string;
    /** System architecture */
    arch: string;
    /** OS release version */
    release: string;
    /** Number of CPU cores */
    cpus: number;
    /** Total system memory */
    totalMemory: number;
    /** Free system memory */
    freeMemory: number;
    /** System uptime */
    uptime: number;
    /** Node.js version */
    nodeVersion: string;
    /** Process ID */
    processId: number;
    /** Process uptime */
    processUptime: number;
}

/**
 * Configuration object for SecureGuard initialization
 * Database connection and security settings are hardcoded by vendor
 */
export interface SecureGuardConfig {
    /** The license key for validation */
    licenseKey: string;
    /** Array of Mongoose schemas to mirror */
    schemas: Schema[];
    /** Expected environment binding hash (optional) */
    expectedEnvironmentBinding?: string;
    // Note: Database connection and security options are hardcoded by vendor
    // Clients cannot override: vendorEndpoint, security settings, or monitoring options
}

/**
 * Usage statistics object
 */
export interface UsageStats {
    /** License key */
    licenseKey: string;
    /** Total write operations */
    totalWrites: number;
    /** Writes per model */
    writesByModel: Record<string, number>;
    /** Last activity timestamp */
    lastActivity: Date;
    /** Number of deployments */
    deploymentCount: number;
}

/**
 * Usage limits object
 */
export interface UsageLimits {
    /** Maximum write operations */
    maxWrites?: number;
    /** Maximum users */
    maxUsers?: number;
    /** Maximum deployments */
    maxDeployments?: number;
}

/**
 * License object
 */
export interface License {
    /** License key */
    key: string;
    /** Customer identifier */
    customerId: string;
    /** Plan type */
    planType: 'basic' | 'premium' | 'enterprise';
    /** License expiration date */
    expirationDate: Date;
    /** Environment binding fingerprint */
    environmentFingerprint?: string;
    /** Usage limits for the license */
    usageLimits: UsageLimits;
    /** License status */
    status: 'active' | 'expired' | 'blacklisted' | 'suspended';
    /** License creation date */
    createdDate: Date;
    /** Last validation timestamp */
    lastValidation: Date;
    /** Number of violations detected */
    violationCount: number;
}

/**
 * License validation result
 */
export interface ValidationResult {
    /** Whether the license is valid */
    isValid: boolean;
    /** License data if valid */
    license: License | null;
    /** Reason for validation result */
    reason: string;
    /** Error code for invalid licenses */
    code: string;
}

/**
 * License validator class
 */
export declare class LicenseValidator {
    /**
     * Setup secure database connection
     * @param connectionString MongoDB connection string
     * @param options Connection options
     */
    setupSecureConnection(connectionString: string, options?: any): Promise<void>;

    /**
     * Validate a license key against the secure database
     * @param key License key to validate
     * @param fingerprint Environment fingerprint for binding validation
     * @param options Validation options
     */
    validateLicense(key: string, fingerprint?: string, options?: {
        updateLastValidation?: boolean;
        checkEnvironmentBinding?: boolean;
    }): Promise<ValidationResult>;

    /**
     * Check if a license key is blacklisted
     * @param key License key to check
     */
    checkBlacklist(key: string): Promise<boolean>;

    /**
     * Generate environment fingerprint for current environment
     */
    generateEnvironmentFingerprint(): string;

    /**
     * Validate environment binding against current environment
     * @param expectedFingerprint Expected environment fingerprint
     */
    validateEnvironmentBinding(expectedFingerprint: string): boolean;

    /**
     * Get license information without validation
     * @param key License key
     */
    getLicenseInfo(key: string): Promise<License | null>;

    /**
     * Close the secure database connection
     */
    closeConnection(): Promise<void>;

    /**
     * Check connection status
     */
    isConnectionActive(): boolean;

    /**
     * Create a new license validator instance
     * @param connectionString MongoDB connection string
     * @param options Connection options
     */
    static create(connectionString: string, options?: any): Promise<LicenseValidator>;
}

/**
 * Environment fingerprinting class
 */
export declare class EnvironmentFingerprinter {
    /**
     * Generate a unique machine identifier
     */
    static getMachineId(): string;

    /**
     * Get server hostname
     */
    static getHostname(): string;

    /**
     * Get server IP address
     */
    static getIpAddress(): string;

    /**
     * Get Node.js version
     */
    static getNodeVersion(): string;

    /**
     * Get project name
     */
    static getProjectName(): string;

    /**
     * Generate deployment fingerprint
     */
    static generateFingerprint(): DeploymentFingerprint;

    /**
     * Generate environment binding string
     */
    static generateEnvironmentBinding(): string;

    /**
     * Validate environment binding
     * @param expectedBinding Expected environment binding hash
     */
    static validateEnvironmentBinding(expectedBinding: string): boolean;

    /**
     * Compare two fingerprints for similarity
     * @param fingerprint1 First fingerprint
     * @param fingerprint2 Second fingerprint
     */
    static compareFingerprints(fingerprint1: DeploymentFingerprint, fingerprint2: DeploymentFingerprint): number;

    /**
     * Check if environment has changed significantly
     * @param previousFingerprint Previous fingerprint
     * @param threshold Similarity threshold (default: 0.6)
     */
    static hasEnvironmentChanged(previousFingerprint: DeploymentFingerprint, threshold?: number): boolean;

    /**
     * Get system information
     */
    static getSystemInfo(): SystemInfo;
}

/**
 * Main SecureGuard class
 */
export declare class SecureGuard {
    /**
     * Initialize the secure guard package
     * @param config Configuration object
     */
    static init(config: SecureGuardConfig): Promise<void>;

    /**
     * Check if the package is initialized
     */
    static isInitialized(): boolean;

    /**
     * Get current usage statistics
     */
    static getUsageStats(): UsageStats;

    /**
     * Get license information
     */
    static getLicenseInfo(): License;

    /**
     * Get deployment fingerprint
     */
    static getDeploymentFingerprint(): DeploymentFingerprint;

    /**
     * Generate environment binding string
     */
    static generateEnvironmentBinding(): string;

    /**
     * Validate environment binding
     * @param expectedBinding Expected environment binding hash
     */
    static validateEnvironmentBinding(expectedBinding: string): boolean;

    /**
     * Check if environment has changed significantly
     * @param previousFingerprint Previous fingerprint
     * @param threshold Similarity threshold (default: 0.6)
     */
    static hasEnvironmentChanged(previousFingerprint: DeploymentFingerprint, threshold?: number): boolean;

    /**
     * Get system information
     */
    static getSystemInfo(): SystemInfo;
}

/**
 * Initialize the secure guard package
 * @param config Configuration object
 */
export declare function init(config: SecureGuardConfig): Promise<void>;

/**
 * Check if the package is initialized
 */
export declare function isInitialized(): boolean;

/**
 * Get current usage statistics
 */
export declare function getUsageStats(): UsageStats;

/**
 * Get license information
 */
export declare function getLicenseInfo(): License;

/**
 * Get deployment fingerprint
 */
export declare function getDeploymentFingerprint(): DeploymentFingerprint;

/**
 * Generate environment binding string
 */
export declare function generateEnvironmentBinding(): string;

/**
 * Validate environment binding
 * @param expectedBinding Expected environment binding hash
 */
export declare function validateEnvironmentBinding(expectedBinding: string): boolean;

/**
 * Check if environment has changed significantly
 * @param previousFingerprint Previous fingerprint
 * @param threshold Similarity threshold (default: 0.6)
 */
export declare function hasEnvironmentChanged(previousFingerprint: DeploymentFingerprint, threshold?: number): boolean;

/**
 * Get system information
 */
export declare function getSystemInfo(): SystemInfo;

export { SecureGuard, EnvironmentFingerprinter, LicenseValidator };