@licensechain/javascript-sdk 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1484 @@
+import crypto, { createHash } from 'crypto';
+import * as jose from 'jose';
+
+class Configuration {
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = options.baseUrl || 'https://api.licensechain.app/v1';
+        this.timeout = options.timeout || 30000; // 30 seconds
+        this.retries = options.retries || 3;
+    }
+    getApiKey() {
+        return this.apiKey;
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    getTimeout() {
+        return this.timeout;
+    }
+    getRetries() {
+        return this.retries;
+    }
+    isValid() {
+        return !!this.apiKey && this.apiKey.length > 0;
+    }
+    setApiKey(apiKey) {
+        this.apiKey = apiKey;
+        return this;
+    }
+    setBaseUrl(baseUrl) {
+        this.baseUrl = baseUrl;
+        return this;
+    }
+    setTimeout(timeout) {
+        this.timeout = timeout;
+        return this;
+    }
+    setRetries(retries) {
+        this.retries = retries;
+        return this;
+    }
+    toObject() {
+        return {
+            apiKey: this.apiKey,
+            baseUrl: this.baseUrl,
+            timeout: this.timeout,
+            retries: this.retries
+        };
+    }
+    static fromObject(config) {
+        return new Configuration(config);
+    }
+    static fromEnvironment() {
+        return new Configuration({
+            apiKey: process.env.LICENSECHAIN_API_KEY || '',
+            baseUrl: process.env.LICENSECHAIN_BASE_URL || 'https://api.licensechain.app/v1',
+            timeout: parseInt(process.env.LICENSECHAIN_TIMEOUT || '30000'),
+            retries: parseInt(process.env.LICENSECHAIN_RETRIES || '3')
+        });
+    }
+}
+
+function validateEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+function validateLicenseKey(licenseKey) {
+    return licenseKey.length === 32 && /^[A-Z0-9]+$/.test(licenseKey);
+}
+function validateUuid(uuid) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(uuid);
+}
+function validateAmount(amount) {
+    return typeof amount === 'number' && amount > 0 && isFinite(amount);
+}
+function validateCurrency(currency) {
+    const validCurrencies = ['USD', 'EUR', 'GBP', 'CAD', 'AUD', 'JPY', 'CHF', 'CNY'];
+    return validCurrencies.includes(currency.toUpperCase());
+}
+function validateStatus(status, allowedStatuses) {
+    return allowedStatuses.includes(status);
+}
+function sanitizeInput(input) {
+    if (typeof input !== 'string') {
+        return String(input);
+    }
+    return input
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#x27;');
+}
+function sanitizeMetadata(metadata) {
+    if (typeof metadata !== 'object' || metadata === null) {
+        return metadata;
+    }
+    const sanitized = {};
+    for (const [key, value] of Object.entries(metadata)) {
+        if (typeof value === 'string') {
+            sanitized[key] = sanitizeInput(value);
+        }
+        else if (Array.isArray(value)) {
+            sanitized[key] = value.map(item => typeof item === 'string' ? sanitizeInput(item) : item);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            sanitized[key] = sanitizeMetadata(value);
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}
+function generateLicenseKey() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let result = '';
+    for (let i = 0; i < 32; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+function generateUuid() {
+    return crypto.randomUUID();
+}
+function formatTimestamp(timestamp) {
+    return new Date(timestamp * 1000).toISOString();
+}
+function parseTimestamp(timestamp) {
+    return Math.floor(new Date(timestamp).getTime() / 1000);
+}
+function validatePagination(page, limit) {
+    const validPage = Math.max(page || 1, 1);
+    const validLimit = Math.min(Math.max(limit || 10, 1), 100);
+    return [validPage, validLimit];
+}
+function validateDateRange(startDate, endDate) {
+    const startTime = parseTimestamp(startDate);
+    const endTime = parseTimestamp(endDate);
+    if (startTime > endTime) {
+        throw new Error('Start date must be before or equal to end date');
+    }
+}
+function createWebhookSignature(payload, secret) {
+    return crypto.createHmac('sha256', secret).update(payload).digest('hex');
+}
+function verifyWebhookSignature(payload, signature, secret) {
+    const expectedSignature = createWebhookSignature(payload, secret);
+    return crypto.timingSafeEqual(Buffer.from(signature, 'hex'), Buffer.from(expectedSignature, 'hex'));
+}
+function retryWithBackoff(fn, maxRetries = 3, initialDelay = 1000) {
+    return new Promise((resolve, reject) => {
+        let attempts = 0;
+        const attempt = async () => {
+            try {
+                const result = await fn();
+                resolve(result);
+            }
+            catch (error) {
+                attempts++;
+                if (attempts >= maxRetries) {
+                    reject(error);
+                }
+                else {
+                    setTimeout(attempt, initialDelay * Math.pow(2, attempts - 1));
+                }
+            }
+        };
+        attempt();
+    });
+}
+function formatBytes(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+    }
+    return `${size.toFixed(1)} ${units[unitIndex]}`;
+}
+function formatDuration(seconds) {
+    if (seconds < 60) {
+        return `${Math.floor(seconds)}s`;
+    }
+    else if (seconds < 3600) {
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = Math.floor(seconds % 60);
+        return `${minutes}m ${remainingSeconds}s`;
+    }
+    else if (seconds < 86400) {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        return `${hours}h ${minutes}m`;
+    }
+    else {
+        const days = Math.floor(seconds / 86400);
+        const hours = Math.floor((seconds % 86400) / 3600);
+        return `${days}d ${hours}h`;
+    }
+}
+function capitalizeFirst(text) {
+    if (!text)
+        return text;
+    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+}
+function toSnakeCase(text) {
+    return text.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '');
+}
+function toPascalCase(text) {
+    return text.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join('');
+}
+function truncateString(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return text.slice(0, maxLength - 3) + '...';
+}
+function removeSpecialChars(text) {
+    return text.replace(/[^a-zA-Z0-9\s]/g, '');
+}
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+function validateNotEmpty(value, fieldName) {
+    if (!value || !value.trim()) {
+        throw new Error(`${fieldName} cannot be empty`);
+    }
+}
+function validatePositive(value, fieldName) {
+    if (value <= 0) {
+        throw new Error(`${fieldName} must be positive`);
+    }
+}
+function validateRange(value, min, max, fieldName) {
+    if (value < min || value > max) {
+        throw new Error(`${fieldName} must be between ${min} and ${max}`);
+    }
+}
+function jsonSerialize(obj) {
+    return JSON.stringify(obj, null, 2);
+}
+function jsonDeserialize(jsonString) {
+    return JSON.parse(jsonString);
+}
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            result[key] = deepMerge(result[key] || {}, value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function chunkArray(array, chunkSize) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+        chunks.push(array.slice(i, i + chunkSize));
+    }
+    return chunks;
+}
+function flattenObject(obj, separator = '.') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const flattened = flattenObject(value, separator);
+            for (const [subKey, subValue] of Object.entries(flattened)) {
+                result[`${key}${separator}${subKey}`] = subValue;
+            }
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function unflattenObject(obj, separator = '.') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const keys = key.split(separator);
+        let current = result;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!current[keys[i]]) {
+                current[keys[i]] = {};
+            }
+            current = current[keys[i]];
+        }
+        current[keys[keys.length - 1]] = value;
+    }
+    return result;
+}
+function generateRandomString(length, characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') {
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+function generateRandomBytes(length) {
+    return crypto.randomBytes(length);
+}
+function sha256(data) {
+    return crypto.createHash('sha256').update(data).digest('hex');
+}
+function sha1(data) {
+    return crypto.createHash('sha1').update(data).digest('hex');
+}
+function md5(data) {
+    return crypto.createHash('md5').update(data).digest('hex');
+}
+function base64Encode(data) {
+    return Buffer.from(data).toString('base64');
+}
+function base64Decode(data) {
+    return Buffer.from(data, 'base64').toString('utf8');
+}
+function urlEncode(data) {
+    return encodeURIComponent(data);
+}
+function urlDecode(data) {
+    return decodeURIComponent(data);
+}
+function isValidJson(jsonString) {
+    try {
+        JSON.parse(jsonString);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isValidIp(ip) {
+    const ipRegex = /^(\d{1,3}\.){3}\d{1,3}$/;
+    return ipRegex.test(ip);
+}
+function isValidEmail(email) {
+    return validateEmail(email);
+}
+function getCurrentTimestamp() {
+    return Math.floor(Date.now() / 1000);
+}
+function getCurrentDate() {
+    return new Date().toISOString();
+}
+function getCurrentDateFormatted(format) {
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return format
+        .replace('YYYY', year.toString())
+        .replace('MM', month)
+        .replace('DD', day)
+        .replace('HH', hours)
+        .replace('mm', minutes)
+        .replace('ss', seconds);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function debounce(func, wait) {
+    let timeout;
+    return (...args) => {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => func(...args), wait);
+    };
+}
+function throttle(func, limit) {
+    let inThrottle;
+    return (...args) => {
+        if (!inThrottle) {
+            func(...args);
+            inThrottle = true;
+            setTimeout(() => (inThrottle = false), limit);
+        }
+    };
+}
+
+/**
+ * LicenseChain JavaScript SDK Exceptions
+ *
+ * Custom exceptions for the LicenseChain JavaScript SDK.
+ */
+class LicenseChainException extends Error {
+    constructor(message = 'LicenseChain error occurred', code, statusCode, details) {
+        super(message);
+        this.name = 'LicenseChainException';
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        // Maintains proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, LicenseChainException);
+        }
+    }
+}
+class AuthenticationError extends LicenseChainException {
+    constructor(message = 'Authentication failed', code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'AuthenticationError';
+    }
+}
+class ValidationError extends LicenseChainException {
+    constructor(message = 'Validation failed', code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'ValidationError';
+    }
+}
+class NotFoundError extends LicenseChainException {
+    constructor(message = 'Resource not found', code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'NotFoundError';
+    }
+}
+class RateLimitError extends LicenseChainException {
+    constructor(message = 'Rate limit exceeded', code, statusCode, details, retryAfter, limit, remaining, reset) {
+        super(message, code, statusCode, details);
+        this.name = 'RateLimitError';
+        this.retryAfter = retryAfter;
+        this.limit = limit;
+        this.remaining = remaining;
+        this.reset = reset;
+    }
+}
+class ServerError extends LicenseChainException {
+    constructor(message = 'Server error', code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'ServerError';
+    }
+}
+class NetworkError extends LicenseChainException {
+    constructor(message = 'Network error', code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'NetworkError';
+    }
+}
+class WebhookVerificationError extends LicenseChainException {
+    constructor(message = 'Webhook verification failed', code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'WebhookVerificationError';
+    }
+}
+class LicenseValidationError extends LicenseChainException {
+    constructor(message = 'License validation failed', code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'LicenseValidationError';
+    }
+}
+class ConfigurationError extends LicenseChainException {
+    constructor(message = 'Configuration error', code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'ConfigurationError';
+    }
+}
+class TimeoutError extends LicenseChainException {
+    constructor(message = 'Request timeout', code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'TimeoutError';
+    }
+}
+// Backward-compatible aliases used by existing SDK modules.
+const NetworkException = NetworkError;
+const ServerException = ServerError;
+const ValidationException = ValidationError;
+const AuthenticationException = AuthenticationError;
+const NotFoundException = NotFoundError;
+const RateLimitException = RateLimitError;
+const ConfigurationException = ConfigurationError;
+/**
+ * Error factory for creating appropriate exceptions based on HTTP status codes
+ */
+function createErrorFromResponse(statusCode, message, code, details) {
+    switch (statusCode) {
+        case 400:
+            return new ValidationError(message, code, statusCode, details);
+        case 401:
+        case 403:
+            return new AuthenticationError(message, code, statusCode, details);
+        case 404:
+            return new NotFoundError(message, code, statusCode, details);
+        case 429:
+            return new RateLimitError(message, code, statusCode, details);
+        case 408:
+            return new TimeoutError(message, code, statusCode, details);
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+            return new ServerError(message, code, statusCode, details);
+        default:
+            if (statusCode >= 400 && statusCode < 500) {
+                return new ValidationError(message, code, statusCode, details);
+            }
+            else if (statusCode >= 500) {
+                return new ServerError(message, code, statusCode, details);
+            }
+            else {
+                return new LicenseChainException(message, code, statusCode, details);
+            }
+    }
+}
+/**
+ * Check if an error is a LicenseChain exception
+ */
+function isLicenseChainError(error) {
+    return error instanceof LicenseChainException;
+}
+/**
+ * Check if an error is a retryable error
+ */
+function isRetryableError(error) {
+    if (!isLicenseChainError(error)) {
+        return false;
+    }
+    // Retry on network errors, server errors, and rate limits
+    return (error instanceof NetworkError ||
+        error instanceof ServerError ||
+        error instanceof RateLimitError ||
+        error instanceof TimeoutError);
+}
+
+class LicenseChainHttpCore {
+    constructor(runtime) {
+        this.runtime = runtime;
+        this.baseUrl = runtime.baseUrl.replace(/\/$/, '');
+    }
+    async get(endpoint, params) {
+        return this.makeRequest('GET', endpoint, undefined, params);
+    }
+    async post(endpoint, data) {
+        return this.makeRequest('POST', endpoint, data);
+    }
+    async put(endpoint, data) {
+        return this.makeRequest('PUT', endpoint, data);
+    }
+    async patch(endpoint, data) {
+        return this.makeRequest('PATCH', endpoint, data);
+    }
+    async delete(endpoint, data) {
+        return this.makeRequest('DELETE', endpoint, data);
+    }
+    async makeRequest(method, endpoint, data, params) {
+        const url = this.buildUrl(endpoint, params);
+        const requestOptions = this.buildRequestOptions(method, data);
+        return this.runtime.retryWithBackoff(async () => {
+            return this.sendRequest(url, requestOptions);
+        }, this.runtime.retries);
+    }
+    buildUrl(endpoint, params) {
+        const baseHasV1 = this.baseUrl.endsWith('/v1');
+        const normalizedEndpoint = endpoint.startsWith('/v1/')
+            ? (baseHasV1 ? endpoint.slice(3) : endpoint)
+            : endpoint.startsWith('/')
+                ? (baseHasV1 ? endpoint : `/v1${endpoint}`)
+                : (baseHasV1 ? `/${endpoint}` : `/v1/${endpoint}`);
+        let url = `${this.baseUrl}${normalizedEndpoint}`;
+        if (params && Object.keys(params).length > 0) {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    searchParams.append(key, String(value));
+                }
+            }
+            url += `?${searchParams.toString()}`;
+        }
+        return url;
+    }
+    buildRequestOptions(method, data) {
+        const options = {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.runtime.apiKey}`,
+                'Content-Type': 'application/json',
+                'User-Agent': this.runtime.userAgent,
+                'X-API-Version': '1.0',
+                'X-Platform': this.runtime.platform,
+            },
+        };
+        if (data !== undefined) {
+            options.body = this.runtime.serialize(data);
+        }
+        return options;
+    }
+    async sendRequest(url, options) {
+        try {
+            const response = await fetch(url, {
+                ...options,
+                signal: AbortSignal.timeout(this.runtime.timeout),
+            });
+            if (response.ok) {
+                const text = await response.text();
+                return text ? this.runtime.deserialize(text) : {};
+            }
+            const errorText = await response.text();
+            let errorMessage = 'Unknown error';
+            try {
+                const errorData = this.runtime.deserialize(errorText);
+                errorMessage = errorData.error || errorData.message || errorMessage;
+            }
+            catch {
+                errorMessage = errorText || errorMessage;
+            }
+            this.handleHttpError(response.status, errorMessage);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw this.runtime.exceptions.network('Request timeout');
+                }
+                throw this.runtime.exceptions.network(error.message);
+            }
+            throw error;
+        }
+    }
+    handleHttpError(statusCode, message) {
+        switch (statusCode) {
+            case 400:
+                throw this.runtime.exceptions.validation(`Bad Request: ${message}`);
+            case 401:
+            case 403:
+                throw this.runtime.exceptions.authentication(`Unauthorized: ${message}`);
+            case 404:
+                throw this.runtime.exceptions.notFound(`Not Found: ${message}`);
+            case 429:
+                throw this.runtime.exceptions.rateLimit(`Rate Limited: ${message}`);
+            case 500:
+            case 502:
+            case 503:
+            case 504:
+                throw this.runtime.exceptions.server(`Server Error: ${message}`);
+            default:
+                throw this.runtime.exceptions.server(`Unexpected response: ${statusCode} ${message}`);
+        }
+    }
+}
+
+class ApiClient {
+    constructor(config) {
+        this.core = new LicenseChainHttpCore({
+            apiKey: config.getApiKey(),
+            baseUrl: config.getBaseUrl(),
+            deserialize: jsonDeserialize,
+            exceptions: {
+                authentication: (message) => new AuthenticationError(message),
+                network: (message) => new NetworkError(message),
+                notFound: (message) => new NotFoundError(message),
+                rateLimit: (message) => new RateLimitError(message),
+                server: (message) => new ServerError(message),
+                validation: (message) => new ValidationError(message),
+            },
+            platform: 'javascript-sdk',
+            retries: config.getRetries(),
+            retryWithBackoff,
+            serialize: jsonSerialize,
+            timeout: config.getTimeout(),
+            userAgent: 'LicenseChain-JavaScript-SDK/1.0.0',
+        });
+    }
+    async get(endpoint, params) {
+        return this.core.get(endpoint, params);
+    }
+    async post(endpoint, data) {
+        return this.core.post(endpoint, data);
+    }
+    async put(endpoint, data) {
+        return this.core.put(endpoint, data);
+    }
+    async patch(endpoint, data) {
+        return this.core.patch(endpoint, data);
+    }
+    async delete(endpoint, data) {
+        return this.core.delete(endpoint, data);
+    }
+    async ping() {
+        return this.get('/health');
+    }
+    async health() {
+        return this.get('/health');
+    }
+}
+
+class LicenseService {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(request) {
+        const appId = request.app_id;
+        if (!appId) {
+            throw new ValidationException('app_id is required for API v1 license creation');
+        }
+        const data = {
+            appId,
+            plan: request.plan || 'FREE',
+            issuedEmail: request.issued_email,
+            expiresAt: request.expires_at
+        };
+        const response = await this.client.post(`/apps/${appId}/licenses`, data);
+        return this.extractLicenseResponse(response);
+    }
+    async get(licenseId) {
+        validateNotEmpty(licenseId, 'license_id');
+        const response = await this.client.get(`/licenses/${licenseId}`);
+        return this.extractLicenseResponse(response);
+    }
+    async update(licenseId, updates) {
+        validateNotEmpty(licenseId, 'license_id');
+        const response = await this.client.patch(`/licenses/${licenseId}`, sanitizeMetadata(updates));
+        return this.extractLicenseResponse(response);
+    }
+    async revoke(licenseId) {
+        validateNotEmpty(licenseId, 'license_id');
+        await this.client.delete(`/licenses/${licenseId}`);
+    }
+    async validate(licenseKey, hwuid) {
+        validateNotEmpty(licenseKey, 'license_key');
+        const body = { key: licenseKey };
+        body.hwuid = hwuid != null && String(hwuid).trim() !== '' ? hwuid.trim() : this.defaultHwuid();
+        const response = await this.client.post('/licenses/verify', body);
+        return response.valid || false;
+    }
+    /** Full POST /v1/licenses/verify JSON (optional license_token / license_jwks_uri). */
+    async verifyWithDetails(licenseKey, hwuid) {
+        validateNotEmpty(licenseKey, 'license_key');
+        const body = { key: licenseKey };
+        body.hwuid = hwuid != null && String(hwuid).trim() !== '' ? hwuid.trim() : this.defaultHwuid();
+        return this.client.post('/licenses/verify', body);
+    }
+    async listUserLicenses(userId, page, limit) {
+        validateNotEmpty(userId, 'user_id');
+        const [validPage, validLimit] = validatePagination(page, limit);
+        const response = await this.client.get('/licenses', {
+            page: validPage,
+            limit: validLimit
+        });
+        const allLicenses = response.licenses || response.data || [];
+        const filtered = allLicenses.filter((license) => license?.issuedEmail === userId ||
+            license?.email === userId ||
+            license?.user_id === userId);
+        return {
+            data: filtered,
+            total: filtered.length,
+            page: validPage,
+            limit: validLimit
+        };
+    }
+    async stats() {
+        const response = await this.client.get('/licenses/stats');
+        return response.data || response;
+    }
+    extractLicenseResponse(response) {
+        return response?.data ? response.data : response;
+    }
+    defaultHwuid() {
+        const g = globalThis;
+        if (g?.navigator) {
+            return createHash('sha256')
+                .update(`licensechain|js-browser|${g.navigator.userAgent}|${g.navigator.language}|${g.navigator.platform || 'unknown'}`)
+                .digest('hex');
+        }
+        if (typeof process !== 'undefined') {
+            return createHash('sha256')
+                .update(`licensechain|js-node|${process.platform}|${process.arch}|${process.version}`)
+                .digest('hex');
+        }
+        return createHash('sha256').update('licensechain|js|unknown|unknown|unknown').digest('hex');
+    }
+}
+
+class UserService {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(request) {
+        this.validateEmail(request.email);
+        const data = {
+            email: request.email,
+            password: request.password || 'ChangeMe123!',
+            name: request.name,
+            metadata: sanitizeMetadata(request.metadata || {})
+        };
+        const response = await this.client.post('/auth/register', data);
+        return (response.user || response.data);
+    }
+    async get(userId) {
+        validateNotEmpty(userId, 'user_id');
+        const response = await this.client.get('/auth/me');
+        return (response.data || response);
+    }
+    async update(userId, updates) {
+        validateNotEmpty(userId, 'user_id');
+        throw new ValidationException('User update endpoint is not available in API v1');
+    }
+    async delete(userId) {
+        validateNotEmpty(userId, 'user_id');
+        throw new ValidationException('User delete endpoint is not available in API v1');
+    }
+    async list(page, limit) {
+        const [validPage, validLimit] = validatePagination(page, limit);
+        return {
+            data: [],
+            total: 0,
+            page: validPage,
+            limit: validLimit
+        };
+    }
+    async stats() {
+        return { total: 0, active: 0, inactive: 0 };
+    }
+    validateEmail(email) {
+        validateNotEmpty(email, 'email');
+        if (!validateEmail(email)) {
+            throw new ValidationException('Invalid email format');
+        }
+    }
+}
+
+class ProductService {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(request) {
+        this.validateRequiredParams(request.name, request.price, request.currency);
+        throw new ValidationException('Product endpoints are not available in API v1');
+    }
+    async get(productId) {
+        validateNotEmpty(productId, 'product_id');
+        throw new ValidationException('Product endpoints are not available in API v1');
+    }
+    async update(productId, updates) {
+        validateNotEmpty(productId, 'product_id');
+        throw new ValidationException('Product endpoints are not available in API v1');
+    }
+    async delete(productId) {
+        validateNotEmpty(productId, 'product_id');
+        throw new ValidationException('Product endpoints are not available in API v1');
+    }
+    async list(page, limit) {
+        const [validPage, validLimit] = validatePagination(page, limit);
+        return {
+            data: [],
+            total: 0,
+            page: validPage,
+            limit: validLimit
+        };
+    }
+    async stats() {
+        return { total: 0, active: 0, revenue: 0 };
+    }
+    validateRequiredParams(name, price, currency) {
+        validateNotEmpty(name, 'name');
+        if (price !== undefined) {
+            validatePositive(price, 'price');
+        }
+        if (!validateCurrency(currency)) {
+            throw new ValidationException('Invalid currency');
+        }
+    }
+}
+
+class WebhookService {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(request) {
+        this.validateWebhookParams(request.url, request.events);
+        const data = {
+            url: request.url,
+            events: request.events,
+            secret: request.secret
+        };
+        const response = await this.client.post('/webhooks', data);
+        return this.normalizeWebhookPayload((response.data || response));
+    }
+    async get(webhookId) {
+        this.validateUuid(webhookId, 'webhook_id');
+        const response = await this.client.get(`/webhooks/${webhookId}`);
+        return this.normalizeWebhookPayload((response.data || response));
+    }
+    async update(webhookId, updates) {
+        this.validateUuid(webhookId, 'webhook_id');
+        const response = await this.client.put(`/webhooks/${webhookId}`, sanitizeMetadata(updates));
+        return this.normalizeWebhookPayload((response.data || response));
+    }
+    async delete(webhookId) {
+        this.validateUuid(webhookId, 'webhook_id');
+        await this.client.delete(`/webhooks/${webhookId}`);
+    }
+    async list() {
+        const response = await this.client.get('/webhooks');
+        const data = (response?.data || []).map((webhook) => this.normalizeWebhookPayload(webhook));
+        return {
+            data,
+            total: response?.pagination?.total || data.length,
+            page: response?.pagination?.page || 1,
+            limit: response?.pagination?.limit || data.length
+        };
+    }
+    validateWebhookParams(url, events) {
+        validateNotEmpty(url, 'url');
+        if (!events || events.length === 0) {
+            throw new ValidationException('Events cannot be empty');
+        }
+    }
+    validateUuid(id, fieldName) {
+        validateNotEmpty(id, fieldName);
+        if (!validateUuid(id)) {
+            throw new ValidationException(`Invalid ${fieldName} format`);
+        }
+    }
+    normalizeWebhookPayload(payload) {
+        return {
+            id: payload?.id,
+            url: payload?.url || '',
+            events: payload?.events || [],
+            secret: payload?.secret,
+            created_at: payload?.created_at || payload?.createdAt,
+            updated_at: payload?.updated_at || payload?.updatedAt
+        };
+    }
+}
+
+class LicenseChainClient {
+    constructor(config) {
+        if (config instanceof Configuration) {
+            this.config = config;
+        }
+        else {
+            this.config = new Configuration(config);
+        }
+        if (!this.config.isValid()) {
+            throw new ConfigurationError('API key is required');
+        }
+        this.apiClient = new ApiClient(this.config);
+        this.licenses = new LicenseService(this.apiClient);
+        this.users = new UserService(this.apiClient);
+        this.products = new ProductService(this.apiClient);
+        this.webhooks = new WebhookService(this.apiClient);
+    }
+    getConfiguration() {
+        return this.config;
+    }
+    getLicenses() {
+        return this.licenses;
+    }
+    getUsers() {
+        return this.users;
+    }
+    getProducts() {
+        return this.products;
+    }
+    getWebhooks() {
+        return this.webhooks;
+    }
+    async validateLicense(licenseKey, hwuid) {
+        const resolvedHwuid = hwuid && hwuid.trim() !== '' ? hwuid.trim() : this.defaultHwuid();
+        const valid = await this.licenses.validate(licenseKey, resolvedHwuid);
+        return { valid };
+    }
+    async ping() {
+        return this.apiClient.ping();
+    }
+    async health() {
+        return this.apiClient.health();
+    }
+    static create(apiKey, baseUrl) {
+        return new LicenseChainClient({
+            apiKey,
+            baseUrl: baseUrl || 'https://api.licensechain.app/v1'
+        });
+    }
+    static fromEnvironment() {
+        return new LicenseChainClient(Configuration.fromEnvironment());
+    }
+    updateConfig(config) {
+        if (config.apiKey)
+            this.config.setApiKey(config.apiKey);
+        if (config.baseUrl)
+            this.config.setBaseUrl(config.baseUrl);
+        if (typeof config.timeout === 'number')
+            this.config.setTimeout(config.timeout);
+        if (typeof config.retries === 'number')
+            this.config.setRetries(config.retries);
+        this.apiClient = new ApiClient(this.config);
+        this.licenses = new LicenseService(this.apiClient);
+        this.users = new UserService(this.apiClient);
+        this.products = new ProductService(this.apiClient);
+        this.webhooks = new WebhookService(this.apiClient);
+    }
+    defaultHwuid() {
+        const g = globalThis;
+        if (g?.navigator) {
+            return createHash('sha256')
+                .update(`licensechain|js-browser|${g.navigator.userAgent}|${g.navigator.language}|${g.navigator.platform || 'unknown'}`)
+                .digest('hex');
+        }
+        if (typeof process !== 'undefined') {
+            return createHash('sha256')
+                .update(`licensechain|js-node|${process.platform}|${process.arch}|${process.version}`)
+                .digest('hex');
+        }
+        return createHash('sha256').update('licensechain|js|unknown|unknown|unknown').digest('hex');
+    }
+}
+
+class WebhookHandler {
+    constructor(secret, tolerance = 300) {
+        this.secret = secret;
+        this.tolerance = tolerance; // seconds
+    }
+    verifySignature(payload, signature) {
+        return verifyWebhookSignature(payload, signature, this.secret);
+    }
+    verifyTimestamp(timestamp) {
+        try {
+            const webhookTime = new Date(timestamp);
+            const currentTime = new Date();
+            const timeDiff = Math.abs((currentTime.getTime() - webhookTime.getTime()) / 1000);
+            if (timeDiff > this.tolerance) {
+                throw new ValidationException(`Webhook timestamp too old: ${timeDiff} seconds`);
+            }
+        }
+        catch (error) {
+            throw new ValidationException(`Invalid timestamp format: ${error}`);
+        }
+    }
+    verifyWebhook(payload, signature, timestamp) {
+        this.verifyTimestamp(timestamp);
+        if (!this.verifySignature(payload, signature)) {
+            throw new AuthenticationException('Invalid webhook signature');
+        }
+    }
+    processEvent(eventData) {
+        const payload = jsonSerialize(eventData.data || {});
+        this.verifyWebhook(payload, eventData.signature, eventData.timestamp);
+        const eventType = eventData.type || '';
+        switch (eventType) {
+            case 'license.created':
+                this.handleLicenseCreated(eventData);
+                break;
+            case 'license.updated':
+                this.handleLicenseUpdated(eventData);
+                break;
+            case 'license.revoked':
+                this.handleLicenseRevoked(eventData);
+                break;
+            case 'license.expired':
+                this.handleLicenseExpired(eventData);
+                break;
+            case 'user.created':
+                this.handleUserCreated(eventData);
+                break;
+            case 'user.updated':
+                this.handleUserUpdated(eventData);
+                break;
+            case 'user.deleted':
+                this.handleUserDeleted(eventData);
+                break;
+            case 'product.created':
+                this.handleProductCreated(eventData);
+                break;
+            case 'product.updated':
+                this.handleProductUpdated(eventData);
+                break;
+            case 'product.deleted':
+                this.handleProductDeleted(eventData);
+                break;
+            case 'payment.completed':
+                this.handlePaymentCompleted(eventData);
+                break;
+            case 'payment.failed':
+                this.handlePaymentFailed(eventData);
+                break;
+            case 'payment.refunded':
+                this.handlePaymentRefunded(eventData);
+                break;
+            default:
+                console.log(`Unknown webhook event type: ${eventType}`);
+        }
+    }
+    handleLicenseCreated(eventData) {
+        console.log(`License created: ${eventData.id}`);
+        // Add custom logic for license created event
+    }
+    handleLicenseUpdated(eventData) {
+        console.log(`License updated: ${eventData.id}`);
+        // Add custom logic for license updated event
+    }
+    handleLicenseRevoked(eventData) {
+        console.log(`License revoked: ${eventData.id}`);
+        // Add custom logic for license revoked event
+    }
+    handleLicenseExpired(eventData) {
+        console.log(`License expired: ${eventData.id}`);
+        // Add custom logic for license expired event
+    }
+    handleUserCreated(eventData) {
+        console.log(`User created: ${eventData.id}`);
+        // Add custom logic for user created event
+    }
+    handleUserUpdated(eventData) {
+        console.log(`User updated: ${eventData.id}`);
+        // Add custom logic for user updated event
+    }
+    handleUserDeleted(eventData) {
+        console.log(`User deleted: ${eventData.id}`);
+        // Add custom logic for user deleted event
+    }
+    handleProductCreated(eventData) {
+        console.log(`Product created: ${eventData.id}`);
+        // Add custom logic for product created event
+    }
+    handleProductUpdated(eventData) {
+        console.log(`Product updated: ${eventData.id}`);
+        // Add custom logic for product updated event
+    }
+    handleProductDeleted(eventData) {
+        console.log(`Product deleted: ${eventData.id}`);
+        // Add custom logic for product deleted event
+    }
+    handlePaymentCompleted(eventData) {
+        console.log(`Payment completed: ${eventData.id}`);
+        // Add custom logic for payment completed event
+    }
+    handlePaymentFailed(eventData) {
+        console.log(`Payment failed: ${eventData.id}`);
+        // Add custom logic for payment failed event
+    }
+    handlePaymentRefunded(eventData) {
+        console.log(`Payment refunded: ${eventData.id}`);
+        // Add custom logic for payment refunded event
+    }
+}
+class WebhookEvents {
+}
+WebhookEvents.LICENSE_CREATED = 'license.created';
+WebhookEvents.LICENSE_UPDATED = 'license.updated';
+WebhookEvents.LICENSE_REVOKED = 'license.revoked';
+WebhookEvents.LICENSE_EXPIRED = 'license.expired';
+WebhookEvents.USER_CREATED = 'user.created';
+WebhookEvents.USER_UPDATED = 'user.updated';
+WebhookEvents.USER_DELETED = 'user.deleted';
+WebhookEvents.PRODUCT_CREATED = 'product.created';
+WebhookEvents.PRODUCT_UPDATED = 'product.updated';
+WebhookEvents.PRODUCT_DELETED = 'product.deleted';
+WebhookEvents.PAYMENT_COMPLETED = 'payment.completed';
+WebhookEvents.PAYMENT_FAILED = 'payment.failed';
+WebhookEvents.PAYMENT_REFUNDED = 'payment.refunded';
+function createOutgoingWebhookSignature(payload, secret) {
+    const crypto = require('crypto');
+    return crypto.createHmac('sha256', secret).update(payload).digest('hex');
+}
+function verifyIncomingWebhookSignature(payload, signature, secret) {
+    return verifyWebhookSignature(payload, signature, secret);
+}
+
+/**
+ * LicenseChain License Validator
+ *
+ * Easy-to-use license validation functionality.
+ */
+class LicenseValidator {
+    constructor(config) {
+        this.client = new LicenseChainClient(config);
+    }
+    /**
+     * Validate a license key
+     */
+    async validateLicense(licenseKey, appId, context) {
+        try {
+            const result = await this.client.validateLicense(licenseKey, appId);
+            return result;
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Check if license is valid (quick check)
+     */
+    async isValid(licenseKey, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            return result.valid;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get license information
+     */
+    async getLicenseInfo(licenseKey, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            return result.valid ? result : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if license is expired
+     */
+    async isExpired(licenseKey, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            if (!result.valid || !result.license) {
+                return true;
+            }
+            const expiresAt = result.license.expiresAt;
+            if (!expiresAt) {
+                return false;
+            }
+            return new Date(expiresAt) < new Date();
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Get days until expiration
+     */
+    async getDaysUntilExpiration(licenseKey, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            if (!result.valid || !result.license) {
+                return null;
+            }
+            const expiresAt = result.license.expiresAt;
+            if (!expiresAt) {
+                return null;
+            }
+            const expDate = new Date(expiresAt);
+            const now = new Date();
+            const diffTime = expDate.getTime() - now.getTime();
+            const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+            return Math.max(0, diffDays);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Validate multiple licenses
+     */
+    async validateLicenses(licenseKeys, appId) {
+        const promises = licenseKeys.map(key => this.validateLicense(key, appId));
+        return Promise.all(promises);
+    }
+    /**
+     * Validate with custom validation rules
+     */
+    async validateWithRules(licenseKey, rules, appId) {
+        const result = await this.validateLicense(licenseKey, appId);
+        if (!result.valid || !rules) {
+            return result;
+        }
+        // Apply custom validation rules
+        if (rules.maxUsage && result.license?.usageCount && result.license.usageCount > rules.maxUsage) {
+            return {
+                ...result,
+                valid: false,
+                error: 'Usage limit exceeded',
+            };
+        }
+        if (rules.allowedFeatures && result.license?.features) {
+            const invalidFeatures = result.license.features.filter((feature) => !rules.allowedFeatures.includes(feature));
+            if (invalidFeatures.length > 0) {
+                return {
+                    ...result,
+                    valid: false,
+                    error: `Invalid features: ${invalidFeatures.join(', ')}`,
+                };
+            }
+        }
+        if (rules.requiredFeatures && result.license?.features) {
+            const missingFeatures = rules.requiredFeatures.filter(feature => !result.license.features.includes(feature));
+            if (missingFeatures.length > 0) {
+                return {
+                    ...result,
+                    valid: false,
+                    error: `Missing required features: ${missingFeatures.join(', ')}`,
+                };
+            }
+        }
+        if (rules.allowedDomains && result.license?.metadata?.domain) {
+            const domain = result.license.metadata.domain;
+            if (!rules.allowedDomains.includes(domain)) {
+                return {
+                    ...result,
+                    valid: false,
+                    error: `Domain not allowed: ${domain}`,
+                };
+            }
+        }
+        if (rules.allowedIPs && result.license?.metadata?.ipAddress) {
+            const ipAddress = result.license.metadata.ipAddress;
+            if (!rules.allowedIPs.includes(ipAddress)) {
+                return {
+                    ...result,
+                    valid: false,
+                    error: `IP address not allowed: ${ipAddress}`,
+                };
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if license has specific feature
+     */
+    async hasFeature(licenseKey, feature, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            return result.valid && result.license?.features?.includes(feature) || false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get license usage count
+     */
+    async getUsageCount(licenseKey, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            return result.valid ? result.license?.usageCount || 0 : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get license metadata
+     */
+    async getMetadata(licenseKey, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            return result.valid ? result.license?.metadata || {} : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get license features
+     */
+    async getFeatures(licenseKey, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            return result.valid ? result.license?.features || [] : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get user information from license
+     */
+    async getUserInfo(licenseKey, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            if (!result.valid) {
+                return null;
+            }
+            return {
+                email: result.user?.email,
+                name: result.user?.name,
+                id: result.user?.id,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get application information from license
+     */
+    async getAppInfo(licenseKey, appId) {
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            if (!result.valid) {
+                return null;
+            }
+            return {
+                name: result.app?.name,
+                id: result.app?.id,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Validate license with context
+     */
+    async validateWithContext(context) {
+        const { licenseKey, appId, ...additionalContext } = context;
+        try {
+            const result = await this.validateLicense(licenseKey, appId);
+            if (!result.valid) {
+                return result;
+            }
+            // Add context validation logic here
+            // For example, validate IP address, user agent, etc.
+            return result;
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Batch validate licenses with rules
+     */
+    async batchValidateWithRules(licenses) {
+        const promises = licenses.map(({ licenseKey, appId, rules }) => rules
+            ? this.validateWithRules(licenseKey, rules, appId)
+            : this.validateLicense(licenseKey, appId));
+        return Promise.all(promises);
+    }
+    /**
+     * Get client instance for advanced operations
+     */
+    getClient() {
+        return this.client;
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.client.updateConfig(config);
+    }
+}
+
+/** Must match Core API `LICENSE_TOKEN_USE_CLAIM`. */
+const LICENSE_TOKEN_USE_CLAIM = 'licensechain_license_v1';
+/**
+ * Verify a `license_token` from POST /v1/licenses/verify using the JWKS URL
+ * from the same response (`license_jwks_uri`) or `GET /v1/licenses/jwks`.
+ * Same contract as `licensechain-node-sdk` — also exported from the package root (`dist/index.js`).
+ */
+async function verifyLicenseAssertionJwt(token, jwksUrl, options) {
+    const JWKS = jose.createRemoteJWKSet(new URL(String(jwksUrl).trim()));
+    const { payload } = await jose.jwtVerify(String(token).trim(), JWKS, {
+        algorithms: ['RS256'],
+        ...(options?.issuer ? { issuer: options.issuer } : {}),
+    });
+    if (payload.token_use !== LICENSE_TOKEN_USE_CLAIM) {
+        throw new Error(`Invalid license token: expected token_use "${LICENSE_TOKEN_USE_CLAIM}"`);
+    }
+    if (options?.expectedAppId != null && options.expectedAppId !== '' && payload.aud !== options.expectedAppId) {
+        throw new Error('Invalid license token: aud does not match expected app id');
+    }
+    return payload;
+}
+
+export { ApiClient, AuthenticationError, AuthenticationException, Configuration, ConfigurationError, ConfigurationException, LICENSE_TOKEN_USE_CLAIM, LicenseChainClient, LicenseChainException, LicenseService, LicenseValidationError, LicenseValidator, NetworkError, NetworkException, NotFoundError, NotFoundException, ProductService, RateLimitError, RateLimitException, ServerError, ServerException, TimeoutError, UserService, ValidationError, ValidationException, WebhookEvents, WebhookHandler, WebhookService, WebhookVerificationError, base64Decode, base64Encode, capitalizeFirst, chunkArray, createErrorFromResponse, createOutgoingWebhookSignature, createWebhookSignature, debounce, deepMerge, LicenseChainClient as default, flattenObject, formatBytes, formatDuration, formatTimestamp, generateLicenseKey, generateRandomBytes, generateRandomString, generateUuid, getCurrentDate, getCurrentDateFormatted, getCurrentTimestamp, isLicenseChainError, isRetryableError, isValidEmail, isValidIp, isValidJson, isValidUrl, jsonDeserialize, jsonSerialize, md5, parseTimestamp, removeSpecialChars, retryWithBackoff, sanitizeInput, sanitizeMetadata, sha1, sha256, sleep, slugify, throttle, toPascalCase, toSnakeCase, truncateString, unflattenObject, urlDecode, urlEncode, validateAmount, validateCurrency, validateDateRange, validateEmail, validateLicenseKey, validateNotEmpty, validatePagination, validatePositive, validateRange, validateStatus, validateUuid, verifyIncomingWebhookSignature, verifyLicenseAssertionJwt, verifyWebhookSignature };
+//# sourceMappingURL=index.esm.js.map