@nice2dev/licensing 1.0.10

package/dist/index.d.ts

@@ -0,0 +1,2285 @@
+import { default as default_2 } from 'react';
+
+declare interface ActivationError {
+    code: string;
+    message: string;
+    retryable: boolean;
+    supportRequired?: boolean;
+}
+
+export declare class ActivationService {
+    private config;
+    constructor(config: ActivationWizardConfig);
+    private request;
+    validateKey(licenseKey: string): Promise<LicenseValidationResult>;
+    checkHardware(licenseKey: string, machineId: string, fingerprint: string): Promise<{
+        allowed: boolean;
+        reason?: string;
+        existingMachines?: number;
+    }>;
+    activate(licenseKey: string, machineId: string, fingerprint: string, machineName: string): Promise<LicenseInfo>;
+    getOfflineChallenge(licenseKey: string, machineId: string): Promise<string>;
+    activateOffline(licenseKey: string, machineId: string, response: string): Promise<LicenseInfo>;
+}
+
+export declare interface ActivationState {
+    step: ActivationStep;
+    licenseKey: string;
+    validation: LicenseValidationResult | null;
+    machineId: string | null;
+    fingerprint: string | null;
+    machineName: string;
+    termsAccepted: boolean;
+    error: ActivationError | null;
+    activatedLicense: LicenseInfo | null;
+    offlineChallenge: string | null;
+}
+
+export declare type ActivationStep = 'enter-key' | 'validate' | 'hardware-check' | 'terms' | 'activating' | 'success' | 'error';
+
+/** Main Activation Wizard component */
+export declare const ActivationWizard: default_2.FC<ActivationWizardProps>;
+
+export declare interface ActivationWizardConfig {
+    /** API base URL */
+    apiBaseUrl: string;
+    /** API authentication token */
+    authToken?: string;
+    /** Terms of service URL */
+    termsUrl?: string;
+    /** Privacy policy URL */
+    privacyUrl?: string;
+    /** Support email */
+    supportEmail?: string;
+    /** Allow offline activation */
+    allowOfflineActivation?: boolean;
+    /** Machine name (auto-detected if not provided) */
+    machineName?: string;
+    /** Callback when activation succeeds */
+    onActivationSuccess?: (license: LicenseInfo) => void;
+    /** Callback when activation fails */
+    onActivationError?: (error: ActivationError) => void;
+    /** Callback when wizard is canceled */
+    onCancel?: () => void;
+}
+
+declare interface ActivationWizardProps extends ActivationWizardConfig {
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare interface AnalyticsConfig {
+    apiBaseUrl: string;
+    authToken?: string;
+    /** Organization/customer ID */
+    organizationId?: string;
+    /** Refresh interval in ms (0 = no auto-refresh) */
+    refreshInterval?: number;
+    /** Enable real-time updates */
+    realtime?: boolean;
+    /** Default time range */
+    defaultTimeRange?: TimeRange;
+    /** Features to track */
+    trackedFeatures?: FeatureId[];
+}
+
+declare interface AnalyticsState {
+    loading: boolean;
+    error: string | null;
+    timeRange: TimeRange;
+    overview: OverviewMetrics | null;
+    licenseActivity: TimeSeriesDataPoint[];
+    userActivity: TimeSeriesDataPoint[];
+    featureUsage: FeatureUsageData[];
+    topUsers: UserActivityData[];
+    licenseUtilization: LicenseUtilizationData[];
+    geoData: GeographicData[];
+    trends: TrendData[];
+    retentionCohorts: CohortData[];
+}
+
+/**
+ * Multi-endpoint rate limiter — maintains a separate bucket per endpoint/action.
+ */
+export declare class ApiRateLimiter {
+    private limiters;
+    private tier;
+    private config;
+    private endpointOverrides;
+    constructor(tier: LicenseTier, config?: RateLimitConfig);
+    /** Set endpoint-specific rate limit overrides */
+    setEndpointOverride(endpoint: string, overrides: Partial<RateLimitConfig>): void;
+    /** Update the current tier (resets all limiters) */
+    setTier(tier: LicenseTier): void;
+    /** Get or create a limiter for an endpoint */
+    private getLimiter;
+    /** Check if a request to the given endpoint is allowed and consume a token */
+    check(endpoint?: string): RateLimitResult;
+    /** Peek without consuming */
+    peek(endpoint?: string): RateLimitResult;
+    /** Reset all limiters */
+    reset(): void;
+}
+
+/** Actor who triggered an audit event */
+export declare interface AuditActor {
+    /** Actor type */
+    type: 'user' | 'admin' | 'system' | 'api';
+    /** Actor identifier (user ID, service name, etc.) */
+    id: string;
+    /** Display name */
+    name?: string;
+}
+
+/** Single audit log entry */
+export declare interface AuditEntry {
+    /** Unique entry ID */
+    id: string;
+    /** Event type */
+    event: AuditEventType;
+    /** ISO timestamp */
+    timestamp: string;
+    /** License key (hashed for security) */
+    licenseKeyHash: string;
+    /** Actor who performed the action */
+    actor: AuditActor;
+    /** Previous value (for changes) */
+    previousValue?: unknown;
+    /** New value (for changes) */
+    newValue?: unknown;
+    /** Human-readable description */
+    description: string;
+    /** IP address of the action (hashed) */
+    ipHash?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+
+/** Audit event types */
+export declare type AuditEventType = 'license.created' | 'license.activated' | 'license.deactivated' | 'license.renewed' | 'license.expired' | 'license.revoked' | 'license.tier-changed' | 'license.seats-changed' | 'license.feature-added' | 'license.feature-removed' | 'license.machine-bound' | 'license.machine-unbound' | 'license.validation-failed' | 'license.grace-started' | 'license.grace-ended' | 'whitelabel.config-changed' | 'sla.breach-detected' | 'admin.key-generated' | 'admin.bulk-action';
+
+/** Audit export format */
+export declare type AuditExportFormat = 'json' | 'csv';
+
+/** Query filter for audit log */
+export declare interface AuditQuery {
+    /** Filter by event types */
+    events?: AuditEventType[];
+    /** Filter by license key hash */
+    licenseKeyHash?: string;
+    /** Filter by actor ID */
+    actorId?: string;
+    /** Start date (inclusive) */
+    from?: Date;
+    /** End date (inclusive) */
+    to?: Date;
+    /** Maximum number of results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+
+/**
+ * Audit Trail — append-only log with query and export capabilities
+ */
+export declare class AuditTrail {
+    private entries;
+    private serverUrl?;
+    private apiKey?;
+    constructor(options?: {
+        serverUrl?: string;
+        apiKey?: string;
+    });
+    /** Append an audit entry */
+    log(event: AuditEventType, licenseKey: LicenseKey, actor: AuditActor, description: string, details?: {
+        previousValue?: unknown;
+        newValue?: unknown;
+        ipHash?: string;
+        metadata?: Record<string, unknown>;
+    }): AuditEntry;
+    logActivation(licenseKey: LicenseKey, actor: AuditActor): AuditEntry;
+    logDeactivation(licenseKey: LicenseKey, actor: AuditActor): AuditEntry;
+    logTierChange(licenseKey: LicenseKey, actor: AuditActor, from: LicenseTier, to: LicenseTier): AuditEntry;
+    logSeatsChange(licenseKey: LicenseKey, actor: AuditActor, from: number, to: number): AuditEntry;
+    logRevocation(licenseKey: LicenseKey, actor: AuditActor, reason?: string): AuditEntry;
+    /** Query audit entries with filters */
+    query(filter?: AuditQuery): AuditEntry[];
+    /** Get total entry count (optionally filtered) */
+    count(filter?: AuditQuery): number;
+    /** Export audit entries */
+    export(filter?: AuditQuery, format?: AuditExportFormat): string;
+    private sendToServer;
+    /** Get all entries (read-only copy) */
+    getAll(): AuditEntry[];
+}
+
+export declare interface BillingConfig {
+    /** Stripe publishable key */
+    stripePublishableKey?: string;
+    /** Paddle vendor ID */
+    paddleVendorId?: string;
+    /** Paddle environment */
+    paddleEnvironment?: 'sandbox' | 'production';
+    /** API base URL for billing operations */
+    apiBaseUrl: string;
+    /** Authentication token */
+    authToken?: string;
+    /** Default currency */
+    defaultCurrency?: string;
+    /** Supported currencies */
+    supportedCurrencies?: string[];
+    /** Tax handling */
+    taxHandling?: 'inclusive' | 'exclusive';
+    /** Webhooks enabled */
+    webhooksEnabled?: boolean;
+}
+
+declare type BillingInterval = 'monthly' | 'yearly' | 'once';
+
+declare interface BillingPortalSession {
+    id: string;
+    url: string;
+    provider: PaymentProvider;
+}
+
+export declare class BillingService {
+    private config;
+    constructor(config: BillingConfig);
+    private request;
+    /** Get all pricing plans */
+    getPlans(currency?: string): Promise<PricingPlan[]>;
+    /** Get plan by ID */
+    getPlan(planId: string): Promise<PricingPlan>;
+    /** Compare plans (for upgrade/downgrade) */
+    comparePlans(currentPlanId: string, targetPlanId: string, seats?: number): Promise<{
+        currentPlan: PricingPlan;
+        targetPlan: PricingPlan;
+        proration: ProratedAmount;
+        isUpgrade: boolean;
+    }>;
+    /** Get current subscription */
+    getSubscription(): Promise<Subscription | null>;
+    /** Get subscription by ID */
+    getSubscriptionById(subscriptionId: string): Promise<Subscription>;
+    /** Create checkout session for new subscription */
+    createCheckoutSession(options: {
+        planId: string;
+        interval: BillingInterval;
+        seats?: number;
+        successUrl: string;
+        cancelUrl: string;
+        provider?: PaymentProvider;
+        couponCode?: string;
+        metadata?: Record<string, string>;
+    }): Promise<CheckoutSession>;
+    /** Create billing portal session */
+    createPortalSession(returnUrl: string): Promise<BillingPortalSession>;
+    /** Update subscription (change plan, seats) */
+    updateSubscription(options: {
+        planId?: string;
+        seats?: number;
+        interval?: BillingInterval;
+        prorate?: boolean;
+    }): Promise<Subscription>;
+    /** Cancel subscription */
+    cancelSubscription(options?: {
+        atPeriodEnd?: boolean;
+        reason?: string;
+        feedback?: string;
+    }): Promise<Subscription>;
+    /** Resume canceled subscription */
+    resumeSubscription(): Promise<Subscription>;
+    /** Pause subscription (Paddle only) */
+    pauseSubscription(): Promise<Subscription>;
+    /** Get saved payment methods */
+    getPaymentMethods(): Promise<PaymentMethod[]>;
+    /** Add payment method (redirect to Stripe/Paddle) */
+    addPaymentMethod(returnUrl: string): Promise<{
+        url: string;
+    }>;
+    /** Remove payment method */
+    removePaymentMethod(paymentMethodId: string): Promise<void>;
+    /** Set default payment method */
+    setDefaultPaymentMethod(paymentMethodId: string): Promise<void>;
+    /** Get invoices */
+    getInvoices(options?: {
+        limit?: number;
+        offset?: number;
+        status?: Invoice['status'];
+    }): Promise<{
+        invoices: Invoice[];
+        total: number;
+    }>;
+    /** Get upcoming invoice preview */
+    getUpcomingInvoice(): Promise<Invoice | null>;
+    /** Download invoice PDF */
+    downloadInvoice(invoiceId: string): Promise<Blob>;
+    /** Validate coupon code */
+    validateCoupon(code: string, planId?: string): Promise<{
+        valid: boolean;
+        coupon?: {
+            id: string;
+            code: string;
+            percentOff?: number;
+            amountOff?: number;
+            duration: 'once' | 'forever' | 'repeating';
+            durationInMonths?: number;
+            applicablePlans?: string[];
+        };
+        error?: string;
+    }>;
+    /** Apply coupon to subscription */
+    applyCoupon(code: string): Promise<Subscription>;
+    /** Report usage */
+    reportUsage(records: UsageRecord[]): Promise<void>;
+    /** Get usage summary */
+    getUsageSummary(startDate: string, endDate: string): Promise<{
+        metrics: {
+            id: string;
+            name: string;
+            usage: number;
+            limit?: number;
+            cost: number;
+        }[];
+        totalCost: number;
+    }>;
+    private detectPreferredProvider;
+    /** Format price for display */
+    formatPrice(amount: number, currency?: string): string;
+    /** Calculate savings for yearly billing */
+    calculateYearlySavings(plan: PricingPlan): {
+        monthlyTotal: number;
+        yearlyTotal: number;
+        savings: number;
+        savingsPercent: number;
+    };
+}
+
+export declare interface BuildLicenseConfig {
+    /** License key (can be from env var) */
+    licenseKey?: LicenseKey;
+    /** Environment variable name for license key */
+    licenseKeyEnvVar?: string;
+    /** License server URL for online validation */
+    licenseServerUrl?: string;
+    /** Fail build if license is invalid */
+    failOnInvalid?: boolean;
+    /** Fail build if license is expired */
+    failOnExpired?: boolean;
+    /** Required tier for build */
+    requiredTier?: LicenseTier;
+    /** Required features for build */
+    requiredFeatures?: FeatureId[];
+    /** Allow offline license (cached) */
+    allowOffline?: boolean;
+    /** Cache directory for offline license */
+    cacheDir?: string;
+    /** Silent mode (no console output) */
+    silent?: boolean;
+    /** Custom validation endpoint */
+    validationEndpoint?: string;
+    /** Timeout for license validation (ms) */
+    validationTimeout?: number;
+}
+
+export declare interface BuildLicenseResult {
+    valid: boolean;
+    licenseKey?: LicenseKey;
+    tier?: LicenseTier;
+    licensee?: string;
+    features?: FeatureId[];
+    expiresAt?: string;
+    daysRemaining?: number;
+    warnings: string[];
+    errors: string[];
+}
+
+export declare class BuildLicenseValidator {
+    private config;
+    private licenseInfo;
+    private validationResult;
+    constructor(config?: BuildLicenseConfig);
+    /** Get license key from config or environment */
+    private getLicenseKey;
+    /** Log message (unless silent) */
+    private log;
+    /** Validate license online */
+    private validateOnline;
+    /** Load cached license */
+    private loadCachedLicense;
+    /** Save license to cache */
+    private saveLicenseCache;
+    /** Validate license (main entry point) */
+    validate(): Promise<BuildLicenseResult>;
+    /** Get validation result */
+    getResult(): BuildLicenseResult | null;
+    /** Get license info */
+    getLicenseInfo(): LicenseInfo | null;
+    /** Check if feature is available */
+    hasFeature(featureId: FeatureId): boolean;
+    /** Check if tier meets requirement */
+    meetsTier(requiredTier: LicenseTier): boolean;
+}
+
+/** Bundle tag added to chunks containing protected code */
+export declare interface BundleTag {
+    /** Chunk/file identifier */
+    chunkId: string;
+    /** Required tier */
+    requiredTier: LicenseTier;
+    /** Access level */
+    accessLevel: SourceAccessLevel;
+    /** Modules in this chunk */
+    modules: string[];
+}
+
+/**
+ * Check feature access with detailed result
+ */
+export declare function checkFeatureAccess(license: LicenseInfo | null, featureId: FeatureId): FeatureCheckResult;
+
+export declare interface CheckoutSession {
+    id: string;
+    url: string;
+    provider: PaymentProvider;
+    expiresAt: string;
+}
+
+export declare interface CILicenseCheckOptions {
+    /** License key */
+    licenseKey?: LicenseKey;
+    /** Environment variable containing license key */
+    licenseKeyEnvVar?: string;
+    /** License server URL */
+    licenseServerUrl?: string;
+    /** Required minimum tier */
+    requiredTier?: LicenseTier;
+    /** Required features */
+    requiredFeatures?: FeatureId[];
+    /** Fail pipeline if invalid */
+    failOnInvalid?: boolean;
+    /** Fail pipeline if expired */
+    failOnExpired?: boolean;
+    /** Skip validation for PRs from forks */
+    skipForForks?: boolean;
+    /** Grace period days after expiration */
+    expirationGraceDays?: number;
+    /** Output format */
+    outputFormat?: 'human' | 'json' | 'ci-annotations';
+    /** Set CI environment variables with license info */
+    setEnvVars?: boolean;
+}
+
+export declare interface CILicenseCheckResult {
+    success: boolean;
+    platform: CIPlatform;
+    exitCode: number;
+    message: string;
+    license?: {
+        key: LicenseKey;
+        tier: LicenseTier;
+        licensee?: string;
+        features: FeatureId[];
+        expiresAt?: string;
+        daysRemaining?: number;
+    };
+    warnings: string[];
+    errors: string[];
+}
+
+export declare type CIPlatform = 'github-actions' | 'azure-devops' | 'gitlab-ci' | 'jenkins' | 'circleci' | 'bitbucket-pipelines' | 'travis-ci' | 'unknown';
+
+declare interface CohortData {
+    cohort: string;
+    retained: number[];
+    total: number;
+}
+
+/**
+ * Collect all fingerprint components
+ */
+export declare function collectFingerprintData(): Promise<HardwareFingerprintData>;
+
+/**
+ * Compare two fingerprints with tolerance (fuzzy match)
+ * Returns similarity score 0-1
+ */
+export declare function compareFingerprintsData(fp1: HardwareFingerprintData, fp2: HardwareFingerprintData): number;
+
+/**
+ * Compare two tiers, returns positive if a > b
+ */
+export declare function compareTiers(a: LicenseTier, b: LicenseTier): number;
+
+/** Convenience factory */
+export declare function createApiRateLimiter(tier: LicenseTier, config?: RateLimitConfig): ApiRateLimiter;
+
+/** Convenience factory */
+export declare function createAuditTrail(options?: {
+    serverUrl?: string;
+    apiKey?: string;
+}): AuditTrail;
+
+export declare function createBillingService(config: BillingConfig): BillingService;
+
+/** Create floating license manager instance */
+export declare function createFloatingLicenseManager(serverUrl: string, apiKey?: string): FloatingLicenseManager;
+
+export declare function createRefundService(config: RefundConfig): RefundService;
+
+/** Create seat manager instance */
+export declare function createSeatManager(serverUrl: string, apiKey?: string): SeatManager;
+
+/** Convenience factory */
+export declare function createSlaTracker(tier: LicenseTier): SlaTracker;
+
+/** Convenience factory */
+export declare function createTelemetry(config: UsageTelemetryConfig): UsageTelemetry;
+
+/** Convenience factory */
+export declare function createWhiteLabelManager(tier: LicenseTier, config?: WhiteLabelConfig): WhiteLabelManager;
+
+export declare interface CustomerLicenseOverview {
+    /** Total licenses owned */
+    totalLicenses: number;
+    /** Active licenses */
+    activeLicenses: number;
+    /** Expired licenses */
+    expiredLicenses: number;
+    /** Licenses in grace period */
+    gracePeriodLicenses: number;
+    /** Total seats across all licenses */
+    totalSeats: number;
+    /** Used seats */
+    usedSeats: number;
+    /** Available seats */
+    availableSeats: number;
+    /** Licenses expiring soon (30 days) */
+    expiringSoon: LicenseInfo[];
+    /** All licenses */
+    licenses: LicenseInfo[];
+}
+
+/** Default tier rate limits (requests per minute) */
+export declare const DEFAULT_RATE_LIMITS: RateLimitConfig;
+
+export declare const DEFAULT_REFUND_POLICY: RefundPolicy;
+
+/** Default SLA configurations per tier */
+export declare const DEFAULT_SLA_CONFIGS: Record<LicenseTier, SlaTierConfig>;
+
+export declare function detectCIPlatform(): CIPlatform;
+
+/**
+ * Extract metadata from license key
+ */
+export declare function extractKeyMetadata(key: LicenseKey): {
+    tier: LicenseTier;
+    year: number;
+    month: number;
+} | null;
+
+/**
+ * Feature check result
+ */
+export declare interface FeatureCheckResult {
+    allowed: boolean;
+    reason?: 'no-license' | 'tier-insufficient' | 'feature-not-included' | 'expired';
+    requiredTier?: LicenseTier;
+    upgradeTarget?: LicenseTier;
+}
+
+/** Feature definition */
+export declare interface FeatureDefinition {
+    /** Feature ID */
+    id: FeatureId;
+    /** Display name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Required tier (minimum) */
+    requiredTier: LicenseTier;
+    /** Is beta feature */
+    isBeta?: boolean;
+    /** Feature category */
+    category?: string;
+    /** Dependencies on other features */
+    dependencies?: FeatureId[];
+}
+
+/** Feature flag identifier */
+export declare type FeatureId = string;
+
+export declare interface FeatureUsageData {
+    featureId: FeatureId;
+    featureName: string;
+    category?: string;
+    totalUses: number;
+    uniqueUsers: number;
+    avgUsesPerUser: number;
+    trend: number;
+    history: TimeSeriesDataPoint[];
+}
+
+/**
+ * Floating License Manager — for shared concurrent licenses
+ */
+export declare class FloatingLicenseManager {
+    private serverUrl;
+    private apiKey?;
+    private leaseId?;
+    private renewInterval?;
+    constructor(serverUrl: string, apiKey?: string);
+    /**
+     * Acquire a floating license
+     */
+    acquireLease(licenseKey: LicenseKey): Promise<{
+        success: boolean;
+        leaseId?: string;
+        expiresAt?: string;
+        error?: string;
+    }>;
+    /**
+     * Release floating license
+     */
+    releaseLease(licenseKey: LicenseKey): Promise<boolean>;
+    /**
+     * Get floating license status
+     */
+    getFloatingStatus(licenseKey: LicenseKey): Promise<{
+        total: number;
+        available: number;
+        leases: Array<{
+            leaseId: string;
+            machineId: MachineId;
+            expiresAt: string;
+        }>;
+    }>;
+    /**
+     * Start lease renewal interval
+     */
+    private startLeaseRenewal;
+    /**
+     * Stop lease renewal
+     */
+    private stopLeaseRenewal;
+    /**
+     * Check if we have an active lease
+     */
+    hasActiveLease(): boolean;
+    /**
+     * Cleanup
+     */
+    cleanup(licenseKey: LicenseKey): Promise<void>;
+}
+
+export declare function generateAzureDevOpsPipeline(options: {
+    requiredTier?: LicenseTier;
+}): string;
+
+/**
+ * Generate bundle tags for a build manifest.
+ * Consumed by the Vite/webpack plugin to tag output chunks.
+ */
+export declare function generateBundleTags(): BundleTag[];
+
+/**
+ * Generate hardware fingerprint
+ */
+export declare function generateFingerprint(): Promise<HardwareFingerprint>;
+
+export declare function generateGitHubActionsWorkflow(options: {
+    requiredTier?: LicenseTier;
+    requiredFeatures?: FeatureId[];
+    skipForForks?: boolean;
+}): string;
+
+export declare function generateGitLabCIPipeline(options: {
+    requiredTier?: LicenseTier;
+}): string;
+
+/**
+ * Generate license info from key options
+ */
+export declare function generateLicenseInfo(options: LicenseKeyOptions): LicenseInfo;
+
+/**
+ * Generate a new license key
+ * Format: XXXX-XXXX-XXXX-XXXX-XXXX
+ * - Segment 1: Encoded metadata (tier, date)
+ * - Segment 2-4: Random unique identifier
+ * - Segment 5: Checksum
+ */
+export declare function generateLicenseKey(tier?: LicenseTier): LicenseKey;
+
+/**
+ * Generate machine ID (stable identifier for this machine)
+ */
+export declare function generateMachineId(): Promise<MachineId>;
+
+/**
+ * Generate a protection manifest (JSON-serializable) for embedding
+ * in production builds.
+ */
+export declare function generateProtectionManifest(): {
+    version: string;
+    generated: string;
+    modules: ProtectedModuleEntry[];
+    bundleTags: BundleTag[];
+};
+
+declare interface GeographicData {
+    country: string;
+    countryCode: string;
+    users: number;
+    sessions: number;
+    avgDuration: number;
+}
+
+/** Get modules accessible at a given tier */
+export declare function getAccessibleModules(currentTier: LicenseTier): ProtectedModuleEntry[];
+
+/**
+ * Get all registered features
+ */
+export declare function getAllFeatures(): FeatureDefinition[];
+
+/**
+ * Get all plans
+ */
+export declare function getAllPlans(): LicensePlan[];
+
+/** Get all protected module entries */
+export declare function getAllProtectedModules(): ProtectedModuleEntry[];
+
+/**
+ * Get all available features for a license
+ */
+export declare function getAvailableFeatures(license: LicenseInfo | null): FeatureId[];
+
+/**
+ * Get default features for tier
+ */
+export declare function getDefaultFeatures(tier: LicenseTier): FeatureId[];
+
+/**
+ * Get default max machines for tier
+ */
+export declare function getDefaultMachines(tier: LicenseTier): number;
+
+/**
+ * Get default max seats for tier
+ */
+export declare function getDefaultSeats(tier: LicenseTier): number | null;
+
+/**
+ * Get feature definition
+ */
+export declare function getFeature(id: FeatureId): FeatureDefinition | undefined;
+
+/**
+ * Get features by category
+ */
+export declare function getFeaturesByCategory(category: string): FeatureDefinition[];
+
+/** Get modules that require a higher tier than current */
+export declare function getInaccessibleModules(currentTier: LicenseTier): ProtectedModuleEntry[];
+
+/**
+ * Get missing features for upgrade promotion
+ */
+export declare function getMissingFeatures(license: LicenseInfo | null, targetTier: LicenseTier): FeatureDefinition[];
+
+/**
+ * Get or generate fingerprint (uses cached value if available)
+ */
+export declare function getOrGenerateFingerprint(): Promise<HardwareFingerprint>;
+
+/**
+ * Get plan by tier
+ */
+export declare function getPlan(tier: LicenseTier): LicensePlan | undefined;
+
+/** Get a protected module entry by path */
+export declare function getProtectedModule(modulePath: string): ProtectedModuleEntry | undefined;
+
+/**
+ * Retrieve stored fingerprint
+ */
+export declare function getStoredFingerprint(): HardwareFingerprint | null;
+
+/**
+ * Get or create global validator instance
+ */
+export declare function getValidator(config?: Partial<LicenseServerConfig>): LicenseValidator;
+
+/** Hardware fingerprint hash */
+export declare type HardwareFingerprint = string;
+
+/** Hardware fingerprint components */
+export declare interface HardwareFingerprintData {
+    /** CPU identifier */
+    cpuId?: string;
+    /** Motherboard serial */
+    motherboardSerial?: string;
+    /** Disk serial */
+    diskSerial?: string;
+    /** MAC address hash */
+    macAddressHash?: string;
+    /** OS installation ID */
+    osInstallId?: string;
+    /** Browser fingerprint (for web) */
+    browserFingerprint?: string;
+    /** User agent hash */
+    userAgentHash?: string;
+    /** WebGL renderer hash */
+    webglHash?: string;
+    /** Canvas fingerprint */
+    canvasFingerprint?: string;
+    /** Audio context fingerprint */
+    audioFingerprint?: string;
+}
+
+/**
+ * Check if license has specific feature
+ */
+export declare function hasFeature(license: LicenseInfo | null, featureId: FeatureId): boolean;
+
+/** Hash a license key for audit storage */
+export declare function hashKeyForAudit(key: LicenseKey): string;
+
+/** Hash a license key for anonymous tracking */
+export declare function hashLicenseKey(key: string): string;
+
+/**
+ * Check if license meets tier requirement
+ */
+export declare function hasTier(license: LicenseInfo | null, requiredTier: LicenseTier): boolean;
+
+/**
+ * Initialize default features and plans
+ */
+export declare function initializeDefaults(): void;
+
+export declare interface Invoice {
+    id: string;
+    number: string;
+    status: 'draft' | 'open' | 'paid' | 'void' | 'uncollectible';
+    amount: number;
+    amountPaid: number;
+    amountDue: number;
+    currency: string;
+    createdAt: string;
+    dueDate: string;
+    paidAt?: string;
+    periodStart: string;
+    periodEnd: string;
+    lineItems: InvoiceLineItem[];
+    pdfUrl?: string;
+    hostedUrl?: string;
+}
+
+declare interface InvoiceInfo {
+    id: string;
+    number: string;
+    status: 'draft' | 'open' | 'paid' | 'void' | 'uncollectible';
+    amount: number;
+    currency: string;
+    issuedAt: string;
+    dueAt: string;
+    paidAt?: string;
+    downloadUrl?: string;
+}
+
+declare interface InvoiceLineItem {
+    description: string;
+    quantity: number;
+    unitPrice: number;
+    amount: number;
+    taxAmount?: number;
+}
+
+/**
+ * Check if feature is licensed (convenience function)
+ */
+export declare function isFeatureLicensed(key: LicenseKey, feature: FeatureId): Promise<boolean>;
+
+export declare function isForkPR(): boolean;
+
+/** Check if a module is accessible for a given tier */
+export declare function isModuleAccessible(modulePath: string, currentTier: LicenseTier): boolean;
+
+export declare interface LicenseAction {
+    id: string;
+    type: 'activate' | 'deactivate' | 'transfer' | 'upgrade' | 'renew' | 'revoke';
+    licenseKey: LicenseKey;
+    timestamp: string;
+    performedBy: string;
+    details?: Record<string, unknown>;
+}
+
+/** License card component */
+export declare const LicenseCard: default_2.FC<{
+    license: LicenseInfo;
+    onSelect?: () => void;
+    onActivate?: () => void;
+    onDeactivate?: () => void;
+    selected?: boolean;
+}>;
+
+/** License error codes */
+export declare type LicenseErrorCode = 'INVALID_KEY' | 'EXPIRED' | 'REVOKED' | 'MACHINE_LIMIT' | 'SEAT_LIMIT' | 'FEATURE_NOT_LICENSED' | 'NETWORK_ERROR' | 'SERVER_ERROR' | 'TAMPERED' | 'CLOCK_SKEW';
+
+export declare interface LicenseFeatureGate {
+    featureId: FeatureId;
+    requiredTier: LicenseTier;
+    requiredFeature?: FeatureId;
+    files: string[];
+    replacement?: string;
+}
+
+/** License metadata */
+export declare interface LicenseInfo {
+    /** Unique license key */
+    key: LicenseKey;
+    /** License tier */
+    tier: LicenseTier;
+    /** Current status */
+    status: LicenseStatus;
+    /** Organization/User name */
+    licensee: string;
+    /** Contact email */
+    email: string;
+    /** Issue date (ISO 8601) */
+    issuedAt: string;
+    /** Expiration date (ISO 8601), null for perpetual */
+    expiresAt: string | null;
+    /** Grace period end date (ISO 8601) */
+    graceUntil?: string;
+    /** Enabled feature flags */
+    features: FeatureId[];
+    /** Maximum seats (users), null for unlimited */
+    maxSeats: number | null;
+    /** Currently active seats */
+    activeSeats: number;
+    /** Bound hardware fingerprints */
+    boundMachines: MachineId[];
+    /** Maximum machines allowed */
+    maxMachines: number;
+    /** Floating license pool size */
+    floatingSeats?: number;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+
+/** License key format: XXXX-XXXX-XXXX-XXXX-XXXX */
+export declare type LicenseKey = string;
+
+/** License key generation options */
+export declare interface LicenseKeyOptions {
+    /** License tier */
+    tier: LicenseTier;
+    /** Licensee name */
+    licensee: string;
+    /** Contact email */
+    email: string;
+    /** Duration in days, null for perpetual */
+    durationDays: number | null;
+    /** Grace period in days after expiration */
+    graceDays?: number;
+    /** Features to enable */
+    features?: FeatureId[];
+    /** Max seats */
+    maxSeats?: number | null;
+    /** Max machines for hardware binding */
+    maxMachines?: number;
+    /** Floating seats for concurrent use */
+    floatingSeats?: number;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+
+/** License comparison plan */
+export declare interface LicensePlan {
+    /** Plan ID (maps to tier) */
+    id: LicenseTier;
+    /** Display name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Price per month (cents) */
+    priceMonthly: number;
+    /** Price per year (cents) */
+    priceYearly: number;
+    /** Included features */
+    features: FeatureId[];
+    /** Max seats */
+    maxSeats: number | null;
+    /** Max machines */
+    maxMachines: number;
+    /** Highlights for marketing */
+    highlights: string[];
+    /** Is recommended */
+    recommended?: boolean;
+}
+
+/** Main License Portal component */
+export declare const LicensePortal: default_2.FC<LicensePortalProps>;
+
+export declare interface LicensePortalConfig {
+    /** API base URL for license operations */
+    apiBaseUrl: string;
+    /** Authentication token */
+    authToken?: string;
+    /** Customer/Organization ID */
+    customerId: string;
+    /** Enable dark mode */
+    darkMode?: boolean;
+    /** Locale for date/number formatting */
+    locale?: string;
+    /** Currency code for billing */
+    currency?: string;
+    /** Show billing section */
+    showBilling?: boolean;
+    /** Show usage analytics */
+    showAnalytics?: boolean;
+    /** Allow license transfers */
+    allowTransfers?: boolean;
+    /** Allow seat management */
+    allowSeatManagement?: boolean;
+    /** Custom theme colors */
+    theme?: LicensePortalTheme;
+    /** Callback when license is activated */
+    onLicenseActivated?: (license: LicenseInfo) => void;
+    /** Callback when license is deactivated */
+    onLicenseDeactivated?: (licenseKey: LicenseKey) => void;
+    /** Callback on error */
+    onError?: (error: LicensePortalError) => void;
+}
+
+declare interface LicensePortalError {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+
+declare interface LicensePortalProps extends LicensePortalConfig {
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare class LicensePortalService {
+    private config;
+    constructor(config: LicensePortalConfig);
+    private request;
+    /** Get customer license overview */
+    getOverview(): Promise<CustomerLicenseOverview>;
+    /** Get detailed license info */
+    getLicense(licenseKey: LicenseKey): Promise<LicenseInfo>;
+    /** Activate license on current machine */
+    activateLicense(licenseKey: LicenseKey, machineId: string, machineName?: string): Promise<LicenseInfo>;
+    /** Deactivate license from machine */
+    deactivateLicense(licenseKey: LicenseKey, machineId: string): Promise<void>;
+    /** Transfer license to another user/org */
+    transferLicense(licenseKey: LicenseKey, targetEmail: string, notes?: string): Promise<{
+        transferId: string;
+        status: string;
+    }>;
+    /** Get seat assignments */
+    getSeats(licenseKey: LicenseKey): Promise<SeatInfo[]>;
+    /** Assign seat to user */
+    assignSeat(licenseKey: LicenseKey, userId: string, email: string): Promise<SeatInfo>;
+    /** Remove seat assignment */
+    removeSeat(licenseKey: LicenseKey, seatId: string): Promise<void>;
+    /** Get subscription info */
+    getSubscription(): Promise<SubscriptionInfo | null>;
+    /** Get invoices */
+    getInvoices(limit?: number, offset?: number): Promise<{
+        invoices: InvoiceInfo[];
+        total: number;
+    }>;
+    /** Get action history */
+    getActionHistory(licenseKey?: LicenseKey, limit?: number): Promise<LicenseAction[]>;
+    /** Request license renewal */
+    requestRenewal(licenseKey: LicenseKey): Promise<{
+        checkoutUrl: string;
+    }>;
+    /** Request tier upgrade */
+    requestUpgrade(licenseKey: LicenseKey, targetTier: LicenseTier): Promise<{
+        checkoutUrl: string;
+        proratedAmount: number;
+    }>;
+}
+
+declare interface LicensePortalState {
+    loading: boolean;
+    error: LicensePortalError | null;
+    overview: CustomerLicenseOverview | null;
+    selectedLicense: LicenseInfo | null;
+    actionHistory: LicenseAction[];
+    subscription: SubscriptionInfo | null;
+    invoices: InvoiceInfo[];
+    activeTab: 'overview' | 'licenses' | 'seats' | 'billing' | 'analytics' | 'settings';
+}
+
+declare interface LicensePortalTheme {
+    primaryColor: string;
+    secondaryColor: string;
+    backgroundColor: string;
+    surfaceColor: string;
+    textColor: string;
+    errorColor: string;
+    successColor: string;
+    warningColor: string;
+}
+
+/** License server configuration */
+export declare interface LicenseServerConfig {
+    /** Server URL */
+    serverUrl: string;
+    /** API key for server communication */
+    apiKey?: string;
+    /** Request timeout in ms */
+    timeout?: number;
+    /** Retry attempts */
+    retries?: number;
+    /** Cache TTL in seconds */
+    cacheTtl?: number;
+    /** Enable offline mode */
+    offlineMode?: boolean;
+    /** Telemetry opt-in */
+    telemetryEnabled?: boolean;
+}
+
+/** License store state */
+export declare interface LicenseState {
+    /** Current license info */
+    license: LicenseInfo | null;
+    /** Validation result */
+    validation: LicenseValidationResult | null;
+    /** Is loading */
+    loading: boolean;
+    /** Last error */
+    error: string | null;
+    /** Available features (computed) */
+    features: Set<FeatureId>;
+    /** Hardware fingerprint */
+    fingerprint: HardwareFingerprint | null;
+}
+
+/** License status */
+export declare type LicenseStatus = 'valid' | 'expired' | 'revoked' | 'invalid' | 'grace' | 'pending';
+
+/** License status badge */
+export declare const LicenseStatusBadge: default_2.FC<{
+    status: LicenseStatus;
+    size?: 'sm' | 'md' | 'lg';
+}>;
+
+/** License tier levels */
+export declare type LicenseTier = 'trial' | 'personal' | 'team' | 'enterprise' | 'site' | 'oem';
+
+/** License tier badge */
+export declare const LicenseTierBadge: default_2.FC<{
+    tier: LicenseTier;
+    size?: 'sm' | 'md' | 'lg';
+}>;
+
+/** License Transfer Wizard */
+export declare const LicenseTransfer: default_2.FC<LicenseTransferProps>;
+
+declare interface LicenseTransferProps extends TransferConfig {
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare class LicenseTransferService {
+    private config;
+    constructor(config: TransferConfig);
+    private request;
+    /** Get transferable licenses */
+    getTransferableLicenses(): Promise<LicenseInfo[]>;
+    /** Validate recipient email/organization */
+    validateRecipient(email: string): Promise<{
+        valid: boolean;
+        recipientInfo?: TransferParty;
+        isExternal: boolean;
+        warnings?: string[];
+    }>;
+    /** Initiate transfer */
+    initiateTransfer(data: {
+        licenseKey: string;
+        recipientEmail: string;
+        recipientName: string;
+        notes?: string;
+        reason: string;
+    }): Promise<TransferRequest>;
+    /** Get transfer by ID */
+    getTransfer(transferId: string): Promise<TransferRequest>;
+    /** Get pending transfers */
+    getPendingTransfers(): Promise<TransferRequest[]>;
+    /** Get transfer history */
+    getTransferHistory(licenseKey?: string): Promise<TransferRequest[]>;
+    /** Cancel transfer */
+    cancelTransfer(transferId: string, reason?: string): Promise<TransferRequest>;
+    /** Accept transfer (as recipient) */
+    acceptTransfer(transferId: string, token: string): Promise<TransferRequest>;
+    /** Approve transfer (admin) */
+    approveTransfer(transferId: string): Promise<TransferRequest>;
+    /** Reject transfer (admin) */
+    rejectTransfer(transferId: string, reason: string): Promise<TransferRequest>;
+}
+
+declare interface LicenseUtilizationData {
+    licenseKey: string;
+    tier: LicenseTier;
+    licensee: string;
+    totalSeats: number;
+    usedSeats: number;
+    utilizationPercent: number;
+    lastActivity: string;
+    activeUsersLast30d: number;
+}
+
+/** License validation result */
+export declare interface LicenseValidationResult {
+    /** Is the license valid */
+    valid: boolean;
+    /** License info if valid */
+    license?: LicenseInfo;
+    /** Error code if invalid */
+    errorCode?: LicenseErrorCode;
+    /** Human-readable error message */
+    errorMessage?: string;
+    /** Days until expiration */
+    daysRemaining?: number;
+    /** Is in grace period */
+    inGracePeriod?: boolean;
+    /** Features available */
+    availableFeatures?: FeatureId[];
+    /** Validation timestamp */
+    validatedAt: string;
+}
+
+/**
+ * License Validator Service
+ */
+export declare class LicenseValidator {
+    private config;
+    private cache;
+    constructor(config?: Partial<LicenseServerConfig>);
+    /**
+     * Validate a license key
+     */
+    validate(key: LicenseKey, fingerprint?: HardwareFingerprint): Promise<LicenseValidationResult>;
+    /**
+     * Online license validation
+     */
+    private validateOnline;
+    /**
+     * Parse server validation response
+     */
+    private parseServerResponse;
+    /**
+     * Offline license validation
+     */
+    private validateOffline;
+    /**
+     * Generate offline activation challenge
+     */
+    generateChallenge(key: LicenseKey): Promise<OfflineChallenge>;
+    /**
+     * Apply offline activation response
+     */
+    applyOfflineResponse(response: OfflineResponse): LicenseValidationResult;
+    /**
+     * Check if feature is available
+     */
+    hasFeature(key: LicenseKey, feature: FeatureId): Promise<boolean>;
+    /**
+     * Activate machine for license
+     */
+    activateMachine(key: LicenseKey): Promise<LicenseValidationResult>;
+    /**
+     * Deactivate machine from license
+     */
+    deactivateMachine(key: LicenseKey): Promise<boolean>;
+    private getFromCache;
+    private setCache;
+    private clearCache;
+    private getStoredLicense;
+    private storeLicense;
+    private clearStoredLicense;
+    private loadCacheFromStorage;
+    private saveCacheToStorage;
+    private getMachineName;
+}
+
+/** Machine identifier */
+export declare type MachineId = string;
+
+/**
+ * Mask license key for display (show first and last segments)
+ */
+export declare function maskLicenseKey(key: LicenseKey): string;
+
+declare type MetricGranularity = 'hour' | 'day' | 'week' | 'month';
+
+export declare function nice2devLicenseRollupPlugin(options?: BuildLicenseConfig): any;
+
+export declare function nice2devLicenseVitePlugin(options?: Nice2DevLicenseVitePluginOptions): any;
+
+export declare interface Nice2DevLicenseVitePluginOptions extends BuildLicenseConfig {
+    featureGates?: LicenseFeatureGate[];
+}
+
+export declare class Nice2DevLicenseWebpackPlugin {
+    private validator;
+    private options;
+    private validated;
+    constructor(options?: Nice2DevLicenseWebpackPluginOptions);
+    apply(compiler: any): void;
+}
+
+export declare interface Nice2DevLicenseWebpackPluginOptions extends BuildLicenseConfig {
+    /** Feature gates to apply */
+    featureGates?: LicenseFeatureGate[];
+}
+
+/**
+ * Parse license key from various formats (with or without dashes)
+ */
+export declare function normalizeLicenseKey(input: string): LicenseKey | null;
+
+/** Offline activation challenge */
+export declare interface OfflineChallenge {
+    /** Challenge ID */
+    challengeId: string;
+    /** Challenge code (base64) */
+    challengeCode: string;
+    /** Hardware fingerprint */
+    fingerprint: HardwareFingerprint;
+    /** Expiration timestamp */
+    expiresAt: string;
+}
+
+/** Offline activation response */
+export declare interface OfflineResponse {
+    /** Challenge ID being responded to */
+    challengeId: string;
+    /** Response code (base64) */
+    responseCode: string;
+    /** License data (encrypted) */
+    licenseData: string;
+}
+
+export declare interface OverviewMetrics {
+    /** Total active licenses */
+    activeLicenses: number;
+    activeLicensesChange: number;
+    /** Total active users */
+    activeUsers: number;
+    activeUsersChange: number;
+    /** Total feature uses */
+    featureUses: number;
+    featureUsesChange: number;
+    /** Average session duration (minutes) */
+    avgSessionDuration: number;
+    avgSessionDurationChange: number;
+    /** License utilization rate */
+    utilizationRate: number;
+    utilizationRateChange: number;
+}
+
+export declare interface PaymentMethod {
+    id: string;
+    type: 'card' | 'bank_account' | 'paypal' | 'sepa_debit';
+    brand?: string;
+    last4: string;
+    expiryMonth?: number;
+    expiryYear?: number;
+    isDefault: boolean;
+}
+
+declare interface PaymentMethodInfo {
+    type: 'card' | 'bank_account' | 'paypal';
+    brand?: string;
+    last4?: string;
+    expiryMonth?: number;
+    expiryYear?: number;
+}
+
+export declare type PaymentProvider = 'stripe' | 'paddle' | 'paypal';
+
+export declare interface PricingPlan {
+    id: string;
+    name: string;
+    description: string;
+    tier: LicenseTier;
+    features: string[];
+    /** Monthly price in cents */
+    monthlyPrice: number;
+    /** Yearly price in cents (with discount) */
+    yearlyPrice: number;
+    /** One-time price in cents (perpetual) */
+    perpetualPrice?: number;
+    currency: string;
+    /** Seats included */
+    seatsIncluded: number;
+    /** Price per additional seat (monthly) */
+    seatPriceMonthly?: number;
+    /** Price per additional seat (yearly) */
+    seatPriceYearly?: number;
+    /** Trial days */
+    trialDays?: number;
+    /** Is highlighted/recommended */
+    recommended?: boolean;
+    /** Stripe price IDs */
+    stripePriceIds?: {
+        monthly?: string;
+        yearly?: string;
+        perpetual?: string;
+    };
+    /** Paddle product IDs */
+    paddleProductIds?: {
+        monthly?: string;
+        yearly?: string;
+        perpetual?: string;
+    };
+}
+
+declare interface ProratedAmount {
+    dueNow: number;
+    credit: number;
+    newRecurring: number;
+    effectiveDate: string;
+}
+
+/** Manifest entry describing a protected module */
+export declare interface ProtectedModuleEntry {
+    /** Module / component path (relative to package root) */
+    modulePath: string;
+    /** Minimum tier required to access source */
+    requiredTier: LicenseTier;
+    /** Required feature ID (if any) */
+    requiredFeature?: FeatureId;
+    /** Protection level */
+    accessLevel: SourceAccessLevel;
+    /** Human-readable name */
+    displayName: string;
+    /** Description of what the module provides */
+    description?: string;
+}
+
+/** Rate limit configuration keyed by tier */
+export declare type RateLimitConfig = Record<LicenseTier, TierRateLimit>;
+
+/**
+ * Token-bucket rate limiter.
+ * Refills tokens at a constant rate up to the max capacity.
+ */
+export declare class RateLimiter {
+    private tokens;
+    private lastRefill;
+    private config;
+    constructor(config: TierRateLimit);
+    /** Refill tokens based on elapsed time */
+    private refill;
+    /** Check and consume one request token */
+    consume(): RateLimitResult;
+    /** Reset the limiter (e.g. after tier change) */
+    reset(config?: TierRateLimit): void;
+    /** Peek at remaining tokens without consuming */
+    peek(): RateLimitResult;
+}
+
+/** Result of a rate limit check */
+export declare interface RateLimitResult {
+    /** Whether the request is allowed */
+    allowed: boolean;
+    /** Remaining requests in the current window */
+    remaining: number;
+    /** Time in ms until the next token is available (0 if allowed) */
+    retryAfterMs: number;
+    /** Total limit for the tier */
+    limit: number;
+}
+
+declare interface RefundAttachment {
+    id: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    uploadedAt: string;
+    url: string;
+}
+
+export declare interface RefundConfig {
+    apiBaseUrl: string;
+    authToken?: string;
+    policy: RefundPolicy;
+    /** Notification configuration */
+    notifications?: {
+        customerEmail: boolean;
+        adminEmail: boolean;
+        slackWebhook?: string;
+    };
+    /** Callback when refund is processed */
+    onRefundProcessed?: (request: RefundRequest) => void;
+    /** Callback when license is revoked */
+    onLicenseRevoked?: (record: RevocationRecord) => void;
+}
+
+declare interface RefundEligibility {
+    eligible: boolean;
+    reason?: string;
+    maxRefundAmount: number;
+    refundPercent: number;
+    withinPeriod: boolean;
+    daysRemaining: number;
+    previousRefunds: number;
+    requiresApproval: boolean;
+}
+
+export declare interface RefundPolicy {
+    /** Days after purchase when refund is allowed */
+    refundPeriodDays: number;
+    /** Tiers eligible for automatic refund */
+    autoApprovalTiers: LicenseTier[];
+    /** Max amount for auto-approval */
+    autoApprovalMaxAmount: number;
+    /** Max refunds per customer per year */
+    maxRefundsPerYear: number;
+    /** Requires reason to be provided */
+    requireReason: boolean;
+    /** Requires detailed explanation */
+    requireDetails: boolean;
+    /** Percentage refund after usage (0-100) */
+    usageBasedRefundPercent?: number;
+    /** Days where full refund applies */
+    fullRefundDays: number;
+    /** Partial refund after full refund period */
+    partialRefundPercent?: number;
+    /** Excluded tiers from refund */
+    excludedTiers?: LicenseTier[];
+    /** Custom rules per tier */
+    tierRules?: Record<LicenseTier, {
+        refundPeriodDays: number;
+        maxRefundPercent: number;
+    }>;
+}
+
+export declare type RefundReason = 'product_not_as_described' | 'technical_issues' | 'accidental_purchase' | 'no_longer_needed' | 'found_alternative' | 'pricing_concerns' | 'customer_service' | 'other';
+
+export declare interface RefundRequest {
+    id: string;
+    customerId: string;
+    customerEmail: string;
+    customerName: string;
+    licenseKey: LicenseKey;
+    license: LicenseInfo;
+    orderId: string;
+    invoiceId?: string;
+    amount: number;
+    currency: string;
+    reason: RefundReason;
+    reasonDetails?: string;
+    status: RefundStatus;
+    createdAt: string;
+    updatedAt: string;
+    processedAt?: string;
+    processedBy?: string;
+    refundMethod: 'original_payment' | 'store_credit' | 'manual';
+    refundTransactionId?: string;
+    rejectionReason?: string;
+    notes?: string;
+    attachments?: RefundAttachment[];
+    autoApproved: boolean;
+    withinRefundPeriod: boolean;
+    daysFromPurchase: number;
+}
+
+export declare class RefundService {
+    private config;
+    constructor(config: RefundConfig);
+    private request;
+    /** Check if license is eligible for refund */
+    checkEligibility(licenseKey: LicenseKey): Promise<RefundEligibility>;
+    /** Calculate refund amount */
+    calculateRefundAmount(originalAmount: number, daysSincePurchase: number): {
+        amount: number;
+        percent: number;
+    };
+    /** Create refund request */
+    createRefundRequest(data: {
+        licenseKey: LicenseKey;
+        reason: RefundReason;
+        reasonDetails?: string;
+        preferredMethod?: RefundRequest['refundMethod'];
+    }): Promise<RefundRequest>;
+    /** Get refund request by ID */
+    getRefundRequest(requestId: string): Promise<RefundRequest>;
+    /** Get refund requests for customer */
+    getCustomerRefundRequests(customerId?: string): Promise<RefundRequest[]>;
+    /** Get pending refund requests (admin) */
+    getPendingRequests(limit?: number, offset?: number): Promise<{
+        requests: RefundRequest[];
+        total: number;
+    }>;
+    /** Cancel refund request (customer) */
+    cancelRefundRequest(requestId: string): Promise<RefundRequest>;
+    /** Add attachment to refund request */
+    addAttachment(requestId: string, file: File): Promise<RefundAttachment>;
+    /** Approve refund request (admin) */
+    approveRefund(requestId: string, options?: {
+        adjustedAmount?: number;
+        notes?: string;
+        refundMethod?: RefundRequest['refundMethod'];
+    }): Promise<RefundRequest>;
+    /** Reject refund request (admin) */
+    rejectRefund(requestId: string, reason: string): Promise<RefundRequest>;
+    /** Process refund (trigger payment refund) */
+    processRefund(requestId: string): Promise<RefundRequest>;
+    /** Revoke license */
+    revokeLicense(licenseKey: LicenseKey, reason: RevocationReason, options?: {
+        reasonDetails?: string;
+        permanent?: boolean;
+        notifyCustomer?: boolean;
+        refundRequestId?: string;
+    }): Promise<RevocationRecord>;
+    /** Get revocation history */
+    getRevocationHistory(licenseKey?: LicenseKey): Promise<RevocationRecord[]>;
+    /** Reactivate revoked license (if allowed) */
+    reactivateLicense(revocationId: string, reason: string): Promise<{
+        success: boolean;
+        license?: LicenseInfo;
+    }>;
+    /** Get refund statistics */
+    getRefundStats(startDate: string, endDate: string): Promise<{
+        totalRequests: number;
+        totalRefunded: number;
+        totalRejected: number;
+        totalAmount: number;
+        averageAmount: number;
+        byReason: Record<RefundReason, number>;
+        byStatus: Record<RefundStatus, number>;
+        averageProcessingTime: number;
+        autoApprovalRate: number;
+    }>;
+}
+
+export declare type RefundStatus = 'pending' | 'approved' | 'rejected' | 'processing' | 'completed' | 'failed' | 'cancelled';
+
+/**
+ * Register a feature definition
+ */
+export declare function registerFeature(feature: FeatureDefinition): void;
+
+/**
+ * Register multiple features
+ */
+export declare function registerFeatures(features: FeatureDefinition[]): void;
+
+/**
+ * Register a license plan
+ */
+export declare function registerPlan(plan: LicensePlan): void;
+
+/**
+ * Register multiple plans
+ */
+export declare function registerPlans(plans: LicensePlan[]): void;
+
+/** Register a module as protected */
+export declare function registerProtectedModule(entry: ProtectedModuleEntry): void;
+
+/** Register multiple protected modules */
+export declare function registerProtectedModules(entries: ProtectedModuleEntry[]): void;
+
+declare type RevocationReason = 'refund' | 'chargeback' | 'fraud' | 'violation' | 'breach_of_terms' | 'payment_failure' | 'admin_action' | 'license_transfer';
+
+export declare interface RevocationRecord {
+    id: string;
+    licenseKey: LicenseKey;
+    license: LicenseInfo;
+    reason: RevocationReason;
+    reasonDetails?: string;
+    revokedAt: string;
+    revokedBy: string;
+    refundRequestId?: string;
+    permanent: boolean;
+    reactivatable: boolean;
+    previousStatus: string;
+    affectedSeats: number;
+    affectedMachines: string[];
+    notificationsSent: boolean;
+}
+
+export declare function runCILicenseCheck(options?: CILicenseCheckOptions): Promise<CILicenseCheckResult>;
+
+/** Seat information */
+export declare interface SeatInfo {
+    /** Seat ID */
+    seatId: string;
+    /** User identifier */
+    userId: string;
+    /** User display name */
+    displayName: string;
+    /** User email */
+    email: string;
+    /** Machine ID where active */
+    machineId?: MachineId;
+    /** Last activity timestamp */
+    lastActivity: string;
+    /** Is currently active */
+    isActive: boolean;
+    /** Activation timestamp */
+    activatedAt: string;
+}
+
+/**
+ * Seat Manager for tracking license usage
+ */
+export declare class SeatManager {
+    private serverUrl;
+    private apiKey?;
+    private heartbeatInterval?;
+    private currentSeat?;
+    constructor(serverUrl: string, apiKey?: string);
+    /**
+     * Acquire a seat for the current user
+     */
+    acquireSeat(licenseKey: LicenseKey, userId: string, displayName: string, email: string): Promise<{
+        success: boolean;
+        seat?: SeatInfo;
+        error?: string;
+    }>;
+    /**
+     * Release current seat
+     */
+    releaseSeat(licenseKey: LicenseKey): Promise<boolean>;
+    /**
+     * Get all active seats for a license
+     */
+    getActiveSeats(licenseKey: LicenseKey): Promise<SeatInfo[]>;
+    /**
+     * Force release a seat (admin function)
+     */
+    forceReleaseSeat(licenseKey: LicenseKey, seatId: string): Promise<boolean>;
+    /**
+     * Check if seat limit is reached
+     */
+    canAcquireSeat(license: LicenseInfo): Promise<boolean>;
+    /**
+     * Start heartbeat to keep seat active
+     */
+    private startHeartbeat;
+    /**
+     * Stop heartbeat
+     */
+    private stopHeartbeat;
+    /**
+     * Get current seat info
+     */
+    getCurrentSeat(): SeatInfo | undefined;
+    /**
+     * Cleanup on unmount/close
+     */
+    cleanup(licenseKey: LicenseKey): Promise<void>;
+}
+
+/** SLA event record (uptime check, support ticket, etc.) */
+export declare interface SlaEvent {
+    /** Event ID */
+    id: string;
+    /** Event type */
+    type: 'uptime-check' | 'downtime-start' | 'downtime-end' | 'ticket-opened' | 'ticket-resolved';
+    /** ISO timestamp */
+    timestamp: string;
+    /** Duration in ms (for downtime or resolution) */
+    durationMs?: number;
+    /** Associated metadata */
+    metadata?: Record<string, unknown>;
+}
+
+/** SLA compliance report */
+export declare interface SlaReport {
+    /** Reporting period start (ISO) */
+    periodStart: string;
+    /** Reporting period end (ISO) */
+    periodEnd: string;
+    /** License tier */
+    tier: LicenseTier;
+    /** SLA config for this tier */
+    slaConfig: SlaTierConfig;
+    /** Actual uptime percentage */
+    actualUptimePercent: number;
+    /** Total downtime in ms */
+    totalDowntimeMs: number;
+    /** Average support response time (hours) */
+    avgResponseHours: number;
+    /** Average resolution time (hours) */
+    avgResolutionHours: number;
+    /** Number of SLA breaches */
+    breachCount: number;
+    /** Is SLA compliant */
+    compliant: boolean;
+    /** Credit owed (if breached) */
+    creditPercent: number;
+}
+
+/** SLA configuration for a single tier */
+export declare interface SlaTierConfig {
+    /** Guaranteed uptime percentage (e.g. 99.9) */
+    uptimePercent: number;
+    /** Maximum response time for support (hours) */
+    supportResponseHours: number;
+    /** Maximum resolution time (hours) */
+    supportResolutionHours: number;
+    /** Support channels available */
+    supportChannels: SupportChannel[];
+    /** Priority level (1 = highest) */
+    priority: number;
+    /** Included support hours per month (null = unlimited) */
+    includedHours: number | null;
+    /** Penalty per SLA breach (as percentage credit) */
+    breachPenaltyPercent: number;
+}
+
+/**
+ * SLA Tracker — Monitors and reports SLA compliance
+ */
+export declare class SlaTracker {
+    private events;
+    private tier;
+    private config;
+    constructor(tier: LicenseTier, config?: Record<LicenseTier, SlaTierConfig>);
+    /** Update the license tier */
+    setTier(tier: LicenseTier): void;
+    /** Get the SLA config for the current tier */
+    getSlaConfig(): SlaTierConfig;
+    /** Record an event */
+    recordEvent(event: SlaEvent): void;
+    /** Record an uptime check */
+    recordUptimeCheck(): void;
+    /** Record downtime */
+    recordDowntime(durationMs: number): void;
+    /** Record a support ticket lifecycle */
+    recordTicket(responseTimeHours: number, resolutionTimeHours: number): void;
+    /** Generate an SLA report for a given period */
+    generateReport(periodStart: Date, periodEnd: Date): SlaReport;
+    /** Get all recorded events */
+    getEvents(): SlaEvent[];
+    /** Clear all events */
+    clearEvents(): void;
+}
+
+/** Access level for a protected component / module */
+export declare type SourceAccessLevel = 'open' | 'obfuscated' | 'encrypted' | 'server-only';
+
+/**
+ * Store fingerprint in local storage
+ */
+export declare function storeFingerprint(fingerprint: HardwareFingerprint): void;
+
+export declare interface Subscription {
+    id: string;
+    customerId: string;
+    status: SubscriptionStatus;
+    plan: PricingPlan;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+    canceledAt?: string;
+    trialStart?: string;
+    trialEnd?: string;
+    seats: number;
+    amount: number;
+    currency: string;
+    interval: BillingInterval;
+    provider: PaymentProvider;
+    providerSubscriptionId: string;
+    licenseKeys: LicenseKey[];
+    paymentMethod?: PaymentMethod;
+    latestInvoice?: Invoice;
+}
+
+declare interface SubscriptionInfo {
+    id: string;
+    status: 'active' | 'past_due' | 'canceled' | 'trialing' | 'paused';
+    plan: string;
+    tier: LicenseTier;
+    pricePerMonth: number;
+    pricePerYear: number;
+    currency: string;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+    seats: number;
+    paymentMethod?: PaymentMethodInfo;
+}
+
+declare type SubscriptionStatus = 'active' | 'past_due' | 'unpaid' | 'canceled' | 'incomplete' | 'trialing' | 'paused';
+
+/** Available support channels */
+export declare type SupportChannel = 'email' | 'chat' | 'phone' | 'dedicated-manager' | 'on-site';
+
+/** License telemetry event (opt-in) */
+export declare interface TelemetryEvent {
+    /** Event type */
+    type: 'activation' | 'deactivation' | 'feature_use' | 'validation' | 'error';
+    /** License key (hashed) */
+    licenseKeyHash: string;
+    /** Timestamp */
+    timestamp: string;
+    /** Event data */
+    data?: Record<string, unknown>;
+}
+
+/**
+ * Check if tier meets minimum requirement
+ */
+export declare function tierMeetsRequirement(userTier: LicenseTier, requiredTier: LicenseTier): boolean;
+
+/** Rate limit configuration for a single tier */
+export declare interface TierRateLimit {
+    /** Maximum requests in the window */
+    maxRequests: number;
+    /** Window duration in ms */
+    windowMs: number;
+    /** Burst allowance (extra requests beyond max, refills over time) */
+    burst?: number;
+}
+
+declare type TimeRange = '24h' | '7d' | '30d' | '90d' | '1y' | 'all';
+
+declare interface TimeSeriesDataPoint {
+    timestamp: string;
+    value: number;
+    label?: string;
+}
+
+export declare interface TransferConfig {
+    apiBaseUrl: string;
+    authToken?: string;
+    /** Require admin approval for transfers */
+    requireApproval?: boolean;
+    /** Days before pending transfer expires */
+    expirationDays?: number;
+    /** Allow transfers to external organizations */
+    allowExternalTransfers?: boolean;
+    /** Notification settings */
+    notifications?: {
+        email: boolean;
+        inApp: boolean;
+        slack?: string;
+    };
+    onTransferComplete?: (transfer: TransferRequest) => void;
+    onError?: (error: TransferError) => void;
+}
+
+declare interface TransferError {
+    code: string;
+    message: string;
+}
+
+declare interface TransferFormData {
+    licenseKey: string;
+    recipientEmail: string;
+    recipientName: string;
+    notes: string;
+    transferReason: 'employee_change' | 'department_transfer' | 'organization_sale' | 'other';
+    confirmDeactivation: boolean;
+}
+
+declare interface TransferNotification {
+    type: 'initiated' | 'pending_approval' | 'approved' | 'rejected' | 'completed' | 'reminder';
+    sentAt: string;
+    recipient: string;
+    delivered: boolean;
+}
+
+declare interface TransferParty {
+    id: string;
+    name: string;
+    email: string;
+    organizationId?: string;
+    organizationName?: string;
+}
+
+export declare interface TransferRequest {
+    id: string;
+    licenseKey: LicenseKey;
+    license: LicenseInfo;
+    fromOrganization: TransferParty;
+    toOrganization: TransferParty;
+    status: TransferStatus;
+    createdAt: string;
+    updatedAt: string;
+    expiresAt: string;
+    notes?: string;
+    approvalRequired: boolean;
+    approvedBy?: string;
+    approvedAt?: string;
+    rejectionReason?: string;
+    transferToken?: string;
+    notificationsSent: TransferNotification[];
+}
+
+export declare type TransferStatus = 'pending' | 'pending_approval' | 'approved' | 'rejected' | 'completed' | 'cancelled' | 'expired';
+
+/** Transfer Status Badge */
+export declare const TransferStatusBadge: default_2.FC<{
+    status: TransferStatus;
+}>;
+
+declare type TransferStep = 'select-license' | 'enter-recipient' | 'review' | 'confirmation' | 'processing' | 'complete';
+
+declare interface TrendData {
+    metric: string;
+    current: number;
+    previous: number;
+    change: number;
+    changePercent: number;
+    trend: 'up' | 'down' | 'stable';
+}
+
+/** Main Dashboard Component */
+export declare const UsageAnalyticsDashboard: default_2.FC<UsageAnalyticsDashboardProps>;
+
+declare interface UsageAnalyticsDashboardProps extends AnalyticsConfig {
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare class UsageAnalyticsService {
+    private config;
+    constructor(config: AnalyticsConfig);
+    private request;
+    private getTimeParams;
+    /** Get overview metrics */
+    getOverview(range?: TimeRange): Promise<OverviewMetrics>;
+    /** Get license activity over time */
+    getLicenseActivity(range?: TimeRange, granularity?: MetricGranularity): Promise<TimeSeriesDataPoint[]>;
+    /** Get user activity over time */
+    getUserActivity(range?: TimeRange, granularity?: MetricGranularity): Promise<TimeSeriesDataPoint[]>;
+    /** Get feature usage data */
+    getFeatureUsage(range?: TimeRange, features?: FeatureId[]): Promise<FeatureUsageData[]>;
+    /** Get top users by activity */
+    getTopUsers(range?: TimeRange, limit?: number): Promise<UserActivityData[]>;
+    /** Get license utilization */
+    getLicenseUtilization(): Promise<LicenseUtilizationData[]>;
+    /** Get geographic distribution */
+    getGeographicData(range?: TimeRange): Promise<GeographicData[]>;
+    /** Get trends for key metrics */
+    getTrends(range?: TimeRange): Promise<TrendData[]>;
+    /** Get retention cohorts */
+    getRetentionCohorts(months?: number): Promise<CohortData[]>;
+    /** Export analytics data */
+    exportData(range: TimeRange, format: 'csv' | 'json' | 'xlsx'): Promise<Blob>;
+}
+
+declare interface UsageRecord {
+    subscriptionId: string;
+    metricId: string;
+    quantity: number;
+    recordedAt: string;
+}
+
+/**
+ * Usage Telemetry Service
+ */
+export declare class UsageTelemetry {
+    private config;
+    private queue;
+    private flushTimer;
+    private _active;
+    constructor(config: UsageTelemetryConfig);
+    /** Start collecting telemetry (no-op if disabled or DNT) */
+    start(): void;
+    /** Stop collecting and flush remaining events */
+    stop(): Promise<void>;
+    /** Track a telemetry event */
+    track(type: TelemetryEvent['type'], data?: Record<string, unknown>): void;
+    /** Track feature usage */
+    trackFeatureUse(featureId: string): void;
+    /** Track activation event */
+    trackActivation(): void;
+    /** Track deactivation event */
+    trackDeactivation(): void;
+    /** Track validation event */
+    trackValidation(valid: boolean): void;
+    /** Track error event */
+    trackError(errorCode: string): void;
+    /** Get queued event count */
+    get queueSize(): number;
+    /** Check if telemetry is active */
+    get active(): boolean;
+    /** Flush queued events to server */
+    flush(): Promise<void>;
+    /** Enable telemetry (opt-in) */
+    enable(): void;
+    /** Disable telemetry (opt-out) */
+    disable(): void;
+    /** Check if telemetry is allowed */
+    private isAllowed;
+}
+
+/** Telemetry configuration */
+export declare interface UsageTelemetryConfig {
+    /** Endpoint URL for sending telemetry */
+    endpoint: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** Hashed license key (never store raw key) */
+    licenseKeyHash: string;
+    /** Whether telemetry is enabled (default: false — opt-in) */
+    enabled?: boolean;
+    /** Batch size — events are sent when batch reaches this size (default: 20) */
+    batchSize?: number;
+    /** Flush interval in ms (default: 60000 — 1 minute) */
+    flushInterval?: number;
+    /** Max queue size — oldest events are dropped when exceeded (default: 500) */
+    maxQueueSize?: number;
+    /** Respect browser Do-Not-Track header (default: true) */
+    respectDNT?: boolean;
+}
+
+export declare function useActivationWizard(config: ActivationWizardConfig): {
+    state: ActivationState;
+    setLicenseKey: (key: string) => void;
+    setMachineName: (name: string) => void;
+    setTermsAccepted: (accepted: boolean) => void;
+    validateKey: () => Promise<void>;
+    acceptTermsAndActivate: () => Promise<void>;
+    startOfflineActivation: () => Promise<void>;
+    submitOfflineResponse: (response: string) => Promise<void>;
+    reset: () => void;
+    goBack: () => void;
+};
+
+export declare function useLicensePortal(config: LicensePortalConfig): {
+    state: LicensePortalState;
+    service: LicensePortalService;
+    loadData: () => Promise<void>;
+    activateLicense: (licenseKey: LicenseKey, machineId: string, machineName?: string) => Promise<LicenseInfo>;
+    deactivateLicense: (licenseKey: LicenseKey, machineId: string) => Promise<void>;
+    transferLicense: (licenseKey: LicenseKey, targetEmail: string, notes?: string) => Promise<{
+        transferId: string;
+        status: string;
+    }>;
+    selectLicense: (license: LicenseInfo | null) => void;
+    setActiveTab: (tab: LicensePortalState["activeTab"]) => void;
+};
+
+export declare function useLicenseTransfer(config: TransferConfig): {
+    step: TransferStep;
+    setStep: default_2.Dispatch<default_2.SetStateAction<TransferStep>>;
+    licenses: LicenseInfo[];
+    formData: TransferFormData;
+    setFormData: default_2.Dispatch<default_2.SetStateAction<TransferFormData>>;
+    selectedLicense: LicenseInfo | null;
+    recipientValidation: {
+        valid: boolean;
+        isExternal: boolean;
+        warnings?: string[];
+    } | null;
+    transfer: TransferRequest | null;
+    loading: boolean;
+    error: TransferError | null;
+    loadLicenses: () => Promise<void>;
+    selectLicense: (license: LicenseInfo) => void;
+    validateRecipient: () => Promise<void>;
+    proceedToReview: () => void;
+    initiateTransfer: () => Promise<void>;
+    reset: () => void;
+};
+
+export declare interface UserActivityData {
+    userId: string;
+    email: string;
+    displayName?: string;
+    licenseKey: string;
+    tier: LicenseTier;
+    lastActive: string;
+    sessionCount: number;
+    totalDuration: number;
+    featuresUsed: number;
+    topFeatures: {
+        featureId: string;
+        uses: number;
+    }[];
+}
+
+export declare function useUsageAnalytics(config: AnalyticsConfig): {
+    state: AnalyticsState;
+    setTimeRange: (range: TimeRange) => void;
+    refresh: (range?: TimeRange) => Promise<void>;
+    exportData: (format: "csv" | "json" | "xlsx") => Promise<void>;
+};
+
+/**
+ * Validate license key format and checksum
+ */
+export declare function validateKeyFormat(key: LicenseKey): boolean;
+
+/**
+ * Validate license key (convenience function)
+ */
+export declare function validateLicense(key: LicenseKey): Promise<LicenseValidationResult>;
+
+export declare const VERSION = "1.1.0";
+
+/** White-label brand configuration */
+export declare interface WhiteLabelConfig {
+    /** Custom product name */
+    productName?: string;
+    /** Logo URL (light theme) */
+    logoUrl?: string;
+    /** Logo URL (dark theme) */
+    logoDarkUrl?: string;
+    /** Favicon URL */
+    faviconUrl?: string;
+    /** Primary brand color (hex) */
+    primaryColor?: string;
+    /** Secondary brand color (hex) */
+    secondaryColor?: string;
+    /** Accent color (hex) */
+    accentColor?: string;
+    /** Custom CSS to inject */
+    customCss?: string;
+    /** Custom footer text */
+    footerText?: string;
+    /** Hide "Powered by Nice2Dev" badge */
+    hidePoweredBy?: boolean;
+    /** Custom domain for white-labeled deployment */
+    customDomain?: string;
+    /** Custom email sender domain */
+    emailDomain?: string;
+}
+
+/**
+ * White-label manager — applies brand overrides based on license tier
+ */
+export declare class WhiteLabelManager {
+    private config;
+    private currentTier;
+    /** Set the active license tier */
+    setTier(tier: LicenseTier): void;
+    /** Update white-label configuration (only applicable fields per tier are kept) */
+    setConfig(config: WhiteLabelConfig): void;
+    /** Get the resolved configuration (filtered by tier permissions) */
+    getResolvedConfig(): Partial<WhiteLabelConfig>;
+    /** Check if a specific white-label feature is allowed */
+    isFeatureAllowed(feature: keyof WhiteLabelConfig): boolean;
+    /** Get list of features not available at current tier */
+    getLockedFeatures(): (keyof WhiteLabelConfig)[];
+    /** Get list of features available at current tier */
+    getUnlockedFeatures(): (keyof WhiteLabelConfig)[];
+    /** Generate CSS custom properties from the resolved config */
+    generateCssVariables(): string;
+    /** Apply the brand configuration to the document */
+    applyToDocument(): void;
+}
+
+export { }