@nice2dev/licensing 1.0.10

package/dist/index.mjs

@@ -0,0 +1,4353 @@
+import { g as generateMachineId, a as generateFingerprint, v as validateKeyFormat$1, e as extractKeyMetadata, t as tierMeetsRequirement } from "./FeatureGate-Da7fCJA5.js";
+import { L, c, b, d, f, h, i, j, k, l, m, n, o, p, q, r, s, u, w, x, y, z, A, B, C, D, E, F, G, H, I, J } from "./FeatureGate-Da7fCJA5.js";
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import React, { useState, useCallback, useEffect, useMemo } from "react";
+const HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
+class SeatManager {
+  constructor(serverUrl, apiKey) {
+    this.serverUrl = serverUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Acquire a seat for the current user
+   */
+  async acquireSeat(licenseKey, userId, displayName, email) {
+    const machineId = await generateMachineId();
+    try {
+      const response = await fetch(`${this.serverUrl}/seats/acquire`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { "X-API-Key": this.apiKey } : {}
+        },
+        body: JSON.stringify({
+          licenseKey,
+          userId,
+          displayName,
+          email,
+          machineId
+        })
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || "Failed to acquire seat"
+        };
+      }
+      this.currentSeat = data.seat;
+      this.startHeartbeat(licenseKey);
+      return {
+        success: true,
+        seat: data.seat
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: "Network error"
+      };
+    }
+  }
+  /**
+   * Release current seat
+   */
+  async releaseSeat(licenseKey) {
+    if (!this.currentSeat) {
+      return true;
+    }
+    this.stopHeartbeat();
+    try {
+      const response = await fetch(`${this.serverUrl}/seats/release`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { "X-API-Key": this.apiKey } : {}
+        },
+        body: JSON.stringify({
+          licenseKey,
+          seatId: this.currentSeat.seatId
+        })
+      });
+      if (response.ok) {
+        this.currentSeat = void 0;
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get all active seats for a license
+   */
+  async getActiveSeats(licenseKey) {
+    try {
+      const response = await fetch(
+        `${this.serverUrl}/seats/list?licenseKey=${encodeURIComponent(licenseKey)}`,
+        {
+          headers: {
+            ...this.apiKey ? { "X-API-Key": this.apiKey } : {}
+          }
+        }
+      );
+      if (!response.ok) {
+        return [];
+      }
+      const data = await response.json();
+      return data.seats || [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Force release a seat (admin function)
+   */
+  async forceReleaseSeat(licenseKey, seatId) {
+    try {
+      const response = await fetch(`${this.serverUrl}/seats/force-release`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { "X-API-Key": this.apiKey } : {}
+        },
+        body: JSON.stringify({
+          licenseKey,
+          seatId
+        })
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if seat limit is reached
+   */
+  async canAcquireSeat(license) {
+    if (license.maxSeats === null) {
+      return true;
+    }
+    const activeSeats = await this.getActiveSeats(license.key);
+    return activeSeats.length < license.maxSeats;
+  }
+  /**
+   * Start heartbeat to keep seat active
+   */
+  startHeartbeat(licenseKey) {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(async () => {
+      if (!this.currentSeat) {
+        this.stopHeartbeat();
+        return;
+      }
+      try {
+        await fetch(`${this.serverUrl}/seats/heartbeat`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.apiKey ? { "X-API-Key": this.apiKey } : {}
+          },
+          body: JSON.stringify({
+            licenseKey,
+            seatId: this.currentSeat.seatId
+          })
+        });
+      } catch {
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  /**
+   * Stop heartbeat
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = void 0;
+    }
+  }
+  /**
+   * Get current seat info
+   */
+  getCurrentSeat() {
+    return this.currentSeat;
+  }
+  /**
+   * Cleanup on unmount/close
+   */
+  async cleanup(licenseKey) {
+    await this.releaseSeat(licenseKey);
+  }
+}
+class FloatingLicenseManager {
+  constructor(serverUrl, apiKey) {
+    this.serverUrl = serverUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Acquire a floating license
+   */
+  async acquireLease(licenseKey) {
+    const machineId = await generateMachineId();
+    try {
+      const response = await fetch(`${this.serverUrl}/floating/acquire`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { "X-API-Key": this.apiKey } : {}
+        },
+        body: JSON.stringify({
+          licenseKey,
+          machineId
+        })
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || "No floating licenses available"
+        };
+      }
+      this.leaseId = data.leaseId;
+      this.startLeaseRenewal(licenseKey);
+      return {
+        success: true,
+        leaseId: data.leaseId,
+        expiresAt: data.expiresAt
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: "Network error"
+      };
+    }
+  }
+  /**
+   * Release floating license
+   */
+  async releaseLease(licenseKey) {
+    if (!this.leaseId) {
+      return true;
+    }
+    this.stopLeaseRenewal();
+    try {
+      const response = await fetch(`${this.serverUrl}/floating/release`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { "X-API-Key": this.apiKey } : {}
+        },
+        body: JSON.stringify({
+          licenseKey,
+          leaseId: this.leaseId
+        })
+      });
+      if (response.ok) {
+        this.leaseId = void 0;
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get floating license status
+   */
+  async getFloatingStatus(licenseKey) {
+    try {
+      const response = await fetch(
+        `${this.serverUrl}/floating/status?licenseKey=${encodeURIComponent(licenseKey)}`,
+        {
+          headers: {
+            ...this.apiKey ? { "X-API-Key": this.apiKey } : {}
+          }
+        }
+      );
+      if (!response.ok) {
+        return { total: 0, available: 0, leases: [] };
+      }
+      return response.json();
+    } catch {
+      return { total: 0, available: 0, leases: [] };
+    }
+  }
+  /**
+   * Start lease renewal interval
+   */
+  startLeaseRenewal(licenseKey) {
+    this.stopLeaseRenewal();
+    this.renewInterval = setInterval(
+      async () => {
+        if (!this.leaseId) {
+          this.stopLeaseRenewal();
+          return;
+        }
+        try {
+          const response = await fetch(`${this.serverUrl}/floating/renew`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...this.apiKey ? { "X-API-Key": this.apiKey } : {}
+            },
+            body: JSON.stringify({
+              licenseKey,
+              leaseId: this.leaseId
+            })
+          });
+          if (!response.ok) {
+            this.leaseId = void 0;
+            this.stopLeaseRenewal();
+          }
+        } catch {
+        }
+      },
+      2 * 60 * 1e3
+    );
+  }
+  /**
+   * Stop lease renewal
+   */
+  stopLeaseRenewal() {
+    if (this.renewInterval) {
+      clearInterval(this.renewInterval);
+      this.renewInterval = void 0;
+    }
+  }
+  /**
+   * Check if we have an active lease
+   */
+  hasActiveLease() {
+    return !!this.leaseId;
+  }
+  /**
+   * Cleanup
+   */
+  async cleanup(licenseKey) {
+    await this.releaseLease(licenseKey);
+  }
+}
+function createSeatManager(serverUrl, apiKey) {
+  return new SeatManager(serverUrl, apiKey);
+}
+function createFloatingLicenseManager(serverUrl, apiKey) {
+  return new FloatingLicenseManager(serverUrl, apiKey);
+}
+function fnv1a(str) {
+  let hash = 2166136261;
+  for (let i2 = 0; i2 < str.length; i2++) {
+    hash ^= str.charCodeAt(i2);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function hashLicenseKey(key) {
+  return fnv1a(key) + fnv1a(key + "nice2dev-salt");
+}
+class UsageTelemetry {
+  constructor(config) {
+    this.queue = [];
+    this.flushTimer = null;
+    this._active = false;
+    this.config = {
+      enabled: false,
+      batchSize: 20,
+      flushInterval: 6e4,
+      maxQueueSize: 500,
+      respectDNT: true,
+      apiKey: "",
+      ...config
+    };
+  }
+  /** Start collecting telemetry (no-op if disabled or DNT) */
+  start() {
+    if (!this.isAllowed()) {
+      return;
+    }
+    if (this._active) {
+      return;
+    }
+    this._active = true;
+    this.flushTimer = setInterval(() => this.flush(), this.config.flushInterval);
+  }
+  /** Stop collecting and flush remaining events */
+  async stop() {
+    if (!this._active) {
+      return;
+    }
+    this._active = false;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  /** Track a telemetry event */
+  track(type, data) {
+    if (!this._active) {
+      return;
+    }
+    const event = {
+      type,
+      licenseKeyHash: this.config.licenseKeyHash,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+    this.queue.push(event);
+    if (this.queue.length > this.config.maxQueueSize) {
+      this.queue = this.queue.slice(-this.config.maxQueueSize);
+    }
+    if (this.queue.length >= this.config.batchSize) {
+      this.flush();
+    }
+  }
+  /** Track feature usage */
+  trackFeatureUse(featureId) {
+    this.track("feature_use", { featureId });
+  }
+  /** Track activation event */
+  trackActivation() {
+    this.track("activation");
+  }
+  /** Track deactivation event */
+  trackDeactivation() {
+    this.track("deactivation");
+  }
+  /** Track validation event */
+  trackValidation(valid) {
+    this.track("validation", { valid });
+  }
+  /** Track error event */
+  trackError(errorCode) {
+    this.track("error", { errorCode });
+  }
+  /** Get queued event count */
+  get queueSize() {
+    return this.queue.length;
+  }
+  /** Check if telemetry is active */
+  get active() {
+    return this._active;
+  }
+  /** Flush queued events to server */
+  async flush() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    const batch = this.queue.splice(0, this.config.batchSize);
+    try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.config.apiKey) {
+        headers["X-API-Key"] = this.config.apiKey;
+      }
+      const response = await fetch(this.config.endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ events: batch })
+      });
+      if (!response.ok) {
+        this.queue.unshift(...batch);
+      }
+    } catch {
+      this.queue.unshift(...batch);
+    }
+  }
+  /** Enable telemetry (opt-in) */
+  enable() {
+    this.config.enabled = true;
+    this.start();
+  }
+  /** Disable telemetry (opt-out) */
+  disable() {
+    this.config.enabled = false;
+    this.stop();
+  }
+  /** Check if telemetry is allowed */
+  isAllowed() {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (this.config.respectDNT && typeof navigator !== "undefined" && navigator.doNotTrack === "1") {
+      return false;
+    }
+    return true;
+  }
+}
+function createTelemetry(config) {
+  return new UsageTelemetry(config);
+}
+const protectedModules = /* @__PURE__ */ new Map();
+function registerProtectedModule(entry) {
+  protectedModules.set(entry.modulePath, entry);
+}
+function registerProtectedModules(entries) {
+  entries.forEach(registerProtectedModule);
+}
+function getAllProtectedModules() {
+  return Array.from(protectedModules.values());
+}
+function getProtectedModule(modulePath) {
+  return protectedModules.get(modulePath);
+}
+function isModuleAccessible(modulePath, currentTier) {
+  const entry = protectedModules.get(modulePath);
+  if (!entry) {
+    return true;
+  }
+  const tierRank2 = {
+    trial: 0,
+    personal: 1,
+    team: 2,
+    enterprise: 3,
+    site: 4,
+    oem: 5
+  };
+  return tierRank2[currentTier] >= tierRank2[entry.requiredTier];
+}
+function getInaccessibleModules(currentTier) {
+  return getAllProtectedModules().filter((m2) => !isModuleAccessible(m2.modulePath, currentTier));
+}
+function getAccessibleModules(currentTier) {
+  return getAllProtectedModules().filter((m2) => isModuleAccessible(m2.modulePath, currentTier));
+}
+function generateBundleTags() {
+  const byTier = /* @__PURE__ */ new Map();
+  for (const entry of protectedModules.values()) {
+    const key = `${entry.requiredTier}:${entry.accessLevel}`;
+    const group = byTier.get(key) ?? [];
+    group.push(entry);
+    byTier.set(key, group);
+  }
+  return Array.from(byTier.entries()).map(([key, entries]) => {
+    const [requiredTier, accessLevel] = key.split(":");
+    return {
+      chunkId: `protected-${requiredTier}-${accessLevel}`,
+      requiredTier,
+      accessLevel,
+      modules: entries.map((e) => e.modulePath)
+    };
+  });
+}
+function generateProtectionManifest() {
+  return {
+    version: "1.0.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    modules: getAllProtectedModules(),
+    bundleTags: generateBundleTags()
+  };
+}
+const DEFAULT_RATE_LIMITS = {
+  trial: { maxRequests: 30, windowMs: 6e4, burst: 5 },
+  personal: { maxRequests: 120, windowMs: 6e4, burst: 20 },
+  team: { maxRequests: 600, windowMs: 6e4, burst: 100 },
+  enterprise: { maxRequests: 3e3, windowMs: 6e4, burst: 500 },
+  site: { maxRequests: 1e4, windowMs: 6e4, burst: 2e3 },
+  oem: { maxRequests: 5e4, windowMs: 6e4, burst: 1e4 }
+};
+class RateLimiter {
+  constructor(config) {
+    this.config = config;
+    this.tokens = config.maxRequests + (config.burst ?? 0);
+    this.lastRefill = Date.now();
+  }
+  /** Refill tokens based on elapsed time */
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    const maxTokens = this.config.maxRequests + (this.config.burst ?? 0);
+    const refillRate = this.config.maxRequests / this.config.windowMs;
+    const newTokens = elapsed * refillRate;
+    this.tokens = Math.min(maxTokens, this.tokens + newTokens);
+    this.lastRefill = now;
+  }
+  /** Check and consume one request token */
+  consume() {
+    this.refill();
+    const maxTokens = this.config.maxRequests + (this.config.burst ?? 0);
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return {
+        allowed: true,
+        remaining: Math.floor(this.tokens),
+        retryAfterMs: 0,
+        limit: maxTokens
+      };
+    }
+    const refillRate = this.config.maxRequests / this.config.windowMs;
+    const retryAfterMs = Math.ceil((1 - this.tokens) / refillRate);
+    return {
+      allowed: false,
+      remaining: 0,
+      retryAfterMs,
+      limit: maxTokens
+    };
+  }
+  /** Reset the limiter (e.g. after tier change) */
+  reset(config) {
+    if (config) {
+      this.config = config;
+    }
+    this.tokens = this.config.maxRequests + (this.config.burst ?? 0);
+    this.lastRefill = Date.now();
+  }
+  /** Peek at remaining tokens without consuming */
+  peek() {
+    this.refill();
+    const maxTokens = this.config.maxRequests + (this.config.burst ?? 0);
+    return {
+      allowed: this.tokens >= 1,
+      remaining: Math.floor(this.tokens),
+      retryAfterMs: 0,
+      limit: maxTokens
+    };
+  }
+}
+class ApiRateLimiter {
+  constructor(tier, config = DEFAULT_RATE_LIMITS) {
+    this.limiters = /* @__PURE__ */ new Map();
+    this.endpointOverrides = /* @__PURE__ */ new Map();
+    this.tier = tier;
+    this.config = config;
+  }
+  /** Set endpoint-specific rate limit overrides */
+  setEndpointOverride(endpoint, overrides) {
+    this.endpointOverrides.set(endpoint, overrides);
+  }
+  /** Update the current tier (resets all limiters) */
+  setTier(tier) {
+    this.tier = tier;
+    this.limiters.clear();
+  }
+  /** Get or create a limiter for an endpoint */
+  getLimiter(endpoint) {
+    let limiter = this.limiters.get(endpoint);
+    if (!limiter) {
+      const override = this.endpointOverrides.get(endpoint);
+      const tierConfig = (override && override[this.tier]) ?? this.config[this.tier];
+      limiter = new RateLimiter(tierConfig);
+      this.limiters.set(endpoint, limiter);
+    }
+    return limiter;
+  }
+  /** Check if a request to the given endpoint is allowed and consume a token */
+  check(endpoint = "default") {
+    return this.getLimiter(endpoint).consume();
+  }
+  /** Peek without consuming */
+  peek(endpoint = "default") {
+    return this.getLimiter(endpoint).peek();
+  }
+  /** Reset all limiters */
+  reset() {
+    this.limiters.clear();
+  }
+}
+function createApiRateLimiter(tier, config) {
+  return new ApiRateLimiter(tier, config);
+}
+const FEATURE_TIER_REQUIREMENTS = {
+  productName: "team",
+  logoUrl: "team",
+  logoDarkUrl: "team",
+  faviconUrl: "team",
+  primaryColor: "team",
+  secondaryColor: "team",
+  accentColor: "team",
+  customCss: "enterprise",
+  footerText: "enterprise",
+  hidePoweredBy: "enterprise",
+  customDomain: "site",
+  emailDomain: "site"
+};
+const tierRank = {
+  trial: 0,
+  personal: 1,
+  team: 2,
+  enterprise: 3,
+  site: 4,
+  oem: 5
+};
+class WhiteLabelManager {
+  constructor() {
+    this.config = {};
+    this.currentTier = "trial";
+  }
+  /** Set the active license tier */
+  setTier(tier) {
+    this.currentTier = tier;
+  }
+  /** Update white-label configuration (only applicable fields per tier are kept) */
+  setConfig(config) {
+    this.config = config;
+  }
+  /** Get the resolved configuration (filtered by tier permissions) */
+  getResolvedConfig() {
+    const resolved = {};
+    for (const [key, value] of Object.entries(this.config)) {
+      if (value === void 0) {
+        continue;
+      }
+      const requiredTier = FEATURE_TIER_REQUIREMENTS[key];
+      if (requiredTier && tierRank[this.currentTier] >= tierRank[requiredTier]) {
+        resolved[key] = value;
+      }
+    }
+    return resolved;
+  }
+  /** Check if a specific white-label feature is allowed */
+  isFeatureAllowed(feature) {
+    const requiredTier = FEATURE_TIER_REQUIREMENTS[feature];
+    return tierRank[this.currentTier] >= tierRank[requiredTier];
+  }
+  /** Get list of features not available at current tier */
+  getLockedFeatures() {
+    return Object.keys(FEATURE_TIER_REQUIREMENTS).filter(
+      (f2) => !this.isFeatureAllowed(f2)
+    );
+  }
+  /** Get list of features available at current tier */
+  getUnlockedFeatures() {
+    return Object.keys(FEATURE_TIER_REQUIREMENTS).filter(
+      (f2) => this.isFeatureAllowed(f2)
+    );
+  }
+  /** Generate CSS custom properties from the resolved config */
+  generateCssVariables() {
+    const cfg = this.getResolvedConfig();
+    const vars = [];
+    if (cfg.primaryColor) {
+      vars.push(`--nice-brand-primary: ${cfg.primaryColor};`);
+    }
+    if (cfg.secondaryColor) {
+      vars.push(`--nice-brand-secondary: ${cfg.secondaryColor};`);
+    }
+    if (cfg.accentColor) {
+      vars.push(`--nice-brand-accent: ${cfg.accentColor};`);
+    }
+    if (cfg.logoUrl) {
+      vars.push(`--nice-brand-logo: url(${cfg.logoUrl});`);
+    }
+    if (cfg.logoDarkUrl) {
+      vars.push(`--nice-brand-logo-dark: url(${cfg.logoDarkUrl});`);
+    }
+    if (vars.length === 0) {
+      return "";
+    }
+    return `:root {
+  ${vars.join("\n  ")}
+}`;
+  }
+  /** Apply the brand configuration to the document */
+  applyToDocument() {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const cfg = this.getResolvedConfig();
+    const css = this.generateCssVariables();
+    if (css) {
+      let styleEl = document.getElementById("nice-whitelabel-styles");
+      if (!styleEl) {
+        styleEl = document.createElement("style");
+        styleEl.id = "nice-whitelabel-styles";
+        document.head.appendChild(styleEl);
+      }
+      styleEl.textContent = css + (cfg.customCss ? `
+${cfg.customCss}` : "");
+    }
+    if (cfg.faviconUrl) {
+      let link = document.querySelector('link[rel="icon"]');
+      if (!link) {
+        link = document.createElement("link");
+        link.rel = "icon";
+        document.head.appendChild(link);
+      }
+      link.href = cfg.faviconUrl;
+    }
+    if (cfg.productName) {
+      document.title = cfg.productName;
+    }
+  }
+}
+function createWhiteLabelManager(tier, config) {
+  const mgr = new WhiteLabelManager();
+  mgr.setTier(tier);
+  if (config) {
+    mgr.setConfig(config);
+  }
+  return mgr;
+}
+const DEFAULT_SLA_CONFIGS = {
+  trial: {
+    uptimePercent: 95,
+    supportResponseHours: 72,
+    supportResolutionHours: 168,
+    supportChannels: ["email"],
+    priority: 6,
+    includedHours: 0,
+    breachPenaltyPercent: 0
+  },
+  personal: {
+    uptimePercent: 99,
+    supportResponseHours: 48,
+    supportResolutionHours: 120,
+    supportChannels: ["email"],
+    priority: 5,
+    includedHours: 2,
+    breachPenaltyPercent: 0
+  },
+  team: {
+    uptimePercent: 99.5,
+    supportResponseHours: 24,
+    supportResolutionHours: 72,
+    supportChannels: ["email", "chat"],
+    priority: 4,
+    includedHours: 10,
+    breachPenaltyPercent: 5
+  },
+  enterprise: {
+    uptimePercent: 99.9,
+    supportResponseHours: 4,
+    supportResolutionHours: 24,
+    supportChannels: ["email", "chat", "phone"],
+    priority: 3,
+    includedHours: 40,
+    breachPenaltyPercent: 10
+  },
+  site: {
+    uptimePercent: 99.95,
+    supportResponseHours: 2,
+    supportResolutionHours: 12,
+    supportChannels: ["email", "chat", "phone", "dedicated-manager"],
+    priority: 2,
+    includedHours: null,
+    breachPenaltyPercent: 15
+  },
+  oem: {
+    uptimePercent: 99.99,
+    supportResponseHours: 1,
+    supportResolutionHours: 4,
+    supportChannels: ["email", "chat", "phone", "dedicated-manager", "on-site"],
+    priority: 1,
+    includedHours: null,
+    breachPenaltyPercent: 20
+  }
+};
+class SlaTracker {
+  constructor(tier, config = DEFAULT_SLA_CONFIGS) {
+    this.events = [];
+    this.tier = tier;
+    this.config = config;
+  }
+  /** Update the license tier */
+  setTier(tier) {
+    this.tier = tier;
+  }
+  /** Get the SLA config for the current tier */
+  getSlaConfig() {
+    return this.config[this.tier];
+  }
+  /** Record an event */
+  recordEvent(event) {
+    this.events.push(event);
+  }
+  /** Record an uptime check */
+  recordUptimeCheck() {
+    var _a;
+    this.recordEvent({
+      id: ((_a = crypto.randomUUID) == null ? void 0 : _a.call(crypto)) ?? Date.now().toString(36),
+      type: "uptime-check",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /** Record downtime */
+  recordDowntime(durationMs) {
+    var _a, _b;
+    const now = /* @__PURE__ */ new Date();
+    this.recordEvent({
+      id: ((_a = crypto.randomUUID) == null ? void 0 : _a.call(crypto)) ?? Date.now().toString(36),
+      type: "downtime-start",
+      timestamp: new Date(now.getTime() - durationMs).toISOString(),
+      durationMs
+    });
+    this.recordEvent({
+      id: ((_b = crypto.randomUUID) == null ? void 0 : _b.call(crypto)) ?? (Date.now() + 1).toString(36),
+      type: "downtime-end",
+      timestamp: now.toISOString()
+    });
+  }
+  /** Record a support ticket lifecycle */
+  recordTicket(responseTimeHours, resolutionTimeHours) {
+    var _a, _b;
+    const now = /* @__PURE__ */ new Date();
+    this.recordEvent({
+      id: ((_a = crypto.randomUUID) == null ? void 0 : _a.call(crypto)) ?? Date.now().toString(36),
+      type: "ticket-opened",
+      timestamp: now.toISOString(),
+      metadata: { responseTimeHours, resolutionTimeHours }
+    });
+    this.recordEvent({
+      id: ((_b = crypto.randomUUID) == null ? void 0 : _b.call(crypto)) ?? (Date.now() + 1).toString(36),
+      type: "ticket-resolved",
+      timestamp: new Date(now.getTime() + resolutionTimeHours * 36e5).toISOString(),
+      durationMs: resolutionTimeHours * 36e5,
+      metadata: { responseTimeHours }
+    });
+  }
+  /** Generate an SLA report for a given period */
+  generateReport(periodStart, periodEnd) {
+    const slaConfig = this.getSlaConfig();
+    const periodMs = periodEnd.getTime() - periodStart.getTime();
+    const periodEvents = this.events.filter((e) => {
+      const t = new Date(e.timestamp).getTime();
+      return t >= periodStart.getTime() && t <= periodEnd.getTime();
+    });
+    const downtimeEvents = periodEvents.filter((e) => e.type === "downtime-start");
+    const totalDowntimeMs = downtimeEvents.reduce((sum, e) => sum + (e.durationMs ?? 0), 0);
+    const actualUptimePercent = periodMs > 0 ? (periodMs - totalDowntimeMs) / periodMs * 100 : 100;
+    const tickets = periodEvents.filter((e) => e.type === "ticket-resolved");
+    const responseTimes = tickets.map((t) => {
+      var _a;
+      return ((_a = t.metadata) == null ? void 0 : _a.responseTimeHours) ?? 0;
+    }).filter((h2) => h2 > 0);
+    const resolutionTimes = tickets.map((t) => (t.durationMs ?? 0) / 36e5).filter((h2) => h2 > 0);
+    const avgResponseHours = responseTimes.length > 0 ? responseTimes.reduce((a, b2) => a + b2, 0) / responseTimes.length : 0;
+    const avgResolutionHours = resolutionTimes.length > 0 ? resolutionTimes.reduce((a, b2) => a + b2, 0) / resolutionTimes.length : 0;
+    let breachCount = 0;
+    if (actualUptimePercent < slaConfig.uptimePercent) {
+      breachCount++;
+    }
+    if (avgResponseHours > slaConfig.supportResponseHours && responseTimes.length > 0) {
+      breachCount++;
+    }
+    if (avgResolutionHours > slaConfig.supportResolutionHours && resolutionTimes.length > 0) {
+      breachCount++;
+    }
+    const compliant = breachCount === 0;
+    const creditPercent = compliant ? 0 : breachCount * slaConfig.breachPenaltyPercent;
+    return {
+      periodStart: periodStart.toISOString(),
+      periodEnd: periodEnd.toISOString(),
+      tier: this.tier,
+      slaConfig,
+      actualUptimePercent: Math.round(actualUptimePercent * 100) / 100,
+      totalDowntimeMs,
+      avgResponseHours: Math.round(avgResponseHours * 10) / 10,
+      avgResolutionHours: Math.round(avgResolutionHours * 10) / 10,
+      breachCount,
+      compliant,
+      creditPercent: Math.min(100, creditPercent)
+    };
+  }
+  /** Get all recorded events */
+  getEvents() {
+    return [...this.events];
+  }
+  /** Clear all events */
+  clearEvents() {
+    this.events = [];
+  }
+}
+function createSlaTracker(tier) {
+  return new SlaTracker(tier);
+}
+function auditHash(str) {
+  let hash = 2166136261;
+  for (let i2 = 0; i2 < str.length; i2++) {
+    hash ^= str.charCodeAt(i2);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function hashKeyForAudit(key) {
+  return auditHash(key) + auditHash(key + "audit-salt");
+}
+class AuditTrail {
+  constructor(options) {
+    this.entries = [];
+    this.serverUrl = options == null ? void 0 : options.serverUrl;
+    this.apiKey = options == null ? void 0 : options.apiKey;
+  }
+  /** Append an audit entry */
+  log(event, licenseKey, actor, description, details) {
+    var _a;
+    const entry = {
+      id: ((_a = crypto.randomUUID) == null ? void 0 : _a.call(crypto)) ?? `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      licenseKeyHash: hashKeyForAudit(licenseKey),
+      actor,
+      description,
+      previousValue: details == null ? void 0 : details.previousValue,
+      newValue: details == null ? void 0 : details.newValue,
+      ipHash: details == null ? void 0 : details.ipHash,
+      metadata: details == null ? void 0 : details.metadata
+    };
+    this.entries.push(entry);
+    if (this.serverUrl) {
+      this.sendToServer(entry).catch(() => {
+      });
+    }
+    return entry;
+  }
+  // ─── Convenience logging methods ────────────────────────────
+  logActivation(licenseKey, actor) {
+    return this.log("license.activated", licenseKey, actor, "License activated");
+  }
+  logDeactivation(licenseKey, actor) {
+    return this.log("license.deactivated", licenseKey, actor, "License deactivated");
+  }
+  logTierChange(licenseKey, actor, from, to) {
+    return this.log(
+      "license.tier-changed",
+      licenseKey,
+      actor,
+      `Tier changed from ${from} to ${to}`,
+      { previousValue: from, newValue: to }
+    );
+  }
+  logSeatsChange(licenseKey, actor, from, to) {
+    return this.log(
+      "license.seats-changed",
+      licenseKey,
+      actor,
+      `Seats changed from ${from} to ${to}`,
+      { previousValue: from, newValue: to }
+    );
+  }
+  logRevocation(licenseKey, actor, reason) {
+    return this.log(
+      "license.revoked",
+      licenseKey,
+      actor,
+      `License revoked${reason ? `: ${reason}` : ""}`,
+      {
+        metadata: reason ? { reason } : void 0
+      }
+    );
+  }
+  // ─── Query ──────────────────────────────────────────────────
+  /** Query audit entries with filters */
+  query(filter = {}) {
+    var _a;
+    let results = [...this.entries];
+    if ((_a = filter.events) == null ? void 0 : _a.length) {
+      const set = new Set(filter.events);
+      results = results.filter((e) => set.has(e.event));
+    }
+    if (filter.licenseKeyHash) {
+      results = results.filter((e) => e.licenseKeyHash === filter.licenseKeyHash);
+    }
+    if (filter.actorId) {
+      results = results.filter((e) => e.actor.id === filter.actorId);
+    }
+    if (filter.from) {
+      const from = filter.from.getTime();
+      results = results.filter((e) => new Date(e.timestamp).getTime() >= from);
+    }
+    if (filter.to) {
+      const to = filter.to.getTime();
+      results = results.filter((e) => new Date(e.timestamp).getTime() <= to);
+    }
+    results.sort((a, b2) => new Date(b2.timestamp).getTime() - new Date(a.timestamp).getTime());
+    if (filter.offset) {
+      results = results.slice(filter.offset);
+    }
+    if (filter.limit) {
+      results = results.slice(0, filter.limit);
+    }
+    return results;
+  }
+  /** Get total entry count (optionally filtered) */
+  count(filter) {
+    if (!filter) {
+      return this.entries.length;
+    }
+    return this.query({ ...filter, limit: void 0, offset: void 0 }).length;
+  }
+  // ─── Export ─────────────────────────────────────────────────
+  /** Export audit entries */
+  export(filter, format = "json") {
+    const entries = this.query(filter ?? {});
+    if (format === "csv") {
+      const header = "id,event,timestamp,licenseKeyHash,actorType,actorId,description";
+      const rows = entries.map(
+        (e) => `"${e.id}","${e.event}","${e.timestamp}","${e.licenseKeyHash}","${e.actor.type}","${e.actor.id}","${e.description.replace(/"/g, '""')}"`
+      );
+      return [header, ...rows].join("\n");
+    }
+    return JSON.stringify(entries, null, 2);
+  }
+  // ─── Server sync ────────────────────────────────────────────
+  async sendToServer(entry) {
+    if (!this.serverUrl) {
+      return;
+    }
+    const headers = { "Content-Type": "application/json" };
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    await fetch(`${this.serverUrl}/audit`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(entry)
+    });
+  }
+  /** Get all entries (read-only copy) */
+  getAll() {
+    return [...this.entries];
+  }
+}
+function createAuditTrail(options) {
+  return new AuditTrail(options);
+}
+class LicensePortalService {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.config.apiBaseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.authToken && {
+        Authorization: `Bearer ${this.config.authToken}`
+      }
+    };
+    const response = await fetch(url, {
+      ...options,
+      headers: { ...headers, ...options.headers }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw {
+        code: `HTTP_${response.status}`,
+        message: error.message || response.statusText,
+        details: error
+      };
+    }
+    return response.json();
+  }
+  /** Get customer license overview */
+  async getOverview() {
+    return this.request(
+      `/customers/${this.config.customerId}/licenses/overview`
+    );
+  }
+  /** Get detailed license info */
+  async getLicense(licenseKey) {
+    return this.request(`/licenses/${encodeURIComponent(licenseKey)}`);
+  }
+  /** Activate license on current machine */
+  async activateLicense(licenseKey, machineId, machineName) {
+    return this.request(`/licenses/${encodeURIComponent(licenseKey)}/activate`, {
+      method: "POST",
+      body: JSON.stringify({ machineId, machineName })
+    });
+  }
+  /** Deactivate license from machine */
+  async deactivateLicense(licenseKey, machineId) {
+    await this.request(`/licenses/${encodeURIComponent(licenseKey)}/deactivate`, {
+      method: "POST",
+      body: JSON.stringify({ machineId })
+    });
+  }
+  /** Transfer license to another user/org */
+  async transferLicense(licenseKey, targetEmail, notes) {
+    return this.request(`/licenses/${encodeURIComponent(licenseKey)}/transfer`, {
+      method: "POST",
+      body: JSON.stringify({ targetEmail, notes })
+    });
+  }
+  /** Get seat assignments */
+  async getSeats(licenseKey) {
+    return this.request(`/licenses/${encodeURIComponent(licenseKey)}/seats`);
+  }
+  /** Assign seat to user */
+  async assignSeat(licenseKey, userId, email) {
+    return this.request(`/licenses/${encodeURIComponent(licenseKey)}/seats`, {
+      method: "POST",
+      body: JSON.stringify({ userId, email })
+    });
+  }
+  /** Remove seat assignment */
+  async removeSeat(licenseKey, seatId) {
+    await this.request(`/licenses/${encodeURIComponent(licenseKey)}/seats/${seatId}`, {
+      method: "DELETE"
+    });
+  }
+  /** Get subscription info */
+  async getSubscription() {
+    try {
+      return await this.request(
+        `/customers/${this.config.customerId}/subscription`
+      );
+    } catch {
+      return null;
+    }
+  }
+  /** Get invoices */
+  async getInvoices(limit = 10, offset = 0) {
+    return this.request(
+      `/customers/${this.config.customerId}/invoices?limit=${limit}&offset=${offset}`
+    );
+  }
+  /** Get action history */
+  async getActionHistory(licenseKey, limit = 50) {
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (licenseKey) {
+      params.set("licenseKey", licenseKey);
+    }
+    return this.request(`/customers/${this.config.customerId}/actions?${params}`);
+  }
+  /** Request license renewal */
+  async requestRenewal(licenseKey) {
+    return this.request(`/licenses/${encodeURIComponent(licenseKey)}/renew`, {
+      method: "POST"
+    });
+  }
+  /** Request tier upgrade */
+  async requestUpgrade(licenseKey, targetTier) {
+    return this.request(`/licenses/${encodeURIComponent(licenseKey)}/upgrade`, {
+      method: "POST",
+      body: JSON.stringify({ targetTier })
+    });
+  }
+}
+function getStatusColor(status) {
+  const colors = {
+    valid: "#22c55e",
+    expired: "#ef4444",
+    revoked: "#a855f7",
+    invalid: "#f97316",
+    grace: "#eab308",
+    pending: "#6b7280"
+  };
+  return colors[status] || "#6b7280";
+}
+function getTierLabel(tier) {
+  const labels = {
+    trial: "Trial",
+    personal: "Personal",
+    team: "Team",
+    enterprise: "Enterprise",
+    site: "Site License",
+    oem: "OEM"
+  };
+  return labels[tier] || tier;
+}
+function formatDate(isoDate, locale = "en-US") {
+  return new Date(isoDate).toLocaleDateString(locale, {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function getDaysUntilExpiration(expiresAt) {
+  if (!expiresAt) {
+    return null;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const expiry = new Date(expiresAt);
+  const diff = expiry.getTime() - now.getTime();
+  return Math.ceil(diff / (1e3 * 60 * 60 * 24));
+}
+function useLicensePortal(config) {
+  const [state, setState] = useState({
+    loading: true,
+    error: null,
+    overview: null,
+    selectedLicense: null,
+    actionHistory: [],
+    subscription: null,
+    invoices: [],
+    activeTab: "overview"
+  });
+  const service = React.useMemo(
+    () => new LicensePortalService(config),
+    [config.apiBaseUrl, config.authToken, config.customerId]
+  );
+  const loadData = useCallback(async () => {
+    var _a;
+    setState((s2) => ({ ...s2, loading: true, error: null }));
+    try {
+      const [overview, subscription, actionsData, invoicesData] = await Promise.all([
+        service.getOverview(),
+        config.showBilling ? service.getSubscription() : null,
+        service.getActionHistory(),
+        config.showBilling ? service.getInvoices() : { invoices: [], total: 0 }
+      ]);
+      setState((s2) => ({
+        ...s2,
+        loading: false,
+        overview,
+        subscription,
+        actionHistory: actionsData,
+        invoices: invoicesData.invoices
+      }));
+    } catch (error) {
+      const licenseError = error;
+      setState((s2) => ({ ...s2, loading: false, error: licenseError }));
+      (_a = config.onError) == null ? void 0 : _a.call(config, licenseError);
+    }
+  }, [service, config]);
+  useEffect(() => {
+    loadData();
+  }, [loadData]);
+  const activateLicense = useCallback(
+    async (licenseKey, machineId, machineName) => {
+      var _a, _b;
+      try {
+        const license = await service.activateLicense(licenseKey, machineId, machineName);
+        (_a = config.onLicenseActivated) == null ? void 0 : _a.call(config, license);
+        await loadData();
+        return license;
+      } catch (error) {
+        (_b = config.onError) == null ? void 0 : _b.call(config, error);
+        throw error;
+      }
+    },
+    [service, config, loadData]
+  );
+  const deactivateLicense = useCallback(
+    async (licenseKey, machineId) => {
+      var _a, _b;
+      try {
+        await service.deactivateLicense(licenseKey, machineId);
+        (_a = config.onLicenseDeactivated) == null ? void 0 : _a.call(config, licenseKey);
+        await loadData();
+      } catch (error) {
+        (_b = config.onError) == null ? void 0 : _b.call(config, error);
+        throw error;
+      }
+    },
+    [service, config, loadData]
+  );
+  const transferLicense = useCallback(
+    async (licenseKey, targetEmail, notes) => {
+      var _a;
+      try {
+        const result = await service.transferLicense(licenseKey, targetEmail, notes);
+        await loadData();
+        return result;
+      } catch (error) {
+        (_a = config.onError) == null ? void 0 : _a.call(config, error);
+        throw error;
+      }
+    },
+    [service, config, loadData]
+  );
+  const selectLicense = useCallback((license) => {
+    setState((s2) => ({ ...s2, selectedLicense: license }));
+  }, []);
+  const setActiveTab = useCallback((tab) => {
+    setState((s2) => ({ ...s2, activeTab: tab }));
+  }, []);
+  return {
+    state,
+    service,
+    loadData,
+    activateLicense,
+    deactivateLicense,
+    transferLicense,
+    selectLicense,
+    setActiveTab
+  };
+}
+const LicenseStatusBadge = ({ status, size = "md" }) => {
+  const sizeClasses = {
+    sm: "px-2 py-0.5 text-xs",
+    md: "px-2.5 py-1 text-sm",
+    lg: "px-3 py-1.5 text-base"
+  };
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: `inline-flex items-center rounded-full font-medium ${sizeClasses[size]}`,
+      style: {
+        backgroundColor: `${getStatusColor(status)}20`,
+        color: getStatusColor(status)
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: "mr-1.5 h-2 w-2 rounded-full",
+            style: { backgroundColor: getStatusColor(status) }
+          }
+        ),
+        status.charAt(0).toUpperCase() + status.slice(1)
+      ]
+    }
+  );
+};
+const LicenseTierBadge = ({ tier, size = "md" }) => {
+  const tierColors = {
+    trial: "#6b7280",
+    personal: "#3b82f6",
+    team: "#8b5cf6",
+    enterprise: "#f59e0b",
+    site: "#10b981",
+    oem: "#ec4899"
+  };
+  const sizeClasses = {
+    sm: "px-2 py-0.5 text-xs",
+    md: "px-2.5 py-1 text-sm",
+    lg: "px-3 py-1.5 text-base"
+  };
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: `inline-flex items-center rounded font-semibold ${sizeClasses[size]}`,
+      style: {
+        backgroundColor: `${tierColors[tier]}20`,
+        color: tierColors[tier],
+        border: `1px solid ${tierColors[tier]}40`
+      },
+      children: getTierLabel(tier)
+    }
+  );
+};
+const LicenseCard = ({ license, onSelect, onActivate, onDeactivate, selected }) => {
+  const daysRemaining = getDaysUntilExpiration(license.expiresAt);
+  const isExpiringSoon = daysRemaining !== null && daysRemaining <= 30 && daysRemaining > 0;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `rounded-lg border p-4 transition-all cursor-pointer hover:shadow-md ${selected ? "border-blue-500 ring-2 ring-blue-200" : "border-gray-200"}`,
+      onClick: onSelect,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between mb-3", children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("div", { className: "font-mono text-sm text-gray-500 mb-1", children: license.key }),
+            /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+              /* @__PURE__ */ jsx(LicenseTierBadge, { tier: license.tier, size: "sm" }),
+              /* @__PURE__ */ jsx(LicenseStatusBadge, { status: license.status, size: "sm" })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "text-right text-sm", children: [
+            /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Seats" }),
+            /* @__PURE__ */ jsxs("div", { className: "font-semibold", children: [
+              license.activeSeats,
+              "/",
+              license.maxSeats ?? "∞"
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "text-sm text-gray-600 mb-3", children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            "Licensee: ",
+            license.licensee
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            "Email: ",
+            license.email
+          ] })
+        ] }),
+        license.expiresAt && /* @__PURE__ */ jsx("div", { className: `text-sm ${isExpiringSoon ? "text-orange-600" : "text-gray-500"}`, children: daysRemaining !== null && daysRemaining > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          "Expires in ",
+          daysRemaining,
+          " days (",
+          formatDate(license.expiresAt),
+          ")"
+        ] }) : daysRemaining === 0 ? /* @__PURE__ */ jsx("span", { className: "text-red-600", children: "Expires today" }) : /* @__PURE__ */ jsxs("span", { className: "text-red-600", children: [
+          "Expired ",
+          formatDate(license.expiresAt)
+        ] }) }),
+        (onActivate || onDeactivate) && /* @__PURE__ */ jsxs("div", { className: "flex gap-2 mt-3 pt-3 border-t", children: [
+          onActivate && license.status === "valid" && /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: "px-3 py-1.5 text-sm bg-blue-500 text-white rounded hover:bg-blue-600",
+              onClick: (e) => {
+                e.stopPropagation();
+                onActivate();
+              },
+              children: "Activate"
+            }
+          ),
+          onDeactivate && /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: "px-3 py-1.5 text-sm bg-gray-200 text-gray-700 rounded hover:bg-gray-300",
+              onClick: (e) => {
+                e.stopPropagation();
+                onDeactivate();
+              },
+              children: "Deactivate"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+const LicensePortal = (props) => {
+  const { className, style, ...config } = props;
+  const { state, activateLicense, deactivateLicense, selectLicense, setActiveTab, loadData } = useLicensePortal(config);
+  if (state.loading) {
+    return /* @__PURE__ */ jsx("div", { className: `nice-license-portal ${className || ""}`, style, children: /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-center p-8", children: [
+      /* @__PURE__ */ jsx("div", { className: "animate-spin rounded-full h-8 w-8 border-b-2 border-blue-500" }),
+      /* @__PURE__ */ jsx("span", { className: "ml-3 text-gray-600", children: "Loading licenses..." })
+    ] }) });
+  }
+  if (state.error) {
+    return /* @__PURE__ */ jsx("div", { className: `nice-license-portal ${className || ""}`, style, children: /* @__PURE__ */ jsxs("div", { className: "p-4 bg-red-50 border border-red-200 rounded-lg", children: [
+      /* @__PURE__ */ jsx("h3", { className: "text-red-800 font-semibold", children: "Error loading licenses" }),
+      /* @__PURE__ */ jsx("p", { className: "text-red-600 text-sm mt-1", children: state.error.message }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          className: "mt-3 px-4 py-2 bg-red-100 text-red-700 rounded hover:bg-red-200",
+          onClick: loadData,
+          children: "Retry"
+        }
+      )
+    ] }) });
+  }
+  const { overview } = state;
+  if (!overview) {
+    return null;
+  }
+  const tabs = [
+    { id: "overview", label: "Overview" },
+    { id: "licenses", label: "Licenses" },
+    { id: "seats", label: "Seat Management" },
+    ...config.showBilling ? [{ id: "billing", label: "Billing" }] : [],
+    ...config.showAnalytics ? [{ id: "analytics", label: "Analytics" }] : [],
+    { id: "settings", label: "Settings" }
+  ];
+  return /* @__PURE__ */ jsxs("div", { className: `nice-license-portal ${className || ""}`, style, children: [
+    /* @__PURE__ */ jsxs("div", { className: "mb-6", children: [
+      /* @__PURE__ */ jsx("h1", { className: "text-2xl font-bold text-gray-900", children: "License Portal" }),
+      /* @__PURE__ */ jsx("p", { className: "text-gray-600", children: "Manage your Nice2Dev licenses and subscriptions" })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "border-b border-gray-200 mb-6", children: /* @__PURE__ */ jsx("nav", { className: "flex gap-6", children: tabs.map((tab) => /* @__PURE__ */ jsx(
+      "button",
+      {
+        className: `pb-3 text-sm font-medium border-b-2 transition-colors ${state.activeTab === tab.id ? "border-blue-500 text-blue-600" : "border-transparent text-gray-500 hover:text-gray-700"}`,
+        onClick: () => setActiveTab(tab.id),
+        children: tab.label
+      },
+      tab.id
+    )) }) }),
+    state.activeTab === "overview" && /* @__PURE__ */ jsxs("div", { className: "space-y-6", children: [
+      /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-1 md:grid-cols-4 gap-4", children: [
+        /* @__PURE__ */ jsxs("div", { className: "bg-white p-4 rounded-lg border border-gray-200", children: [
+          /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: "Total Licenses" }),
+          /* @__PURE__ */ jsx("div", { className: "text-2xl font-bold", children: overview.totalLicenses })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "bg-white p-4 rounded-lg border border-gray-200", children: [
+          /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: "Active" }),
+          /* @__PURE__ */ jsx("div", { className: "text-2xl font-bold text-green-600", children: overview.activeLicenses })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "bg-white p-4 rounded-lg border border-gray-200", children: [
+          /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: "Seats Used" }),
+          /* @__PURE__ */ jsxs("div", { className: "text-2xl font-bold", children: [
+            overview.usedSeats,
+            "/",
+            overview.totalSeats
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "bg-white p-4 rounded-lg border border-gray-200", children: [
+          /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: "Expiring Soon" }),
+          /* @__PURE__ */ jsx("div", { className: "text-2xl font-bold text-orange-600", children: overview.expiringSoon.length })
+        ] })
+      ] }),
+      overview.expiringSoon.length > 0 && /* @__PURE__ */ jsxs("div", { className: "bg-orange-50 border border-orange-200 rounded-lg p-4", children: [
+        /* @__PURE__ */ jsx("h3", { className: "font-semibold text-orange-800 mb-2", children: "Licenses Expiring Soon" }),
+        /* @__PURE__ */ jsx("div", { className: "space-y-2", children: overview.expiringSoon.map((license) => /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between text-sm", children: [
+          /* @__PURE__ */ jsx("span", { className: "font-mono text-orange-700", children: license.key }),
+          /* @__PURE__ */ jsxs("span", { className: "text-orange-600", children: [
+            getDaysUntilExpiration(license.expiresAt),
+            " days remaining"
+          ] })
+        ] }, license.key)) })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg border border-gray-200", children: [
+        /* @__PURE__ */ jsx("div", { className: "p-4 border-b border-gray-200", children: /* @__PURE__ */ jsx("h3", { className: "font-semibold", children: "Recent Activity" }) }),
+        /* @__PURE__ */ jsxs("div", { className: "divide-y divide-gray-100", children: [
+          state.actionHistory.slice(0, 5).map((action) => /* @__PURE__ */ jsxs("div", { className: "p-4 flex items-center justify-between", children: [
+            /* @__PURE__ */ jsxs("div", { children: [
+              /* @__PURE__ */ jsx("span", { className: "capitalize font-medium", children: action.type }),
+              /* @__PURE__ */ jsx("span", { className: "text-gray-500 ml-2 font-mono text-sm", children: action.licenseKey })
+            ] }),
+            /* @__PURE__ */ jsx("span", { className: "text-sm text-gray-500", children: formatDate(action.timestamp) })
+          ] }, action.id)),
+          state.actionHistory.length === 0 && /* @__PURE__ */ jsx("div", { className: "p-4 text-gray-500 text-center", children: "No recent activity" })
+        ] })
+      ] })
+    ] }),
+    state.activeTab === "licenses" && /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4", children: [
+      overview.licenses.map((license) => {
+        var _a;
+        return /* @__PURE__ */ jsx(
+          LicenseCard,
+          {
+            license,
+            selected: ((_a = state.selectedLicense) == null ? void 0 : _a.key) === license.key,
+            onSelect: () => selectLicense(license),
+            onActivate: () => {
+              activateLicense(license.key, "machine-id-here");
+            },
+            onDeactivate: () => {
+              deactivateLicense(license.key, "machine-id-here");
+            }
+          },
+          license.key
+        );
+      }),
+      overview.licenses.length === 0 && /* @__PURE__ */ jsx("div", { className: "col-span-full text-center py-8 text-gray-500", children: "No licenses found. Contact support to purchase a license." })
+    ] }),
+    state.activeTab === "billing" && config.showBilling && /* @__PURE__ */ jsxs("div", { className: "space-y-6", children: [
+      state.subscription && /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg border border-gray-200 p-6", children: [
+        /* @__PURE__ */ jsx("h3", { className: "font-semibold mb-4", children: "Current Subscription" }),
+        /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-2 gap-4", children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: "Plan" }),
+            /* @__PURE__ */ jsx("div", { className: "font-medium", children: state.subscription.plan })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: "Status" }),
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: `font-medium capitalize ${state.subscription.status === "active" ? "text-green-600" : "text-orange-600"}`,
+                children: state.subscription.status
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: "Current Period" }),
+            /* @__PURE__ */ jsxs("div", { className: "font-medium", children: [
+              formatDate(state.subscription.currentPeriodStart),
+              " -",
+              " ",
+              formatDate(state.subscription.currentPeriodEnd)
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: "Seats" }),
+            /* @__PURE__ */ jsx("div", { className: "font-medium", children: state.subscription.seats })
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg border border-gray-200", children: [
+        /* @__PURE__ */ jsx("div", { className: "p-4 border-b border-gray-200", children: /* @__PURE__ */ jsx("h3", { className: "font-semibold", children: "Invoices" }) }),
+        /* @__PURE__ */ jsxs("div", { className: "divide-y divide-gray-100", children: [
+          state.invoices.map((invoice) => /* @__PURE__ */ jsxs("div", { className: "p-4 flex items-center justify-between", children: [
+            /* @__PURE__ */ jsxs("div", { children: [
+              /* @__PURE__ */ jsx("div", { className: "font-medium", children: invoice.number }),
+              /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: formatDate(invoice.issuedAt) })
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4", children: [
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: `px-2 py-1 rounded text-sm ${invoice.status === "paid" ? "bg-green-100 text-green-700" : "bg-gray-100 text-gray-700"}`,
+                  children: invoice.status
+                }
+              ),
+              /* @__PURE__ */ jsxs("span", { className: "font-medium", children: [
+                invoice.currency,
+                " ",
+                invoice.amount.toFixed(2)
+              ] }),
+              invoice.downloadUrl && /* @__PURE__ */ jsx(
+                "a",
+                {
+                  href: invoice.downloadUrl,
+                  className: "text-blue-500 hover:text-blue-600",
+                  target: "_blank",
+                  rel: "noopener noreferrer",
+                  children: "Download"
+                }
+              )
+            ] })
+          ] }, invoice.id)),
+          state.invoices.length === 0 && /* @__PURE__ */ jsx("div", { className: "p-4 text-gray-500 text-center", children: "No invoices" })
+        ] })
+      ] })
+    ] }),
+    state.activeTab === "seats" && /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg border border-gray-200 p-6", children: [
+      /* @__PURE__ */ jsx("h3", { className: "font-semibold mb-4", children: "Seat Management" }),
+      /* @__PURE__ */ jsx("p", { className: "text-gray-500 mb-4", children: "Select a license to manage seat assignments." })
+    ] }),
+    state.activeTab === "settings" && /* @__PURE__ */ jsx("div", { className: "bg-white rounded-lg border border-gray-200 p-6", children: /* @__PURE__ */ jsx("h3", { className: "font-semibold mb-4", children: "Portal Settings" }) })
+  ] });
+};
+class ActivationService {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.config.apiBaseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.authToken && { Authorization: `Bearer ${this.config.authToken}` }
+    };
+    const response = await fetch(url, { ...options, headers });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw {
+        code: `HTTP_${response.status}`,
+        message: error.message || "Request failed",
+        retryable: response.status >= 500,
+        supportRequired: response.status === 403
+      };
+    }
+    return response.json();
+  }
+  async validateKey(licenseKey) {
+    return this.request("/licenses/validate", {
+      method: "POST",
+      body: JSON.stringify({ licenseKey })
+    });
+  }
+  async checkHardware(licenseKey, machineId, fingerprint) {
+    return this.request("/licenses/hardware-check", {
+      method: "POST",
+      body: JSON.stringify({ licenseKey, machineId, fingerprint })
+    });
+  }
+  async activate(licenseKey, machineId, fingerprint, machineName) {
+    return this.request(`/licenses/${encodeURIComponent(licenseKey)}/activate`, {
+      method: "POST",
+      body: JSON.stringify({ machineId, fingerprint, machineName })
+    });
+  }
+  async getOfflineChallenge(licenseKey, machineId) {
+    const result = await this.request("/licenses/offline/challenge", {
+      method: "POST",
+      body: JSON.stringify({ licenseKey, machineId })
+    });
+    return result.challenge;
+  }
+  async activateOffline(licenseKey, machineId, response) {
+    return this.request("/licenses/offline/activate", {
+      method: "POST",
+      body: JSON.stringify({ licenseKey, machineId, response })
+    });
+  }
+}
+function formatLicenseKey(key) {
+  const clean = key.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+  const parts = [];
+  for (let i2 = 0; i2 < clean.length; i2 += 4) {
+    parts.push(clean.slice(i2, i2 + 4));
+  }
+  return parts.slice(0, 5).join("-");
+}
+function validateKeyFormat(key) {
+  const pattern = /^[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/;
+  return pattern.test(key);
+}
+async function getDefaultMachineName() {
+  if (typeof window !== "undefined" && "userAgent" in navigator) {
+    const ua = navigator.userAgent;
+    if (ua.includes("Windows")) {
+      return "Windows PC";
+    }
+    if (ua.includes("Mac")) {
+      return "Mac";
+    }
+    if (ua.includes("Linux")) {
+      return "Linux Machine";
+    }
+    if (ua.includes("Android")) {
+      return "Android Device";
+    }
+    if (ua.includes("iOS")) {
+      return "iOS Device";
+    }
+  }
+  return "Unknown Device";
+}
+function useActivationWizard(config) {
+  const [state, setState] = useState({
+    step: "enter-key",
+    licenseKey: "",
+    validation: null,
+    machineId: null,
+    fingerprint: null,
+    machineName: config.machineName || "",
+    termsAccepted: false,
+    error: null,
+    activatedLicense: null,
+    offlineChallenge: null
+  });
+  const service = React.useMemo(() => new ActivationService(config), [config]);
+  const setLicenseKey = useCallback((key) => {
+    const formatted = formatLicenseKey(key);
+    setState((s2) => ({ ...s2, licenseKey: formatted, error: null }));
+  }, []);
+  const setMachineName = useCallback((name) => {
+    setState((s2) => ({ ...s2, machineName: name }));
+  }, []);
+  const setTermsAccepted = useCallback((accepted) => {
+    setState((s2) => ({ ...s2, termsAccepted: accepted }));
+  }, []);
+  const validateKey = useCallback(async () => {
+    if (!validateKeyFormat(state.licenseKey)) {
+      setState((s2) => ({
+        ...s2,
+        error: {
+          code: "INVALID_FORMAT",
+          message: "License key format is invalid. Expected format: XXXX-XXXX-XXXX-XXXX-XXXX",
+          retryable: true
+        }
+      }));
+      return;
+    }
+    setState((s2) => ({ ...s2, step: "validate", error: null }));
+    try {
+      const validation = await service.validateKey(state.licenseKey);
+      if (!validation.valid) {
+        setState((s2) => ({
+          ...s2,
+          step: "error",
+          error: {
+            code: validation.errorCode || "VALIDATION_FAILED",
+            message: validation.errorMessage || "License key validation failed",
+            retryable: true
+          }
+        }));
+        return;
+      }
+      const fingerprintData = await generateFingerprint();
+      const machineId = await generateMachineId();
+      const machineName = state.machineName || await getDefaultMachineName();
+      setState((s2) => ({
+        ...s2,
+        validation,
+        machineId,
+        fingerprint: fingerprintData,
+        machineName,
+        step: "hardware-check"
+      }));
+      const hwCheck = await service.checkHardware(state.licenseKey, machineId, fingerprintData);
+      if (!hwCheck.allowed) {
+        setState((s2) => ({
+          ...s2,
+          step: "error",
+          error: {
+            code: "HARDWARE_LIMIT",
+            message: hwCheck.reason || "Maximum hardware activations reached",
+            retryable: false,
+            supportRequired: true
+          }
+        }));
+        return;
+      }
+      setState((s2) => ({ ...s2, step: "terms" }));
+    } catch (error) {
+      setState((s2) => ({
+        ...s2,
+        step: "error",
+        error
+      }));
+    }
+  }, [state.licenseKey, state.machineName, service]);
+  const acceptTermsAndActivate = useCallback(async () => {
+    var _a, _b;
+    if (!state.termsAccepted) {
+      setState((s2) => ({
+        ...s2,
+        error: {
+          code: "TERMS_NOT_ACCEPTED",
+          message: "Please accept the terms of service to continue",
+          retryable: true
+        }
+      }));
+      return;
+    }
+    setState((s2) => ({ ...s2, step: "activating", error: null }));
+    try {
+      const license = await service.activate(
+        state.licenseKey,
+        state.machineId,
+        state.fingerprint,
+        state.machineName
+      );
+      setState((s2) => ({
+        ...s2,
+        step: "success",
+        activatedLicense: license
+      }));
+      (_a = config.onActivationSuccess) == null ? void 0 : _a.call(config, license);
+    } catch (error) {
+      const activationError = error;
+      setState((s2) => ({
+        ...s2,
+        step: "error",
+        error: activationError
+      }));
+      (_b = config.onActivationError) == null ? void 0 : _b.call(config, activationError);
+    }
+  }, [state, service, config]);
+  const startOfflineActivation = useCallback(async () => {
+    if (!config.allowOfflineActivation) {
+      return;
+    }
+    try {
+      const machineId = state.machineId || await generateMachineId();
+      const challenge = await service.getOfflineChallenge(state.licenseKey, machineId);
+      setState((s2) => ({
+        ...s2,
+        machineId,
+        offlineChallenge: challenge
+      }));
+    } catch (error) {
+      setState((s2) => ({
+        ...s2,
+        error
+      }));
+    }
+  }, [state.licenseKey, state.machineId, service, config.allowOfflineActivation]);
+  const submitOfflineResponse = useCallback(
+    async (response) => {
+      var _a, _b;
+      setState((s2) => ({ ...s2, step: "activating", error: null }));
+      try {
+        const license = await service.activateOffline(state.licenseKey, state.machineId, response);
+        setState((s2) => ({
+          ...s2,
+          step: "success",
+          activatedLicense: license
+        }));
+        (_a = config.onActivationSuccess) == null ? void 0 : _a.call(config, license);
+      } catch (error) {
+        const activationError = error;
+        setState((s2) => ({
+          ...s2,
+          step: "error",
+          error: activationError
+        }));
+        (_b = config.onActivationError) == null ? void 0 : _b.call(config, activationError);
+      }
+    },
+    [state.licenseKey, state.machineId, service, config]
+  );
+  const reset = useCallback(() => {
+    setState({
+      step: "enter-key",
+      licenseKey: "",
+      validation: null,
+      machineId: null,
+      fingerprint: null,
+      machineName: config.machineName || "",
+      termsAccepted: false,
+      error: null,
+      activatedLicense: null,
+      offlineChallenge: null
+    });
+  }, [config.machineName]);
+  const goBack = useCallback(() => {
+    setState((s2) => {
+      const stepOrder = [
+        "enter-key",
+        "validate",
+        "hardware-check",
+        "terms",
+        "activating",
+        "success"
+      ];
+      const currentIndex = stepOrder.indexOf(s2.step);
+      if (currentIndex > 0) {
+        return { ...s2, step: stepOrder[currentIndex - 1], error: null };
+      }
+      return s2;
+    });
+  }, []);
+  return {
+    state,
+    setLicenseKey,
+    setMachineName,
+    setTermsAccepted,
+    validateKey,
+    acceptTermsAndActivate,
+    startOfflineActivation,
+    submitOfflineResponse,
+    reset,
+    goBack
+  };
+}
+const StepIndicator = ({ currentStep }) => {
+  const steps = [
+    { id: "enter-key", label: "Enter Key" },
+    { id: "validate", label: "Validate" },
+    { id: "hardware-check", label: "Hardware" },
+    { id: "terms", label: "Terms" },
+    { id: "activating", label: "Activate" },
+    { id: "success", label: "Done" }
+  ];
+  const stepOrder = [
+    "enter-key",
+    "validate",
+    "hardware-check",
+    "terms",
+    "activating",
+    "success"
+  ];
+  const currentIndex = stepOrder.indexOf(currentStep);
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center justify-between mb-8", children: steps.map((step, index) => /* @__PURE__ */ jsxs(React.Fragment, { children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: `w-8 h-8 rounded-full flex items-center justify-center text-sm font-medium ${index < currentIndex ? "bg-green-500 text-white" : index === currentIndex ? "bg-blue-500 text-white" : "bg-gray-200 text-gray-500"}`,
+          children: index < currentIndex ? "✓" : index + 1
+        }
+      ),
+      /* @__PURE__ */ jsx("span", { className: "text-xs mt-1 text-gray-500", children: step.label })
+    ] }),
+    index < steps.length - 1 && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: `flex-1 h-0.5 mx-2 ${index < currentIndex ? "bg-green-500" : "bg-gray-200"}`
+      }
+    )
+  ] }, step.id)) });
+};
+const ActivationWizard = (props) => {
+  var _a;
+  const { className, style, ...config } = props;
+  const {
+    state,
+    setLicenseKey,
+    setMachineName,
+    setTermsAccepted,
+    validateKey,
+    acceptTermsAndActivate,
+    startOfflineActivation,
+    reset,
+    goBack
+  } = useActivationWizard(config);
+  const [offlineResponse, setOfflineResponse] = useState("");
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `nice-activation-wizard bg-white rounded-lg shadow-lg p-8 max-w-xl mx-auto ${className || ""}`,
+      style,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "text-center mb-6", children: [
+          /* @__PURE__ */ jsx("h1", { className: "text-2xl font-bold text-gray-900", children: "Activate License" }),
+          /* @__PURE__ */ jsx("p", { className: "text-gray-600 mt-1", children: "Follow the steps to activate your Nice2Dev license" })
+        ] }),
+        state.step !== "error" && /* @__PURE__ */ jsx(StepIndicator, { currentStep: state.step }),
+        state.step === "error" && state.error && /* @__PURE__ */ jsxs("div", { className: "space-y-4", children: [
+          /* @__PURE__ */ jsxs("div", { className: "bg-red-50 border border-red-200 rounded-lg p-6 text-center", children: [
+            /* @__PURE__ */ jsx("div", { className: "text-red-500 text-4xl mb-3", children: "⚠️" }),
+            /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold text-red-800", children: "Activation Failed" }),
+            /* @__PURE__ */ jsx("p", { className: "text-red-600 mt-2", children: state.error.message }),
+            state.error.supportRequired && config.supportEmail && /* @__PURE__ */ jsxs("p", { className: "text-sm text-gray-600 mt-4", children: [
+              "Please contact support at",
+              " ",
+              /* @__PURE__ */ jsx("a", { href: `mailto:${config.supportEmail}`, className: "text-blue-500 hover:underline", children: config.supportEmail })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex gap-3 justify-center", children: [
+            state.error.retryable && /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: () => goBack(),
+                className: "px-6 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600",
+                children: "Try Again"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: reset,
+                className: "px-6 py-2 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300",
+                children: "Start Over"
+              }
+            )
+          ] })
+        ] }),
+        state.step === "enter-key" && /* @__PURE__ */ jsxs("div", { className: "space-y-6", children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-gray-700 mb-2", children: "License Key" }),
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "text",
+                value: state.licenseKey,
+                onChange: (e) => setLicenseKey(e.target.value),
+                placeholder: "XXXX-XXXX-XXXX-XXXX-XXXX",
+                className: "w-full px-4 py-3 border border-gray-300 rounded-lg font-mono text-center text-lg tracking-wider focus:ring-2 focus:ring-blue-500 focus:border-blue-500",
+                maxLength: 29
+              }
+            ),
+            /* @__PURE__ */ jsx("p", { className: "text-sm text-gray-500 mt-2", children: "Enter the license key you received upon purchase" })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-gray-700 mb-2", children: "Machine Name (optional)" }),
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "text",
+                value: state.machineName,
+                onChange: (e) => setMachineName(e.target.value),
+                placeholder: "My Work PC",
+                className: "w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
+              }
+            )
+          ] }),
+          state.error && /* @__PURE__ */ jsx("div", { className: "text-red-600 text-sm bg-red-50 p-3 rounded-lg", children: state.error.message }),
+          /* @__PURE__ */ jsxs("div", { className: "flex gap-3", children: [
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: validateKey,
+                disabled: !state.licenseKey,
+                className: "flex-1 px-6 py-3 bg-blue-500 text-white rounded-lg hover:bg-blue-600 disabled:bg-gray-300 disabled:cursor-not-allowed",
+                children: "Continue"
+              }
+            ),
+            config.onCancel && /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: config.onCancel,
+                className: "px-6 py-3 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300",
+                children: "Cancel"
+              }
+            )
+          ] }),
+          config.allowOfflineActivation && /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: startOfflineActivation,
+              className: "w-full text-sm text-blue-500 hover:underline",
+              children: "Activate offline →"
+            }
+          )
+        ] }),
+        (state.step === "validate" || state.step === "hardware-check") && /* @__PURE__ */ jsxs("div", { className: "text-center py-8", children: [
+          /* @__PURE__ */ jsx("div", { className: "animate-spin rounded-full h-12 w-12 border-b-2 border-blue-500 mx-auto" }),
+          /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold mt-4", children: state.step === "validate" ? "Validating License..." : "Checking Hardware..." }),
+          /* @__PURE__ */ jsx("p", { className: "text-gray-500 mt-2", children: state.step === "validate" ? "Verifying your license key with the server" : "Collecting hardware information for activation" })
+        ] }),
+        state.step === "terms" && /* @__PURE__ */ jsxs("div", { className: "space-y-6", children: [
+          /* @__PURE__ */ jsxs("div", { className: "bg-gray-50 rounded-lg p-4", children: [
+            /* @__PURE__ */ jsx("h3", { className: "font-semibold mb-3", children: "License Details" }),
+            ((_a = state.validation) == null ? void 0 : _a.license) && /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-2 gap-2 text-sm", children: [
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Tier:" }),
+              /* @__PURE__ */ jsx("div", { className: "font-medium capitalize", children: state.validation.license.tier }),
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Licensee:" }),
+              /* @__PURE__ */ jsx("div", { className: "font-medium", children: state.validation.license.licensee }),
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Max Machines:" }),
+              /* @__PURE__ */ jsx("div", { className: "font-medium", children: state.validation.license.maxMachines }),
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "This Machine:" }),
+              /* @__PURE__ */ jsx("div", { className: "font-medium", children: state.machineName })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "border border-gray-200 rounded-lg p-4 max-h-48 overflow-y-auto text-sm text-gray-600", children: [
+            /* @__PURE__ */ jsx("h4", { className: "font-semibold text-gray-800 mb-2", children: "Terms of Service" }),
+            /* @__PURE__ */ jsx("p", { children: "By activating this license, you agree to the Nice2Dev Software License Agreement. This license grants you the right to use the software on the specified number of machines according to your license tier. Unauthorized redistribution, reverse engineering, or violation of these terms may result in license revocation." })
+          ] }),
+          /* @__PURE__ */ jsxs("label", { className: "flex items-start gap-3 cursor-pointer", children: [
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "checkbox",
+                checked: state.termsAccepted,
+                onChange: (e) => setTermsAccepted(e.target.checked),
+                className: "mt-1 w-4 h-4 rounded border-gray-300 text-blue-500 focus:ring-blue-500"
+              }
+            ),
+            /* @__PURE__ */ jsxs("span", { className: "text-sm text-gray-700", children: [
+              "I accept the",
+              " ",
+              config.termsUrl ? /* @__PURE__ */ jsx(
+                "a",
+                {
+                  href: config.termsUrl,
+                  className: "text-blue-500 hover:underline",
+                  target: "_blank",
+                  rel: "noopener noreferrer",
+                  children: "Terms of Service"
+                }
+              ) : "Terms of Service",
+              config.privacyUrl && /* @__PURE__ */ jsxs(Fragment, { children: [
+                " ",
+                "and",
+                " ",
+                /* @__PURE__ */ jsx(
+                  "a",
+                  {
+                    href: config.privacyUrl,
+                    className: "text-blue-500 hover:underline",
+                    target: "_blank",
+                    rel: "noopener noreferrer",
+                    children: "Privacy Policy"
+                  }
+                )
+              ] })
+            ] })
+          ] }),
+          state.error && /* @__PURE__ */ jsx("div", { className: "text-red-600 text-sm bg-red-50 p-3 rounded-lg", children: state.error.message }),
+          /* @__PURE__ */ jsxs("div", { className: "flex gap-3", children: [
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: goBack,
+                className: "px-6 py-3 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300",
+                children: "Back"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: acceptTermsAndActivate,
+                disabled: !state.termsAccepted,
+                className: "flex-1 px-6 py-3 bg-blue-500 text-white rounded-lg hover:bg-blue-600 disabled:bg-gray-300 disabled:cursor-not-allowed",
+                children: "Activate License"
+              }
+            )
+          ] })
+        ] }),
+        state.step === "activating" && /* @__PURE__ */ jsxs("div", { className: "text-center py-8", children: [
+          /* @__PURE__ */ jsx("div", { className: "animate-spin rounded-full h-12 w-12 border-b-2 border-blue-500 mx-auto" }),
+          /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold mt-4", children: "Activating License..." }),
+          /* @__PURE__ */ jsx("p", { className: "text-gray-500 mt-2", children: "Please wait while we activate your license" })
+        ] }),
+        state.step === "success" && state.activatedLicense && /* @__PURE__ */ jsxs("div", { className: "text-center space-y-6", children: [
+          /* @__PURE__ */ jsx("div", { className: "text-green-500 text-6xl", children: "✓" }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("h2", { className: "text-xl font-bold text-gray-900", children: "License Activated!" }),
+            /* @__PURE__ */ jsx("p", { className: "text-gray-600 mt-2", children: "Your license has been successfully activated on this machine." })
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "bg-green-50 rounded-lg p-4 text-left", children: /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-2 gap-2 text-sm", children: [
+            /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "License Key:" }),
+            /* @__PURE__ */ jsx("div", { className: "font-mono", children: state.activatedLicense.key }),
+            /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Tier:" }),
+            /* @__PURE__ */ jsx("div", { className: "capitalize", children: state.activatedLicense.tier }),
+            /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Machine:" }),
+            /* @__PURE__ */ jsx("div", { children: state.machineName }),
+            state.activatedLicense.expiresAt && /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Expires:" }),
+              /* @__PURE__ */ jsx("div", { children: new Date(state.activatedLicense.expiresAt).toLocaleDateString() })
+            ] })
+          ] }) }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => {
+                var _a2;
+                reset();
+                (_a2 = config.onCancel) == null ? void 0 : _a2.call(config);
+              },
+              className: "px-8 py-3 bg-blue-500 text-white rounded-lg hover:bg-blue-600",
+              children: "Done"
+            }
+          )
+        ] }),
+        state.offlineChallenge && /* @__PURE__ */ jsx("div", { className: "fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center p-4 z-50", children: /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg p-6 max-w-md w-full", children: [
+          /* @__PURE__ */ jsx("h3", { className: "text-lg font-semibold mb-4", children: "Offline Activation" }),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-4", children: [
+            /* @__PURE__ */ jsxs("div", { children: [
+              /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-gray-700 mb-1", children: "Challenge Code (send this to support):" }),
+              /* @__PURE__ */ jsx(
+                "textarea",
+                {
+                  readOnly: true,
+                  value: state.offlineChallenge,
+                  className: "w-full px-3 py-2 border border-gray-300 rounded font-mono text-xs h-20"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs("div", { children: [
+              /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-gray-700 mb-1", children: "Response Code (from support):" }),
+              /* @__PURE__ */ jsx(
+                "textarea",
+                {
+                  value: offlineResponse,
+                  onChange: (e) => setOfflineResponse(e.target.value),
+                  placeholder: "Paste the response code here...",
+                  className: "w-full px-3 py-2 border border-gray-300 rounded font-mono text-xs h-20"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "flex gap-3", children: [
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: () => {
+                  },
+                  disabled: !offlineResponse,
+                  className: "flex-1 px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600 disabled:bg-gray-300",
+                  children: "Activate"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: () => {
+                    setOfflineResponse("");
+                  },
+                  className: "px-4 py-2 bg-gray-200 text-gray-700 rounded hover:bg-gray-300",
+                  children: "Cancel"
+                }
+              )
+            ] })
+          ] })
+        ] }) })
+      ]
+    }
+  );
+};
+class LicenseTransferService {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.config.apiBaseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.authToken && { Authorization: `Bearer ${this.config.authToken}` }
+    };
+    const response = await fetch(url, { ...options, headers });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw {
+        code: `HTTP_${response.status}`,
+        message: error.message || "Request failed"
+      };
+    }
+    return response.json();
+  }
+  /** Get transferable licenses */
+  async getTransferableLicenses() {
+    return this.request("/licenses/transferable");
+  }
+  /** Validate recipient email/organization */
+  async validateRecipient(email) {
+    return this.request("/transfers/validate-recipient", {
+      method: "POST",
+      body: JSON.stringify({ email })
+    });
+  }
+  /** Initiate transfer */
+  async initiateTransfer(data) {
+    return this.request("/transfers", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  /** Get transfer by ID */
+  async getTransfer(transferId) {
+    return this.request(`/transfers/${transferId}`);
+  }
+  /** Get pending transfers */
+  async getPendingTransfers() {
+    return this.request("/transfers?status=pending,pending_approval");
+  }
+  /** Get transfer history */
+  async getTransferHistory(licenseKey) {
+    const params = licenseKey ? `?licenseKey=${encodeURIComponent(licenseKey)}` : "";
+    return this.request(`/transfers/history${params}`);
+  }
+  /** Cancel transfer */
+  async cancelTransfer(transferId, reason) {
+    return this.request(`/transfers/${transferId}/cancel`, {
+      method: "POST",
+      body: JSON.stringify({ reason })
+    });
+  }
+  /** Accept transfer (as recipient) */
+  async acceptTransfer(transferId, token) {
+    return this.request(`/transfers/${transferId}/accept`, {
+      method: "POST",
+      body: JSON.stringify({ token })
+    });
+  }
+  /** Approve transfer (admin) */
+  async approveTransfer(transferId) {
+    return this.request(`/transfers/${transferId}/approve`, {
+      method: "POST"
+    });
+  }
+  /** Reject transfer (admin) */
+  async rejectTransfer(transferId, reason) {
+    return this.request(`/transfers/${transferId}/reject`, {
+      method: "POST",
+      body: JSON.stringify({ reason })
+    });
+  }
+}
+function getTransferStatusColor(status) {
+  const colors = {
+    pending: "#f59e0b",
+    pending_approval: "#8b5cf6",
+    approved: "#3b82f6",
+    rejected: "#ef4444",
+    completed: "#22c55e",
+    cancelled: "#6b7280",
+    expired: "#9ca3af"
+  };
+  return colors[status];
+}
+function getTransferStatusLabel(status) {
+  const labels = {
+    pending: "Pending Acceptance",
+    pending_approval: "Awaiting Approval",
+    approved: "Approved",
+    rejected: "Rejected",
+    completed: "Completed",
+    cancelled: "Cancelled",
+    expired: "Expired"
+  };
+  return labels[status];
+}
+const TRANSFER_REASONS = [
+  { value: "employee_change", label: "Employee leaving/joining" },
+  { value: "department_transfer", label: "Department transfer" },
+  { value: "organization_sale", label: "Organization sale/merger" },
+  { value: "other", label: "Other" }
+];
+function useLicenseTransfer(config) {
+  const [step, setStep] = useState("select-license");
+  const [licenses, setLicenses] = useState([]);
+  const [formData, setFormData] = useState({
+    licenseKey: "",
+    recipientEmail: "",
+    recipientName: "",
+    notes: "",
+    transferReason: "employee_change",
+    confirmDeactivation: false
+  });
+  const [selectedLicense, setSelectedLicense] = useState(null);
+  const [recipientValidation, setRecipientValidation] = useState(null);
+  const [transfer, setTransfer] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const service = React.useMemo(() => new LicenseTransferService(config), [config]);
+  const loadLicenses = useCallback(async () => {
+    var _a;
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await service.getTransferableLicenses();
+      setLicenses(data);
+    } catch (err) {
+      setError(err);
+      (_a = config.onError) == null ? void 0 : _a.call(config, err);
+    } finally {
+      setLoading(false);
+    }
+  }, [service, config]);
+  const selectLicense = useCallback((license) => {
+    setSelectedLicense(license);
+    setFormData((f2) => ({ ...f2, licenseKey: license.key }));
+    setStep("enter-recipient");
+  }, []);
+  const validateRecipient = useCallback(async () => {
+    if (!formData.recipientEmail) {
+      return;
+    }
+    setLoading(true);
+    try {
+      const result = await service.validateRecipient(formData.recipientEmail);
+      setRecipientValidation({
+        valid: result.valid,
+        isExternal: result.isExternal,
+        warnings: result.warnings
+      });
+      if (result.valid && result.recipientInfo) {
+        setFormData((f2) => {
+          var _a;
+          return {
+            ...f2,
+            recipientName: ((_a = result.recipientInfo) == null ? void 0 : _a.name) || f2.recipientName
+          };
+        });
+      }
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [formData.recipientEmail, service]);
+  const proceedToReview = useCallback(() => {
+    if ((recipientValidation == null ? void 0 : recipientValidation.valid) && formData.recipientEmail) {
+      setStep("review");
+    }
+  }, [recipientValidation, formData.recipientEmail]);
+  const initiateTransfer = useCallback(async () => {
+    var _a, _b;
+    if (!formData.confirmDeactivation) {
+      setError({ code: "CONFIRMATION_REQUIRED", message: "Please confirm license deactivation" });
+      return;
+    }
+    setStep("processing");
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await service.initiateTransfer({
+        licenseKey: formData.licenseKey,
+        recipientEmail: formData.recipientEmail,
+        recipientName: formData.recipientName,
+        notes: formData.notes,
+        reason: formData.transferReason
+      });
+      setTransfer(result);
+      setStep("complete");
+      (_a = config.onTransferComplete) == null ? void 0 : _a.call(config, result);
+    } catch (err) {
+      setError(err);
+      setStep("review");
+      (_b = config.onError) == null ? void 0 : _b.call(config, err);
+    } finally {
+      setLoading(false);
+    }
+  }, [formData, service, config]);
+  const reset = useCallback(() => {
+    setStep("select-license");
+    setFormData({
+      licenseKey: "",
+      recipientEmail: "",
+      recipientName: "",
+      notes: "",
+      transferReason: "employee_change",
+      confirmDeactivation: false
+    });
+    setSelectedLicense(null);
+    setRecipientValidation(null);
+    setTransfer(null);
+    setError(null);
+  }, []);
+  return {
+    step,
+    setStep,
+    licenses,
+    formData,
+    setFormData,
+    selectedLicense,
+    recipientValidation,
+    transfer,
+    loading,
+    error,
+    loadLicenses,
+    selectLicense,
+    validateRecipient,
+    proceedToReview,
+    initiateTransfer,
+    reset
+  };
+}
+const TransferStatusBadge = ({ status }) => /* @__PURE__ */ jsx(
+  "span",
+  {
+    className: "inline-flex items-center px-2.5 py-1 rounded-full text-sm font-medium",
+    style: {
+      backgroundColor: `${getTransferStatusColor(status)}20`,
+      color: getTransferStatusColor(status)
+    },
+    children: getTransferStatusLabel(status)
+  }
+);
+const LicenseTransfer = (props) => {
+  var _a, _b;
+  const { className, style, ...config } = props;
+  const {
+    step,
+    licenses,
+    formData,
+    setFormData,
+    selectedLicense,
+    recipientValidation,
+    transfer,
+    loading,
+    error,
+    loadLicenses,
+    selectLicense,
+    validateRecipient,
+    proceedToReview,
+    initiateTransfer,
+    reset,
+    setStep
+  } = useLicenseTransfer(config);
+  React.useEffect(() => {
+    loadLicenses();
+  }, [loadLicenses]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `nice-license-transfer bg-white rounded-lg shadow-lg p-8 max-w-2xl mx-auto ${className || ""}`,
+      style,
+      children: [
+        /* @__PURE__ */ jsx("h1", { className: "text-2xl font-bold text-gray-900 mb-2", children: "Transfer License" }),
+        /* @__PURE__ */ jsx("p", { className: "text-gray-600 mb-6", children: "Transfer a license to another user or organization" }),
+        error && /* @__PURE__ */ jsx("div", { className: "mb-6 p-4 bg-red-50 border border-red-200 rounded-lg", children: /* @__PURE__ */ jsx("p", { className: "text-red-700", children: error.message }) }),
+        step === "select-license" && /* @__PURE__ */ jsxs("div", { className: "space-y-4", children: [
+          /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold", children: "Select a license to transfer" }),
+          loading ? /* @__PURE__ */ jsx("div", { className: "text-center py-8", children: /* @__PURE__ */ jsx("div", { className: "animate-spin h-8 w-8 border-b-2 border-blue-500 rounded-full mx-auto" }) }) : licenses.length === 0 ? /* @__PURE__ */ jsx("div", { className: "text-center py-8 text-gray-500", children: "No transferable licenses found" }) : /* @__PURE__ */ jsx("div", { className: "grid gap-4", children: licenses.map((license) => /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "p-4 border border-gray-200 rounded-lg hover:border-blue-500 cursor-pointer transition-colors",
+              onClick: () => selectLicense(license),
+              children: [
+                /* @__PURE__ */ jsxs("div", { className: "flex justify-between items-start", children: [
+                  /* @__PURE__ */ jsxs("div", { children: [
+                    /* @__PURE__ */ jsx("div", { className: "font-mono text-sm text-gray-500", children: license.key }),
+                    /* @__PURE__ */ jsx("div", { className: "font-medium mt-1", children: license.licensee })
+                  ] }),
+                  /* @__PURE__ */ jsx("span", { className: "px-2 py-1 bg-blue-100 text-blue-700 rounded text-sm capitalize", children: license.tier })
+                ] }),
+                /* @__PURE__ */ jsxs("div", { className: "mt-2 text-sm text-gray-500", children: [
+                  license.activeSeats,
+                  "/",
+                  license.maxSeats ?? "∞",
+                  " seats used"
+                ] })
+              ]
+            },
+            license.key
+          )) })
+        ] }),
+        step === "enter-recipient" && selectedLicense && /* @__PURE__ */ jsxs("div", { className: "space-y-6", children: [
+          /* @__PURE__ */ jsxs("div", { className: "p-4 bg-gray-50 rounded-lg", children: [
+            /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500", children: "Transferring license:" }),
+            /* @__PURE__ */ jsx("div", { className: "font-mono", children: selectedLicense.key })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-gray-700 mb-2", children: "Recipient Email" }),
+            /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+              /* @__PURE__ */ jsx(
+                "input",
+                {
+                  type: "email",
+                  value: formData.recipientEmail,
+                  onChange: (e) => setFormData((f2) => ({ ...f2, recipientEmail: e.target.value })),
+                  onBlur: validateRecipient,
+                  placeholder: "recipient@company.com",
+                  className: "flex-1 px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: validateRecipient,
+                  disabled: !formData.recipientEmail || loading,
+                  className: "px-4 py-2 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300 disabled:opacity-50",
+                  children: "Validate"
+                }
+              )
+            ] }),
+            recipientValidation && /* @__PURE__ */ jsxs(
+              "div",
+              {
+                className: `mt-2 text-sm ${recipientValidation.valid ? "text-green-600" : "text-red-600"}`,
+                children: [
+                  recipientValidation.valid ? "✓ Valid recipient" : "✗ Invalid recipient",
+                  recipientValidation.isExternal && /* @__PURE__ */ jsx("span", { className: "ml-2 text-orange-600", children: "(External organization)" })
+                ]
+              }
+            ),
+            (_a = recipientValidation == null ? void 0 : recipientValidation.warnings) == null ? void 0 : _a.map((warning, i2) => /* @__PURE__ */ jsxs("div", { className: "mt-1 text-sm text-orange-600", children: [
+              "⚠ ",
+              warning
+            ] }, i2))
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-gray-700 mb-2", children: "Recipient Name" }),
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "text",
+                value: formData.recipientName,
+                onChange: (e) => setFormData((f2) => ({ ...f2, recipientName: e.target.value })),
+                placeholder: "John Doe",
+                className: "w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-gray-700 mb-2", children: "Transfer Reason" }),
+            /* @__PURE__ */ jsx(
+              "select",
+              {
+                value: formData.transferReason,
+                onChange: (e) => setFormData((f2) => ({
+                  ...f2,
+                  transferReason: e.target.value
+                })),
+                className: "w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500",
+                children: TRANSFER_REASONS.map((reason) => /* @__PURE__ */ jsx("option", { value: reason.value, children: reason.label }, reason.value))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-gray-700 mb-2", children: "Notes (optional)" }),
+            /* @__PURE__ */ jsx(
+              "textarea",
+              {
+                value: formData.notes,
+                onChange: (e) => setFormData((f2) => ({ ...f2, notes: e.target.value })),
+                placeholder: "Any additional information...",
+                rows: 3,
+                className: "w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex gap-3", children: [
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: () => setStep("select-license"),
+                className: "px-6 py-2 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300",
+                children: "Back"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: proceedToReview,
+                disabled: !(recipientValidation == null ? void 0 : recipientValidation.valid) || !formData.recipientName,
+                className: "flex-1 px-6 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600 disabled:bg-gray-300",
+                children: "Review Transfer"
+              }
+            )
+          ] })
+        ] }),
+        step === "review" && selectedLicense && /* @__PURE__ */ jsxs("div", { className: "space-y-6", children: [
+          /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold", children: "Review Transfer Details" }),
+          /* @__PURE__ */ jsxs("div", { className: "bg-gray-50 rounded-lg p-4 space-y-3", children: [
+            /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-2 gap-2 text-sm", children: [
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "License Key:" }),
+              /* @__PURE__ */ jsx("div", { className: "font-mono", children: selectedLicense.key }),
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Current Licensee:" }),
+              /* @__PURE__ */ jsx("div", { children: selectedLicense.licensee }),
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Tier:" }),
+              /* @__PURE__ */ jsx("div", { className: "capitalize", children: selectedLicense.tier }),
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Transfer To:" }),
+              /* @__PURE__ */ jsx("div", { children: formData.recipientName }),
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Recipient Email:" }),
+              /* @__PURE__ */ jsx("div", { children: formData.recipientEmail }),
+              /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Reason:" }),
+              /* @__PURE__ */ jsx("div", { children: (_b = TRANSFER_REASONS.find((r2) => r2.value === formData.transferReason)) == null ? void 0 : _b.label })
+            ] }),
+            formData.notes && /* @__PURE__ */ jsxs("div", { className: "pt-3 border-t border-gray-200", children: [
+              /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500 mb-1", children: "Notes:" }),
+              /* @__PURE__ */ jsx("div", { className: "text-sm", children: formData.notes })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "p-4 bg-orange-50 border border-orange-200 rounded-lg", children: [
+            /* @__PURE__ */ jsx("h3", { className: "font-semibold text-orange-800 mb-2", children: "⚠ Important" }),
+            /* @__PURE__ */ jsx("p", { className: "text-sm text-orange-700", children: "Once the transfer is completed, this license will be deactivated from all your machines and the new owner will need to activate it." })
+          ] }),
+          /* @__PURE__ */ jsxs("label", { className: "flex items-start gap-3 cursor-pointer", children: [
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "checkbox",
+                checked: formData.confirmDeactivation,
+                onChange: (e) => setFormData((f2) => ({ ...f2, confirmDeactivation: e.target.checked })),
+                className: "mt-1 w-4 h-4 rounded border-gray-300 text-blue-500 focus:ring-blue-500"
+              }
+            ),
+            /* @__PURE__ */ jsx("span", { className: "text-sm text-gray-700", children: "I understand that this license will be deactivated and transferred to the recipient. This action cannot be undone without admin intervention." })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex gap-3", children: [
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: () => setStep("enter-recipient"),
+                className: "px-6 py-2 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300",
+                children: "Back"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: initiateTransfer,
+                disabled: !formData.confirmDeactivation || loading,
+                className: "flex-1 px-6 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600 disabled:bg-gray-300",
+                children: loading ? "Processing..." : "Initiate Transfer"
+              }
+            )
+          ] })
+        ] }),
+        step === "processing" && /* @__PURE__ */ jsxs("div", { className: "text-center py-12", children: [
+          /* @__PURE__ */ jsx("div", { className: "animate-spin h-12 w-12 border-b-2 border-blue-500 rounded-full mx-auto" }),
+          /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold mt-4", children: "Processing Transfer..." }),
+          /* @__PURE__ */ jsx("p", { className: "text-gray-500", children: "Please wait while we process your transfer request" })
+        ] }),
+        step === "complete" && transfer && /* @__PURE__ */ jsxs("div", { className: "text-center space-y-6", children: [
+          /* @__PURE__ */ jsx("div", { className: "text-green-500 text-6xl", children: "✓" }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("h2", { className: "text-xl font-bold", children: "Transfer Initiated" }),
+            /* @__PURE__ */ jsx("p", { className: "text-gray-600 mt-2", children: transfer.approvalRequired ? "Your transfer request has been submitted for approval." : "An email has been sent to the recipient with instructions to accept the transfer." })
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "bg-gray-50 rounded-lg p-4 text-left", children: /* @__PURE__ */ jsxs("div", { className: "text-sm grid grid-cols-2 gap-2", children: [
+            /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Transfer ID:" }),
+            /* @__PURE__ */ jsx("div", { className: "font-mono", children: transfer.id }),
+            /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Status:" }),
+            /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(TransferStatusBadge, { status: transfer.status }) }),
+            /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Expires:" }),
+            /* @__PURE__ */ jsx("div", { children: new Date(transfer.expiresAt).toLocaleDateString() })
+          ] }) }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: reset,
+              className: "px-8 py-3 bg-blue-500 text-white rounded-lg hover:bg-blue-600",
+              children: "Done"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+class BillingService {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.config.apiBaseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.authToken && { Authorization: `Bearer ${this.config.authToken}` }
+    };
+    const response = await fetch(url, { ...options, headers });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(error.message || `Request failed: ${response.status}`);
+    }
+    return response.json();
+  }
+  /* ─────────────────────────────────────────────────────────────
+     PRICING & PLANS
+  ───────────────────────────────────────────────────────────── */
+  /** Get all pricing plans */
+  async getPlans(currency) {
+    const params = currency ? `?currency=${currency}` : "";
+    return this.request(`/billing/plans${params}`);
+  }
+  /** Get plan by ID */
+  async getPlan(planId) {
+    return this.request(`/billing/plans/${planId}`);
+  }
+  /** Compare plans (for upgrade/downgrade) */
+  async comparePlans(currentPlanId, targetPlanId, seats) {
+    return this.request("/billing/plans/compare", {
+      method: "POST",
+      body: JSON.stringify({ currentPlanId, targetPlanId, seats })
+    });
+  }
+  /* ─────────────────────────────────────────────────────────────
+     SUBSCRIPTIONS
+  ───────────────────────────────────────────────────────────── */
+  /** Get current subscription */
+  async getSubscription() {
+    try {
+      return await this.request("/billing/subscription");
+    } catch {
+      return null;
+    }
+  }
+  /** Get subscription by ID */
+  async getSubscriptionById(subscriptionId) {
+    return this.request(`/billing/subscriptions/${subscriptionId}`);
+  }
+  /** Create checkout session for new subscription */
+  async createCheckoutSession(options) {
+    const provider = options.provider || this.detectPreferredProvider();
+    return this.request("/billing/checkout", {
+      method: "POST",
+      body: JSON.stringify({ ...options, provider })
+    });
+  }
+  /** Create billing portal session */
+  async createPortalSession(returnUrl) {
+    return this.request("/billing/portal", {
+      method: "POST",
+      body: JSON.stringify({ returnUrl })
+    });
+  }
+  /** Update subscription (change plan, seats) */
+  async updateSubscription(options) {
+    return this.request("/billing/subscription", {
+      method: "PATCH",
+      body: JSON.stringify(options)
+    });
+  }
+  /** Cancel subscription */
+  async cancelSubscription(options) {
+    return this.request("/billing/subscription/cancel", {
+      method: "POST",
+      body: JSON.stringify(options || { atPeriodEnd: true })
+    });
+  }
+  /** Resume canceled subscription */
+  async resumeSubscription() {
+    return this.request("/billing/subscription/resume", {
+      method: "POST"
+    });
+  }
+  /** Pause subscription (Paddle only) */
+  async pauseSubscription() {
+    return this.request("/billing/subscription/pause", {
+      method: "POST"
+    });
+  }
+  /* ─────────────────────────────────────────────────────────────
+     PAYMENT METHODS
+  ───────────────────────────────────────────────────────────── */
+  /** Get saved payment methods */
+  async getPaymentMethods() {
+    return this.request("/billing/payment-methods");
+  }
+  /** Add payment method (redirect to Stripe/Paddle) */
+  async addPaymentMethod(returnUrl) {
+    return this.request("/billing/payment-methods/add", {
+      method: "POST",
+      body: JSON.stringify({ returnUrl })
+    });
+  }
+  /** Remove payment method */
+  async removePaymentMethod(paymentMethodId) {
+    await this.request(`/billing/payment-methods/${paymentMethodId}`, {
+      method: "DELETE"
+    });
+  }
+  /** Set default payment method */
+  async setDefaultPaymentMethod(paymentMethodId) {
+    await this.request(`/billing/payment-methods/${paymentMethodId}/default`, {
+      method: "POST"
+    });
+  }
+  /* ─────────────────────────────────────────────────────────────
+     INVOICES
+  ───────────────────────────────────────────────────────────── */
+  /** Get invoices */
+  async getInvoices(options) {
+    const params = new URLSearchParams();
+    if (options == null ? void 0 : options.limit) {
+      params.set("limit", String(options.limit));
+    }
+    if (options == null ? void 0 : options.offset) {
+      params.set("offset", String(options.offset));
+    }
+    if (options == null ? void 0 : options.status) {
+      params.set("status", options.status);
+    }
+    return this.request(`/billing/invoices?${params}`);
+  }
+  /** Get upcoming invoice preview */
+  async getUpcomingInvoice() {
+    try {
+      return await this.request("/billing/invoices/upcoming");
+    } catch {
+      return null;
+    }
+  }
+  /** Download invoice PDF */
+  async downloadInvoice(invoiceId) {
+    const response = await fetch(`${this.config.apiBaseUrl}/billing/invoices/${invoiceId}/pdf`, {
+      headers: {
+        Authorization: this.config.authToken ? `Bearer ${this.config.authToken}` : ""
+      }
+    });
+    return response.blob();
+  }
+  /* ─────────────────────────────────────────────────────────────
+     COUPONS & PROMOTIONS
+  ───────────────────────────────────────────────────────────── */
+  /** Validate coupon code */
+  async validateCoupon(code, planId) {
+    return this.request("/billing/coupons/validate", {
+      method: "POST",
+      body: JSON.stringify({ code, planId })
+    });
+  }
+  /** Apply coupon to subscription */
+  async applyCoupon(code) {
+    return this.request("/billing/subscription/coupon", {
+      method: "POST",
+      body: JSON.stringify({ code })
+    });
+  }
+  /* ─────────────────────────────────────────────────────────────
+     USAGE-BASED BILLING
+  ───────────────────────────────────────────────────────────── */
+  /** Report usage */
+  async reportUsage(records) {
+    await this.request("/billing/usage", {
+      method: "POST",
+      body: JSON.stringify({ records })
+    });
+  }
+  /** Get usage summary */
+  async getUsageSummary(startDate, endDate) {
+    return this.request(`/billing/usage/summary?start=${startDate}&end=${endDate}`);
+  }
+  /* ─────────────────────────────────────────────────────────────
+     UTILITIES
+  ───────────────────────────────────────────────────────────── */
+  detectPreferredProvider() {
+    if (this.config.stripePublishableKey) {
+      return "stripe";
+    }
+    if (this.config.paddleVendorId) {
+      return "paddle";
+    }
+    return "stripe";
+  }
+  /** Format price for display */
+  formatPrice(amount, currency = "USD") {
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency,
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 2
+    }).format(amount / 100);
+  }
+  /** Calculate savings for yearly billing */
+  calculateYearlySavings(plan) {
+    const monthlyTotal = plan.monthlyPrice * 12;
+    const yearlyTotal = plan.yearlyPrice;
+    const savings = monthlyTotal - yearlyTotal;
+    const savingsPercent = Math.round(savings / monthlyTotal * 100);
+    return { monthlyTotal, yearlyTotal, savings, savingsPercent };
+  }
+}
+function createBillingService(config) {
+  return new BillingService(config);
+}
+class UsageAnalyticsService {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.config.apiBaseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.authToken && { Authorization: `Bearer ${this.config.authToken}` }
+    };
+    const response = await fetch(url, { ...options, headers });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(error.message || `Request failed: ${response.status}`);
+    }
+    return response.json();
+  }
+  getTimeParams(range, granularity) {
+    const params = new URLSearchParams({ range });
+    if (granularity) {
+      params.set("granularity", granularity);
+    }
+    if (this.config.organizationId) {
+      params.set("org", this.config.organizationId);
+    }
+    return params.toString();
+  }
+  /** Get overview metrics */
+  async getOverview(range = "30d") {
+    return this.request(`/analytics/overview?${this.getTimeParams(range)}`);
+  }
+  /** Get license activity over time */
+  async getLicenseActivity(range = "30d", granularity = "day") {
+    return this.request(
+      `/analytics/licenses/activity?${this.getTimeParams(range, granularity)}`
+    );
+  }
+  /** Get user activity over time */
+  async getUserActivity(range = "30d", granularity = "day") {
+    return this.request(
+      `/analytics/users/activity?${this.getTimeParams(range, granularity)}`
+    );
+  }
+  /** Get feature usage data */
+  async getFeatureUsage(range = "30d", features) {
+    const params = this.getTimeParams(range);
+    const featuresParam = features ? `&features=${features.join(",")}` : "";
+    return this.request(`/analytics/features?${params}${featuresParam}`);
+  }
+  /** Get top users by activity */
+  async getTopUsers(range = "30d", limit = 20) {
+    return this.request(
+      `/analytics/users/top?${this.getTimeParams(range)}&limit=${limit}`
+    );
+  }
+  /** Get license utilization */
+  async getLicenseUtilization() {
+    const params = this.config.organizationId ? `?org=${this.config.organizationId}` : "";
+    return this.request(`/analytics/licenses/utilization${params}`);
+  }
+  /** Get geographic distribution */
+  async getGeographicData(range = "30d") {
+    return this.request(`/analytics/geo?${this.getTimeParams(range)}`);
+  }
+  /** Get trends for key metrics */
+  async getTrends(range = "30d") {
+    return this.request(`/analytics/trends?${this.getTimeParams(range)}`);
+  }
+  /** Get retention cohorts */
+  async getRetentionCohorts(months = 6) {
+    const params = this.config.organizationId ? `?org=${this.config.organizationId}&months=${months}` : `?months=${months}`;
+    return this.request(`/analytics/retention${params}`);
+  }
+  /** Export analytics data */
+  async exportData(range, format) {
+    const response = await fetch(
+      `${this.config.apiBaseUrl}/analytics/export?${this.getTimeParams(range)}&format=${format}`,
+      {
+        headers: {
+          Authorization: this.config.authToken ? `Bearer ${this.config.authToken}` : ""
+        }
+      }
+    );
+    return response.blob();
+  }
+}
+function useUsageAnalytics(config) {
+  const [state, setState] = useState({
+    loading: true,
+    error: null,
+    timeRange: config.defaultTimeRange || "30d",
+    overview: null,
+    licenseActivity: [],
+    userActivity: [],
+    featureUsage: [],
+    topUsers: [],
+    licenseUtilization: [],
+    geoData: [],
+    trends: [],
+    retentionCohorts: []
+  });
+  const service = useMemo(() => new UsageAnalyticsService(config), [config]);
+  const loadData = useCallback(
+    async (range = state.timeRange) => {
+      setState((s2) => ({ ...s2, loading: true, error: null, timeRange: range }));
+      try {
+        const [
+          overview,
+          licenseActivity,
+          userActivity,
+          featureUsage,
+          topUsers,
+          licenseUtilization,
+          geoData,
+          trends,
+          retentionCohorts
+        ] = await Promise.all([
+          service.getOverview(range),
+          service.getLicenseActivity(range),
+          service.getUserActivity(range),
+          service.getFeatureUsage(range),
+          service.getTopUsers(range),
+          service.getLicenseUtilization(),
+          service.getGeographicData(range),
+          service.getTrends(range),
+          service.getRetentionCohorts()
+        ]);
+        setState((s2) => ({
+          ...s2,
+          loading: false,
+          overview,
+          licenseActivity,
+          userActivity,
+          featureUsage,
+          topUsers,
+          licenseUtilization,
+          geoData,
+          trends,
+          retentionCohorts
+        }));
+      } catch (error) {
+        setState((s2) => ({
+          ...s2,
+          loading: false,
+          error: error.message
+        }));
+      }
+    },
+    [service, state.timeRange]
+  );
+  useEffect(() => {
+    loadData();
+  }, []);
+  useEffect(() => {
+    if (config.refreshInterval && config.refreshInterval > 0) {
+      const interval = setInterval(() => loadData(), config.refreshInterval);
+      return () => clearInterval(interval);
+    }
+  }, [config.refreshInterval, loadData]);
+  const setTimeRange = useCallback(
+    (range) => {
+      loadData(range);
+    },
+    [loadData]
+  );
+  const exportData = useCallback(
+    async (format) => {
+      const blob = await service.exportData(state.timeRange, format);
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `analytics-${state.timeRange}.${format}`;
+      a.click();
+      URL.revokeObjectURL(url);
+    },
+    [service, state.timeRange]
+  );
+  return {
+    state,
+    setTimeRange,
+    refresh: loadData,
+    exportData
+  };
+}
+const MetricCard = ({ title, value, change, suffix, loading }) => /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg border border-gray-200 p-4", children: [
+  /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500 mb-1", children: title }),
+  loading ? /* @__PURE__ */ jsx("div", { className: "h-8 bg-gray-100 rounded animate-pulse" }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("div", { className: "text-2xl font-bold", children: [
+      typeof value === "number" ? value.toLocaleString() : value,
+      suffix && /* @__PURE__ */ jsx("span", { className: "text-sm font-normal text-gray-500 ml-1", children: suffix })
+    ] }),
+    change !== void 0 && /* @__PURE__ */ jsxs("div", { className: `text-sm mt-1 ${change >= 0 ? "text-green-600" : "text-red-600"}`, children: [
+      change >= 0 ? "↑" : "↓",
+      " ",
+      Math.abs(change).toFixed(1),
+      "%"
+    ] })
+  ] })
+] });
+const TimeRangeSelector = ({ value, onChange }) => {
+  const options = [
+    { value: "24h", label: "24 Hours" },
+    { value: "7d", label: "7 Days" },
+    { value: "30d", label: "30 Days" },
+    { value: "90d", label: "90 Days" },
+    { value: "1y", label: "1 Year" },
+    { value: "all", label: "All Time" }
+  ];
+  return /* @__PURE__ */ jsx("div", { className: "flex gap-1 bg-gray-100 rounded-lg p-1", children: options.map((opt) => /* @__PURE__ */ jsx(
+    "button",
+    {
+      onClick: () => onChange(opt.value),
+      className: `px-3 py-1.5 rounded-md text-sm font-medium transition-colors ${value === opt.value ? "bg-white text-gray-900 shadow-sm" : "text-gray-600 hover:text-gray-900"}`,
+      children: opt.label
+    },
+    opt.value
+  )) });
+};
+const FeatureUsageTable = ({ data, loading }) => /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg border border-gray-200 overflow-hidden", children: [
+  /* @__PURE__ */ jsx("div", { className: "p-4 border-b border-gray-200", children: /* @__PURE__ */ jsx("h3", { className: "font-semibold", children: "Feature Usage" }) }),
+  /* @__PURE__ */ jsx("div", { className: "overflow-x-auto", children: /* @__PURE__ */ jsxs("table", { className: "w-full", children: [
+    /* @__PURE__ */ jsx("thead", { className: "bg-gray-50", children: /* @__PURE__ */ jsxs("tr", { children: [
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase", children: "Feature" }),
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase", children: "Total Uses" }),
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase", children: "Users" }),
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase", children: "Avg/User" }),
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase", children: "Trend" })
+    ] }) }),
+    /* @__PURE__ */ jsx("tbody", { className: "divide-y divide-gray-100", children: loading ? /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: 5, className: "px-4 py-8 text-center text-gray-500", children: "Loading..." }) }) : data.length === 0 ? /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: 5, className: "px-4 py-8 text-center text-gray-500", children: "No data available" }) }) : data.map((feature) => /* @__PURE__ */ jsxs("tr", { className: "hover:bg-gray-50", children: [
+      /* @__PURE__ */ jsxs("td", { className: "px-4 py-3", children: [
+        /* @__PURE__ */ jsx("div", { className: "font-medium", children: feature.featureName }),
+        feature.category && /* @__PURE__ */ jsx("div", { className: "text-xs text-gray-500", children: feature.category })
+      ] }),
+      /* @__PURE__ */ jsx("td", { className: "px-4 py-3 text-right font-mono", children: feature.totalUses.toLocaleString() }),
+      /* @__PURE__ */ jsx("td", { className: "px-4 py-3 text-right font-mono", children: feature.uniqueUsers.toLocaleString() }),
+      /* @__PURE__ */ jsx("td", { className: "px-4 py-3 text-right font-mono", children: feature.avgUsesPerUser.toFixed(1) }),
+      /* @__PURE__ */ jsx("td", { className: "px-4 py-3 text-right", children: /* @__PURE__ */ jsxs(
+        "span",
+        {
+          className: `inline-flex items-center px-2 py-0.5 rounded text-xs font-medium ${feature.trend > 0 ? "bg-green-100 text-green-800" : feature.trend < 0 ? "bg-red-100 text-red-800" : "bg-gray-100 text-gray-800"}`,
+          children: [
+            feature.trend > 0 ? "+" : "",
+            feature.trend.toFixed(1),
+            "%"
+          ]
+        }
+      ) })
+    ] }, feature.featureId)) })
+  ] }) })
+] });
+const TopUsersTable = ({ data, loading }) => /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg border border-gray-200 overflow-hidden", children: [
+  /* @__PURE__ */ jsx("div", { className: "p-4 border-b border-gray-200", children: /* @__PURE__ */ jsx("h3", { className: "font-semibold", children: "Top Active Users" }) }),
+  /* @__PURE__ */ jsx("div", { className: "overflow-x-auto", children: /* @__PURE__ */ jsxs("table", { className: "w-full", children: [
+    /* @__PURE__ */ jsx("thead", { className: "bg-gray-50", children: /* @__PURE__ */ jsxs("tr", { children: [
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase", children: "User" }),
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase", children: "Sessions" }),
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase", children: "Duration" }),
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase", children: "Features" }),
+      /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase", children: "Last Active" })
+    ] }) }),
+    /* @__PURE__ */ jsx("tbody", { className: "divide-y divide-gray-100", children: loading ? /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: 5, className: "px-4 py-8 text-center text-gray-500", children: "Loading..." }) }) : data.map((user) => /* @__PURE__ */ jsxs("tr", { className: "hover:bg-gray-50", children: [
+      /* @__PURE__ */ jsxs("td", { className: "px-4 py-3", children: [
+        /* @__PURE__ */ jsx("div", { className: "font-medium", children: user.displayName || user.email }),
+        /* @__PURE__ */ jsx("div", { className: "text-xs text-gray-500 capitalize", children: user.tier })
+      ] }),
+      /* @__PURE__ */ jsx("td", { className: "px-4 py-3 text-right font-mono", children: user.sessionCount.toLocaleString() }),
+      /* @__PURE__ */ jsxs("td", { className: "px-4 py-3 text-right font-mono", children: [
+        Math.round(user.totalDuration / 60),
+        "h"
+      ] }),
+      /* @__PURE__ */ jsx("td", { className: "px-4 py-3 text-right font-mono", children: user.featuresUsed }),
+      /* @__PURE__ */ jsx("td", { className: "px-4 py-3 text-sm text-gray-500", children: new Date(user.lastActive).toLocaleDateString() })
+    ] }, user.userId)) })
+  ] }) })
+] });
+const LicenseUtilizationChart = ({ data, loading }) => /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg border border-gray-200", children: [
+  /* @__PURE__ */ jsx("div", { className: "p-4 border-b border-gray-200", children: /* @__PURE__ */ jsx("h3", { className: "font-semibold", children: "License Utilization" }) }),
+  /* @__PURE__ */ jsx("div", { className: "p-4 space-y-4", children: loading ? /* @__PURE__ */ jsx("div", { className: "text-center text-gray-500", children: "Loading..." }) : data.length === 0 ? /* @__PURE__ */ jsx("div", { className: "text-center text-gray-500", children: "No licenses" }) : data.map((license) => /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex justify-between text-sm mb-1", children: [
+      /* @__PURE__ */ jsx("span", { className: "font-medium truncate max-w-[200px]", children: license.licensee }),
+      /* @__PURE__ */ jsxs("span", { className: "text-gray-500", children: [
+        license.usedSeats,
+        "/",
+        license.totalSeats,
+        " seats"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "h-2 bg-gray-100 rounded-full overflow-hidden", children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: `h-full rounded-full ${license.utilizationPercent >= 90 ? "bg-red-500" : license.utilizationPercent >= 70 ? "bg-yellow-500" : "bg-green-500"}`,
+        style: { width: `${license.utilizationPercent}%` }
+      }
+    ) })
+  ] }, license.licenseKey)) })
+] });
+const UsageAnalyticsDashboard = (props) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const { className, style, ...config } = props;
+  const { state, setTimeRange, refresh, exportData } = useUsageAnalytics(config);
+  return /* @__PURE__ */ jsxs("div", { className: `nice-usage-analytics ${className || ""}`, style, children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between mb-6", children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("h1", { className: "text-2xl font-bold text-gray-900", children: "Usage Analytics" }),
+        /* @__PURE__ */ jsx("p", { className: "text-gray-600", children: "Monitor license usage and feature adoption" })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4", children: [
+        /* @__PURE__ */ jsx(TimeRangeSelector, { value: state.timeRange, onChange: setTimeRange }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: () => refresh(),
+            className: "p-2 text-gray-500 hover:text-gray-700 rounded-lg hover:bg-gray-100",
+            title: "Refresh",
+            children: "↻"
+          }
+        ),
+        /* @__PURE__ */ jsx("div", { className: "relative", children: /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "px-4 py-2 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300",
+            onClick: () => exportData("csv"),
+            children: "Export"
+          }
+        ) })
+      ] })
+    ] }),
+    state.error && /* @__PURE__ */ jsx("div", { className: "mb-6 p-4 bg-red-50 border border-red-200 rounded-lg text-red-700", children: state.error }),
+    /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-1 md:grid-cols-2 lg:grid-cols-5 gap-4 mb-6", children: [
+      /* @__PURE__ */ jsx(
+        MetricCard,
+        {
+          title: "Active Licenses",
+          value: ((_a = state.overview) == null ? void 0 : _a.activeLicenses) ?? 0,
+          change: (_b = state.overview) == null ? void 0 : _b.activeLicensesChange,
+          loading: state.loading
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        MetricCard,
+        {
+          title: "Active Users",
+          value: ((_c = state.overview) == null ? void 0 : _c.activeUsers) ?? 0,
+          change: (_d = state.overview) == null ? void 0 : _d.activeUsersChange,
+          loading: state.loading
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        MetricCard,
+        {
+          title: "Feature Uses",
+          value: ((_e = state.overview) == null ? void 0 : _e.featureUses) ?? 0,
+          change: (_f = state.overview) == null ? void 0 : _f.featureUsesChange,
+          loading: state.loading
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        MetricCard,
+        {
+          title: "Avg Session",
+          value: ((_h = (_g = state.overview) == null ? void 0 : _g.avgSessionDuration) == null ? void 0 : _h.toFixed(1)) ?? "0",
+          suffix: "min",
+          change: (_i = state.overview) == null ? void 0 : _i.avgSessionDurationChange,
+          loading: state.loading
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        MetricCard,
+        {
+          title: "Utilization",
+          value: `${((_k = (_j = state.overview) == null ? void 0 : _j.utilizationRate) == null ? void 0 : _k.toFixed(0)) ?? 0}%`,
+          change: (_l = state.overview) == null ? void 0 : _l.utilizationRateChange,
+          loading: state.loading
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-1 lg:grid-cols-3 gap-6 mb-6", children: [
+      /* @__PURE__ */ jsx("div", { className: "lg:col-span-2", children: /* @__PURE__ */ jsx(FeatureUsageTable, { data: state.featureUsage, loading: state.loading }) }),
+      /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(LicenseUtilizationChart, { data: state.licenseUtilization, loading: state.loading }) })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "mb-6", children: /* @__PURE__ */ jsx(TopUsersTable, { data: state.topUsers, loading: state.loading }) }),
+    state.geoData.length > 0 && /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg border border-gray-200 p-4", children: [
+      /* @__PURE__ */ jsx("h3", { className: "font-semibold mb-4", children: "Geographic Distribution" }),
+      /* @__PURE__ */ jsx("div", { className: "grid grid-cols-2 md:grid-cols-3 lg:grid-cols-6 gap-4", children: state.geoData.slice(0, 6).map((geo) => /* @__PURE__ */ jsxs("div", { className: "text-center", children: [
+        /* @__PURE__ */ jsx("div", { className: "text-2xl mb-1", children: getCountryFlag(geo.countryCode) }),
+        /* @__PURE__ */ jsx("div", { className: "text-sm font-medium", children: geo.country }),
+        /* @__PURE__ */ jsxs("div", { className: "text-xs text-gray-500", children: [
+          geo.users,
+          " users"
+        ] })
+      ] }, geo.countryCode)) })
+    ] })
+  ] });
+};
+function getCountryFlag(countryCode) {
+  const codePoints = countryCode.toUpperCase().split("").map((char) => 127397 + char.charCodeAt(0));
+  return String.fromCodePoint(...codePoints);
+}
+class RefundService {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.config.apiBaseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.authToken && { Authorization: `Bearer ${this.config.authToken}` }
+    };
+    const response = await fetch(url, { ...options, headers });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(error.message || `Request failed: ${response.status}`);
+    }
+    return response.json();
+  }
+  /* ─────────────────────────────────────────────────────────────
+     REFUND ELIGIBILITY
+  ───────────────────────────────────────────────────────────── */
+  /** Check if license is eligible for refund */
+  async checkEligibility(licenseKey) {
+    return this.request(
+      `/refunds/eligibility/${encodeURIComponent(licenseKey)}`
+    );
+  }
+  /** Calculate refund amount */
+  calculateRefundAmount(originalAmount, daysSincePurchase) {
+    const policy = this.config.policy;
+    if (daysSincePurchase > policy.refundPeriodDays) {
+      return { amount: 0, percent: 0 };
+    }
+    if (daysSincePurchase <= policy.fullRefundDays) {
+      return { amount: originalAmount, percent: 100 };
+    }
+    if (policy.partialRefundPercent) {
+      const amount = Math.round(originalAmount * (policy.partialRefundPercent / 100));
+      return { amount, percent: policy.partialRefundPercent };
+    }
+    if (policy.usageBasedRefundPercent !== void 0) {
+      const usedDays = daysSincePurchase - policy.fullRefundDays;
+      const remainingDays = policy.refundPeriodDays - policy.fullRefundDays;
+      const usagePercent = Math.min(100, usedDays / remainingDays * 100);
+      const refundPercent = Math.max(0, policy.usageBasedRefundPercent - usagePercent);
+      const amount = Math.round(originalAmount * (refundPercent / 100));
+      return { amount, percent: refundPercent };
+    }
+    return { amount: originalAmount, percent: 100 };
+  }
+  /* ─────────────────────────────────────────────────────────────
+     REFUND REQUESTS
+  ───────────────────────────────────────────────────────────── */
+  /** Create refund request */
+  async createRefundRequest(data) {
+    return this.request("/refunds", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  /** Get refund request by ID */
+  async getRefundRequest(requestId) {
+    return this.request(`/refunds/${requestId}`);
+  }
+  /** Get refund requests for customer */
+  async getCustomerRefundRequests(customerId) {
+    const endpoint = customerId ? `/refunds?customerId=${customerId}` : "/refunds";
+    return this.request(endpoint);
+  }
+  /** Get pending refund requests (admin) */
+  async getPendingRequests(limit = 50, offset = 0) {
+    return this.request(`/refunds/pending?limit=${limit}&offset=${offset}`);
+  }
+  /** Cancel refund request (customer) */
+  async cancelRefundRequest(requestId) {
+    return this.request(`/refunds/${requestId}/cancel`, {
+      method: "POST"
+    });
+  }
+  /** Add attachment to refund request */
+  async addAttachment(requestId, file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const response = await fetch(`${this.config.apiBaseUrl}/refunds/${requestId}/attachments`, {
+      method: "POST",
+      headers: {
+        Authorization: this.config.authToken ? `Bearer ${this.config.authToken}` : ""
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      throw new Error("Failed to upload attachment");
+    }
+    return response.json();
+  }
+  /* ─────────────────────────────────────────────────────────────
+     ADMIN OPERATIONS
+  ───────────────────────────────────────────────────────────── */
+  /** Approve refund request (admin) */
+  async approveRefund(requestId, options) {
+    return this.request(`/refunds/${requestId}/approve`, {
+      method: "POST",
+      body: JSON.stringify(options || {})
+    });
+  }
+  /** Reject refund request (admin) */
+  async rejectRefund(requestId, reason) {
+    return this.request(`/refunds/${requestId}/reject`, {
+      method: "POST",
+      body: JSON.stringify({ reason })
+    });
+  }
+  /** Process refund (trigger payment refund) */
+  async processRefund(requestId) {
+    var _a, _b;
+    const result = await this.request(`/refunds/${requestId}/process`, {
+      method: "POST"
+    });
+    (_b = (_a = this.config).onRefundProcessed) == null ? void 0 : _b.call(_a, result);
+    return result;
+  }
+  /* ─────────────────────────────────────────────────────────────
+     LICENSE REVOCATION
+  ───────────────────────────────────────────────────────────── */
+  /** Revoke license */
+  async revokeLicense(licenseKey, reason, options) {
+    var _a, _b;
+    const result = await this.request("/revocations", {
+      method: "POST",
+      body: JSON.stringify({
+        licenseKey,
+        reason,
+        ...options
+      })
+    });
+    (_b = (_a = this.config).onLicenseRevoked) == null ? void 0 : _b.call(_a, result);
+    return result;
+  }
+  /** Get revocation history */
+  async getRevocationHistory(licenseKey) {
+    const endpoint = licenseKey ? `/revocations?licenseKey=${encodeURIComponent(licenseKey)}` : "/revocations";
+    return this.request(endpoint);
+  }
+  /** Reactivate revoked license (if allowed) */
+  async reactivateLicense(revocationId, reason) {
+    return this.request(`/revocations/${revocationId}/reactivate`, {
+      method: "POST",
+      body: JSON.stringify({ reason })
+    });
+  }
+  /* ─────────────────────────────────────────────────────────────
+     STATISTICS
+  ───────────────────────────────────────────────────────────── */
+  /** Get refund statistics */
+  async getRefundStats(startDate, endDate) {
+    return this.request(`/refunds/stats?start=${startDate}&end=${endDate}`);
+  }
+}
+const DEFAULT_REFUND_POLICY = {
+  refundPeriodDays: 30,
+  autoApprovalTiers: ["trial", "personal"],
+  autoApprovalMaxAmount: 1e4,
+  // $100
+  maxRefundsPerYear: 3,
+  requireReason: true,
+  requireDetails: false,
+  fullRefundDays: 14,
+  partialRefundPercent: 50
+};
+function createRefundService(config) {
+  return new RefundService(config);
+}
+class BuildLicenseValidator {
+  constructor(config = {}) {
+    this.licenseInfo = null;
+    this.validationResult = null;
+    this.config = {
+      failOnInvalid: true,
+      failOnExpired: true,
+      allowOffline: true,
+      validationTimeout: 1e4,
+      ...config
+    };
+  }
+  /** Get license key from config or environment */
+  getLicenseKey() {
+    if (this.config.licenseKey) {
+      return this.config.licenseKey;
+    }
+    const envVar = this.config.licenseKeyEnvVar || "NICE2DEV_LICENSE_KEY";
+    return process.env[envVar] || null;
+  }
+  /** Log message (unless silent) */
+  log(message, type = "info") {
+    if (this.config.silent) {
+      return;
+    }
+    const prefix = "[nice2dev/license]";
+    switch (type) {
+      case "warn":
+        console.warn(`${prefix} ⚠ ${message}`);
+        break;
+      case "error":
+        console.error(`${prefix} ✗ ${message}`);
+        break;
+      default:
+        console.log(`${prefix} ${message}`);
+    }
+  }
+  /** Validate license online */
+  async validateOnline(licenseKey) {
+    if (!this.config.licenseServerUrl) {
+      return null;
+    }
+    const endpoint = this.config.validationEndpoint || "/api/licenses/validate";
+    const url = `${this.config.licenseServerUrl}${endpoint}`;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.config.validationTimeout);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ licenseKey }),
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (!response.ok) {
+        this.log(`Online validation failed: ${response.status}`, "warn");
+        return null;
+      }
+      const result = await response.json();
+      return result.license || null;
+    } catch (error) {
+      this.log(`Online validation error: ${error.message}`, "warn");
+      return null;
+    }
+  }
+  /** Load cached license */
+  async loadCachedLicense(licenseKey) {
+    if (!this.config.allowOffline || !this.config.cacheDir) {
+      return null;
+    }
+    const fs = await import("./__vite-browser-external-2Ng8QIWW.js").then((m2) => m2.promises).catch(() => null);
+    if (!fs) {
+      return null;
+    }
+    const cacheFile = `${this.config.cacheDir}/.license-cache.json`;
+    try {
+      const content = await fs.readFile(cacheFile, "utf-8");
+      const cached = JSON.parse(content);
+      if (cached.licenseKey === licenseKey && cached.license) {
+        return cached.license;
+      }
+    } catch {
+    }
+    return null;
+  }
+  /** Save license to cache */
+  async saveLicenseCache(licenseKey, license) {
+    if (!this.config.cacheDir) {
+      return;
+    }
+    const fs = await import("./__vite-browser-external-2Ng8QIWW.js").then((m2) => m2.promises).catch(() => null);
+    const path = await import("./__vite-browser-external-2Ng8QIWW.js").catch(() => null);
+    if (!fs || !path) {
+      return;
+    }
+    try {
+      await fs.mkdir(this.config.cacheDir, { recursive: true });
+      const cacheFile = `${this.config.cacheDir}/.license-cache.json`;
+      await fs.writeFile(
+        cacheFile,
+        JSON.stringify({ licenseKey, license, cachedAt: (/* @__PURE__ */ new Date()).toISOString() })
+      );
+    } catch {
+    }
+  }
+  /** Validate license (main entry point) */
+  async validate() {
+    var _a;
+    const result = {
+      valid: false,
+      warnings: [],
+      errors: []
+    };
+    const licenseKey = this.getLicenseKey();
+    if (!licenseKey) {
+      if (this.config.failOnInvalid) {
+        result.errors.push(
+          "No license key provided. Set NICE2DEV_LICENSE_KEY or pass licenseKey option."
+        );
+      } else {
+        result.warnings.push("No license key provided. Some features may be disabled.");
+        result.valid = true;
+      }
+      this.validationResult = result;
+      return result;
+    }
+    if (!validateKeyFormat$1(licenseKey)) {
+      result.errors.push("Invalid license key format.");
+      this.validationResult = result;
+      return result;
+    }
+    const metadata = extractKeyMetadata(licenseKey);
+    result.licenseKey = licenseKey;
+    result.tier = metadata == null ? void 0 : metadata.tier;
+    let license = await this.validateOnline(licenseKey);
+    if (!license && this.config.allowOffline) {
+      license = await this.loadCachedLicense(licenseKey);
+      if (license) {
+        result.warnings.push("Using cached license (offline mode).");
+      }
+    }
+    if (!license) {
+      this.log("Could not validate license online, using key metadata.", "warn");
+      result.warnings.push("License could not be validated online.");
+      if (this.config.requiredTier && (metadata == null ? void 0 : metadata.tier)) {
+        if (!tierMeetsRequirement(metadata.tier, this.config.requiredTier)) {
+          result.errors.push(
+            `License tier "${metadata.tier}" does not meet required tier "${this.config.requiredTier}".`
+          );
+          this.validationResult = result;
+          return result;
+        }
+      }
+      result.valid = !this.config.failOnInvalid;
+      this.validationResult = result;
+      return result;
+    }
+    await this.saveLicenseCache(licenseKey, license);
+    this.licenseInfo = license;
+    result.licensee = license.licensee;
+    result.tier = license.tier;
+    result.features = license.features;
+    result.expiresAt = license.expiresAt || void 0;
+    if (license.expiresAt) {
+      const expiresAt = new Date(license.expiresAt);
+      const now = /* @__PURE__ */ new Date();
+      const daysRemaining = Math.ceil(
+        (expiresAt.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24)
+      );
+      result.daysRemaining = daysRemaining;
+      if (daysRemaining <= 0) {
+        if (this.config.failOnExpired) {
+          result.errors.push("License has expired.");
+          this.validationResult = result;
+          return result;
+        } else {
+          result.warnings.push("License has expired. Some features may be disabled.");
+        }
+      } else if (daysRemaining <= 30) {
+        result.warnings.push(`License expires in ${daysRemaining} days.`);
+      }
+    }
+    if (this.config.requiredTier) {
+      if (!tierMeetsRequirement(license.tier, this.config.requiredTier)) {
+        result.errors.push(
+          `License tier "${license.tier}" does not meet required tier "${this.config.requiredTier}".`
+        );
+        this.validationResult = result;
+        return result;
+      }
+    }
+    if ((_a = this.config.requiredFeatures) == null ? void 0 : _a.length) {
+      const missingFeatures = this.config.requiredFeatures.filter(
+        (f2) => !license.features.includes(f2)
+      );
+      if (missingFeatures.length > 0) {
+        result.errors.push(`License missing required features: ${missingFeatures.join(", ")}`);
+        this.validationResult = result;
+        return result;
+      }
+    }
+    result.valid = true;
+    this.validationResult = result;
+    this.log(`License validated: ${license.licensee} (${license.tier})`);
+    return result;
+  }
+  /** Get validation result */
+  getResult() {
+    return this.validationResult;
+  }
+  /** Get license info */
+  getLicenseInfo() {
+    return this.licenseInfo;
+  }
+  /** Check if feature is available */
+  hasFeature(featureId) {
+    var _a;
+    return ((_a = this.licenseInfo) == null ? void 0 : _a.features.includes(featureId)) ?? false;
+  }
+  /** Check if tier meets requirement */
+  meetsTier(requiredTier) {
+    return this.licenseInfo ? tierMeetsRequirement(this.licenseInfo.tier, requiredTier) : false;
+  }
+}
+class Nice2DevLicenseWebpackPlugin {
+  constructor(options = {}) {
+    this.validated = false;
+    this.options = options;
+    this.validator = new BuildLicenseValidator(options);
+  }
+  apply(compiler) {
+    compiler.hooks.beforeRun.tapPromise("Nice2DevLicensePlugin", async () => {
+      if (this.validated) {
+        return;
+      }
+      const result = await this.validator.validate();
+      this.validated = true;
+      result.warnings.forEach((w2) => console.warn(`[nice2dev] ⚠ ${w2}`));
+      if (result.errors.length > 0 && this.options.failOnInvalid !== false) {
+        result.errors.forEach((e) => console.error(`[nice2dev] ✗ ${e}`));
+        throw new Error("License validation failed");
+      }
+    });
+    compiler.hooks.compilation.tap("Nice2DevLicensePlugin", (compilation) => {
+      var _a, _b;
+      const DefinePlugin = ((_a = compiler.webpack) == null ? void 0 : _a.DefinePlugin) || require("webpack").DefinePlugin;
+      const license = this.validator.getLicenseInfo();
+      new DefinePlugin({
+        "process.env.NICE2DEV_LICENSE_VALID": JSON.stringify(
+          ((_b = this.validator.getResult()) == null ? void 0 : _b.valid) ?? false
+        ),
+        "process.env.NICE2DEV_LICENSE_TIER": JSON.stringify((license == null ? void 0 : license.tier) ?? "trial"),
+        "process.env.NICE2DEV_LICENSE_FEATURES": JSON.stringify((license == null ? void 0 : license.features) ?? [])
+      }).apply(compiler);
+    });
+  }
+}
+function nice2devLicenseVitePlugin(options = {}) {
+  const validator = new BuildLicenseValidator(options);
+  let validated = false;
+  return {
+    name: "nice2dev-license",
+    async buildStart() {
+      if (validated) {
+        return;
+      }
+      const result = await validator.validate();
+      validated = true;
+      result.warnings.forEach((w2) => this.warn(w2));
+      if (result.errors.length > 0 && options.failOnInvalid !== false) {
+        result.errors.forEach((e) => this.error(e));
+        throw new Error("License validation failed");
+      }
+    },
+    config() {
+      var _a;
+      const license = validator.getLicenseInfo();
+      return {
+        define: {
+          "import.meta.env.NICE2DEV_LICENSE_VALID": JSON.stringify(
+            ((_a = validator.getResult()) == null ? void 0 : _a.valid) ?? false
+          ),
+          "import.meta.env.NICE2DEV_LICENSE_TIER": JSON.stringify((license == null ? void 0 : license.tier) ?? "trial"),
+          "import.meta.env.NICE2DEV_LICENSE_FEATURES": JSON.stringify((license == null ? void 0 : license.features) ?? [])
+        }
+      };
+    }
+  };
+}
+function nice2devLicenseRollupPlugin(options = {}) {
+  const validator = new BuildLicenseValidator(options);
+  let validated = false;
+  return {
+    name: "nice2dev-license",
+    async buildStart() {
+      if (validated) {
+        return;
+      }
+      const result = await validator.validate();
+      validated = true;
+      result.warnings.forEach((w2) => this.warn(w2));
+      if (result.errors.length > 0 && options.failOnInvalid !== false) {
+        throw new Error(result.errors.join("\n"));
+      }
+    }
+  };
+}
+function detectCIPlatform() {
+  const env = process.env;
+  if (env.GITHUB_ACTIONS === "true") {
+    return "github-actions";
+  }
+  if (env.TF_BUILD === "True") {
+    return "azure-devops";
+  }
+  if (env.GITLAB_CI === "true") {
+    return "gitlab-ci";
+  }
+  if (env.JENKINS_URL) {
+    return "jenkins";
+  }
+  if (env.CIRCLECI === "true") {
+    return "circleci";
+  }
+  if (env.BITBUCKET_BUILD_NUMBER) {
+    return "bitbucket-pipelines";
+  }
+  if (env.TRAVIS === "true") {
+    return "travis-ci";
+  }
+  return "unknown";
+}
+function isForkPR() {
+  const env = process.env;
+  const platform = detectCIPlatform();
+  switch (platform) {
+    case "github-actions":
+      return env.GITHUB_EVENT_NAME === "pull_request" && env.GITHUB_HEAD_REF !== void 0 && env.GITHUB_REPOSITORY !== env.GITHUB_HEAD_REPOSITORY;
+    case "gitlab-ci":
+      return env.CI_MERGE_REQUEST_SOURCE_PROJECT_PATH !== env.CI_PROJECT_PATH;
+    case "azure-devops":
+      return env.BUILD_REASON === "PullRequest" && env.SYSTEM_PULLREQUEST_ISFORK === "True";
+    default:
+      return false;
+  }
+}
+class CIOutputFormatter {
+  constructor(platform, format = "human") {
+    this.platform = platform;
+    this.outputFormat = format;
+  }
+  info(message) {
+    if (this.outputFormat === "json") {
+      return;
+    }
+    console.log(`ℹ️ ${message}`);
+  }
+  success(message) {
+    if (this.outputFormat === "json") {
+      return;
+    }
+    switch (this.platform) {
+      case "github-actions":
+        console.log(`::notice::${message}`);
+        break;
+      case "azure-devops":
+        console.log(`##[section]${message}`);
+        break;
+      default:
+        console.log(`✅ ${message}`);
+    }
+  }
+  warning(message) {
+    if (this.outputFormat === "json") {
+      return;
+    }
+    switch (this.platform) {
+      case "github-actions":
+        console.log(`::warning::${message}`);
+        break;
+      case "azure-devops":
+        console.log(`##[warning]${message}`);
+        break;
+      case "gitlab-ci":
+        console.warn(`\x1B[33mWarning: ${message}\x1B[0m`);
+        break;
+      default:
+        console.warn(`⚠️ ${message}`);
+    }
+  }
+  error(message) {
+    if (this.outputFormat === "json") {
+      return;
+    }
+    switch (this.platform) {
+      case "github-actions":
+        console.log(`::error::${message}`);
+        break;
+      case "azure-devops":
+        console.log(`##[error]${message}`);
+        break;
+      case "gitlab-ci":
+        console.error(`\x1B[31mError: ${message}\x1B[0m`);
+        break;
+      default:
+        console.error(`❌ ${message}`);
+    }
+  }
+  setOutput(name, value) {
+    switch (this.platform) {
+      case "github-actions":
+        const fs = require("fs");
+        const outputFile = process.env.GITHUB_OUTPUT;
+        if (outputFile) {
+          fs.appendFileSync(outputFile, `${name}=${value}
+`);
+        }
+        break;
+      case "azure-devops":
+        console.log(`##vso[task.setvariable variable=${name}]${value}`);
+        break;
+    }
+  }
+  setEnvVar(name, value) {
+    switch (this.platform) {
+      case "github-actions":
+        const fs = require("fs");
+        const envFile = process.env.GITHUB_ENV;
+        if (envFile) {
+          fs.appendFileSync(envFile, `${name}=${value}
+`);
+        }
+        break;
+      case "azure-devops":
+        console.log(`##vso[task.setvariable variable=${name}]${value}`);
+        break;
+    }
+  }
+  group(name, content) {
+    switch (this.platform) {
+      case "github-actions":
+        console.log(`::group::${name}`);
+        content();
+        console.log("::endgroup::");
+        break;
+      case "azure-devops":
+        console.log(`##[group]${name}`);
+        content();
+        console.log("##[endgroup]");
+        break;
+      default:
+        console.log(`
+--- ${name} ---`);
+        content();
+        console.log("");
+    }
+  }
+}
+async function validateLicenseOnline(licenseKey, serverUrl) {
+  try {
+    const response = await fetch(`${serverUrl}/api/licenses/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ licenseKey, context: "ci" })
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data.license || null;
+  } catch {
+    return null;
+  }
+}
+async function runCILicenseCheck(options = {}) {
+  var _a;
+  const platform = detectCIPlatform();
+  const formatter = new CIOutputFormatter(platform, options.outputFormat);
+  const result = {
+    success: false,
+    platform,
+    exitCode: 0,
+    message: "",
+    warnings: [],
+    errors: []
+  };
+  if (options.skipForForks && isForkPR()) {
+    formatter.info("Skipping license check for fork PR");
+    result.success = true;
+    result.message = "License check skipped for fork PR";
+    return result;
+  }
+  const licenseKey = options.licenseKey || process.env[options.licenseKeyEnvVar || "NICE2DEV_LICENSE_KEY"];
+  if (!licenseKey) {
+    const error = "No license key found. Set NICE2DEV_LICENSE_KEY secret or pass licenseKey option.";
+    formatter.error(error);
+    result.errors.push(error);
+    result.message = error;
+    result.exitCode = options.failOnInvalid !== false ? 1 : 0;
+    result.success = options.failOnInvalid === false;
+    return result;
+  }
+  formatter.info(`Validating license: ${licenseKey.substring(0, 12)}...`);
+  if (!validateKeyFormat$1(licenseKey)) {
+    const error = "Invalid license key format";
+    formatter.error(error);
+    result.errors.push(error);
+    result.message = error;
+    result.exitCode = 1;
+    return result;
+  }
+  const metadata = extractKeyMetadata(licenseKey);
+  const license = {
+    key: licenseKey,
+    tier: (metadata == null ? void 0 : metadata.tier) || "trial",
+    features: [],
+    licensee: void 0,
+    expiresAt: void 0,
+    daysRemaining: void 0
+  };
+  result.license = license;
+  if (options.licenseServerUrl) {
+    const onlineLicense = await validateLicenseOnline(licenseKey, options.licenseServerUrl);
+    if (onlineLicense) {
+      license.licensee = onlineLicense.licensee;
+      license.tier = onlineLicense.tier;
+      license.features = onlineLicense.features;
+      license.expiresAt = onlineLicense.expiresAt || void 0;
+      formatter.success(`License validated for: ${onlineLicense.licensee} (${onlineLicense.tier})`);
+    } else {
+      const warning = "Could not validate license online, using key metadata";
+      formatter.warning(warning);
+      result.warnings.push(warning);
+    }
+  }
+  if (license.expiresAt) {
+    const expiresAt = new Date(license.expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    const daysRemaining = Math.ceil((expiresAt.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
+    license.daysRemaining = daysRemaining;
+    const graceDays = options.expirationGraceDays ?? 0;
+    if (daysRemaining < -graceDays) {
+      const error = `License expired ${Math.abs(daysRemaining)} days ago`;
+      if (options.failOnExpired !== false) {
+        formatter.error(error);
+        result.errors.push(error);
+        result.exitCode = 1;
+        result.message = error;
+        return result;
+      } else {
+        formatter.warning(error);
+        result.warnings.push(error);
+      }
+    } else if (daysRemaining <= 0) {
+      const warning = `License expired but within grace period (${graceDays} days)`;
+      formatter.warning(warning);
+      result.warnings.push(warning);
+    } else if (daysRemaining <= 30) {
+      const warning = `License expires in ${daysRemaining} days`;
+      formatter.warning(warning);
+      result.warnings.push(warning);
+    }
+  }
+  if (options.requiredTier) {
+    if (!tierMeetsRequirement(license.tier, options.requiredTier)) {
+      const error = `License tier "${license.tier}" does not meet required tier "${options.requiredTier}"`;
+      formatter.error(error);
+      result.errors.push(error);
+      result.exitCode = 1;
+      result.message = error;
+      return result;
+    }
+    formatter.info(`Tier check passed: ${license.tier} >= ${options.requiredTier}`);
+  }
+  if ((_a = options.requiredFeatures) == null ? void 0 : _a.length) {
+    const missingFeatures = options.requiredFeatures.filter((f2) => !license.features.includes(f2));
+    if (missingFeatures.length > 0) {
+      const error = `Missing required features: ${missingFeatures.join(", ")}`;
+      formatter.error(error);
+      result.errors.push(error);
+      result.exitCode = 1;
+      result.message = error;
+      return result;
+    }
+    formatter.info(`Feature check passed: ${options.requiredFeatures.join(", ")}`);
+  }
+  if (options.setEnvVars !== false) {
+    formatter.setEnvVar("NICE2DEV_LICENSE_VALID", "true");
+    formatter.setEnvVar("NICE2DEV_LICENSE_TIER", license.tier);
+    formatter.setOutput("license-valid", "true");
+    formatter.setOutput("license-tier", license.tier);
+  }
+  result.success = true;
+  result.message = `License validated successfully (${license.tier})`;
+  formatter.success(result.message);
+  if (options.outputFormat === "json") {
+    console.log(JSON.stringify(result, null, 2));
+  }
+  return result;
+}
+function generateGitHubActionsWorkflow(options) {
+  return `name: License Check
+
+on:
+  pull_request:
+  push:
+    branches: [main, master]
+
+jobs:
+  license-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      
+      - name: Install dependencies
+        run: npm ci
+      
+      - name: Validate License
+        run: npx nice2dev-license-check${options.requiredTier ? ` -t ${options.requiredTier}` : ""}${options.skipForForks ? " --skip-for-forks" : ""}
+        env:
+          NICE2DEV_LICENSE_KEY: \${{ secrets.NICE2DEV_LICENSE_KEY }}
+`;
+}
+function generateAzureDevOpsPipeline(options) {
+  return `trigger:
+  - main
+  - master
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: '20.x'
+  displayName: 'Install Node.js'
+
+- script: npm ci
+  displayName: 'Install dependencies'
+
+- script: npx nice2dev-license-check${options.requiredTier ? ` -t ${options.requiredTier}` : ""}
+  displayName: 'Validate License'
+  env:
+    NICE2DEV_LICENSE_KEY: $(NICE2DEV_LICENSE_KEY)
+`;
+}
+function generateGitLabCIPipeline(options) {
+  return `stages:
+  - validate
+
+license-check:
+  stage: validate
+  image: node:20
+  script:
+    - npm ci
+    - npx nice2dev-license-check${options.requiredTier ? ` -t ${options.requiredTier}` : ""}
+  variables:
+    NICE2DEV_LICENSE_KEY: $NICE2DEV_LICENSE_KEY
+`;
+}
+const VERSION = "1.1.0";
+export {
+  ActivationService,
+  ActivationWizard,
+  ApiRateLimiter,
+  AuditTrail,
+  BillingService,
+  BuildLicenseValidator,
+  DEFAULT_RATE_LIMITS,
+  DEFAULT_REFUND_POLICY,
+  DEFAULT_SLA_CONFIGS,
+  FloatingLicenseManager,
+  LicenseCard,
+  LicensePortal,
+  LicensePortalService,
+  LicenseStatusBadge,
+  LicenseTierBadge,
+  LicenseTransfer,
+  LicenseTransferService,
+  L as LicenseValidator,
+  Nice2DevLicenseWebpackPlugin,
+  RateLimiter,
+  RefundService,
+  SeatManager,
+  SlaTracker,
+  TransferStatusBadge,
+  UsageAnalyticsDashboard,
+  UsageAnalyticsService,
+  UsageTelemetry,
+  VERSION,
+  WhiteLabelManager,
+  c as checkFeatureAccess,
+  b as collectFingerprintData,
+  d as compareFingerprintsData,
+  f as compareTiers,
+  createApiRateLimiter,
+  createAuditTrail,
+  createBillingService,
+  createFloatingLicenseManager,
+  createRefundService,
+  createSeatManager,
+  createSlaTracker,
+  createTelemetry,
+  createWhiteLabelManager,
+  detectCIPlatform,
+  extractKeyMetadata,
+  generateAzureDevOpsPipeline,
+  generateBundleTags,
+  generateFingerprint,
+  generateGitHubActionsWorkflow,
+  generateGitLabCIPipeline,
+  h as generateLicenseInfo,
+  i as generateLicenseKey,
+  generateMachineId,
+  generateProtectionManifest,
+  getAccessibleModules,
+  j as getAllFeatures,
+  k as getAllPlans,
+  getAllProtectedModules,
+  l as getAvailableFeatures,
+  m as getDefaultFeatures,
+  n as getDefaultMachines,
+  o as getDefaultSeats,
+  p as getFeature,
+  q as getFeaturesByCategory,
+  getInaccessibleModules,
+  r as getMissingFeatures,
+  s as getOrGenerateFingerprint,
+  u as getPlan,
+  getProtectedModule,
+  w as getStoredFingerprint,
+  x as getValidator,
+  y as hasFeature,
+  z as hasTier,
+  hashKeyForAudit,
+  hashLicenseKey,
+  A as initializeDefaults,
+  B as isFeatureLicensed,
+  isForkPR,
+  isModuleAccessible,
+  C as maskLicenseKey,
+  nice2devLicenseRollupPlugin,
+  nice2devLicenseVitePlugin,
+  D as normalizeLicenseKey,
+  E as registerFeature,
+  F as registerFeatures,
+  G as registerPlan,
+  H as registerPlans,
+  registerProtectedModule,
+  registerProtectedModules,
+  runCILicenseCheck,
+  I as storeFingerprint,
+  tierMeetsRequirement,
+  useActivationWizard,
+  useLicensePortal,
+  useLicenseTransfer,
+  useUsageAnalytics,
+  validateKeyFormat$1 as validateKeyFormat,
+  J as validateLicense
+};
+//# sourceMappingURL=index.mjs.map