@licensechain/javascript-sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,763 @@
+import * as jose from 'jose';
+
+interface ConfigurationOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+}
+declare class Configuration {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    private retries;
+    constructor(options: ConfigurationOptions);
+    getApiKey(): string;
+    getBaseUrl(): string;
+    getTimeout(): number;
+    getRetries(): number;
+    isValid(): boolean;
+    setApiKey(apiKey: string): this;
+    setBaseUrl(baseUrl: string): this;
+    setTimeout(timeout: number): this;
+    setRetries(retries: number): this;
+    toObject(): ConfigurationOptions;
+    static fromObject(config: ConfigurationOptions): Configuration;
+    static fromEnvironment(): Configuration;
+}
+
+declare class ApiClient {
+    private readonly core;
+    constructor(config: Configuration);
+    get<T = any>(endpoint: string, params?: Record<string, any>): Promise<T>;
+    post<T = any>(endpoint: string, data?: any): Promise<T>;
+    put<T = any>(endpoint: string, data?: any): Promise<T>;
+    patch<T = any>(endpoint: string, data?: any): Promise<T>;
+    delete<T = any>(endpoint: string, data?: any): Promise<T>;
+    ping(): Promise<any>;
+    health(): Promise<any>;
+}
+
+interface License$1 {
+    id: string;
+    user_id: string;
+    product_id: string;
+    license_key: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    expires_at?: string;
+    metadata?: Record<string, any>;
+}
+interface CreateLicenseRequest$1 {
+    user_id?: string;
+    product_id?: string;
+    app_id?: string;
+    plan?: 'FREE' | 'PRO' | 'BUSINESS' | 'ENTERPRISE';
+    issued_email?: string;
+    expires_at?: string;
+    metadata?: Record<string, any>;
+}
+interface UpdateLicenseRequest$1 {
+    status?: string;
+    expires_at?: string;
+    metadata?: Record<string, any>;
+}
+interface LicenseListResponse {
+    data: License$1[];
+    total: number;
+    page: number;
+    limit: number;
+}
+interface LicenseStats {
+    total: number;
+    active: number;
+    expired: number;
+    revoked: number;
+    revenue: number;
+}
+declare class LicenseService {
+    private client;
+    constructor(client: ApiClient);
+    create(request: CreateLicenseRequest$1): Promise<License$1>;
+    get(licenseId: string): Promise<License$1>;
+    update(licenseId: string, updates: UpdateLicenseRequest$1): Promise<License$1>;
+    revoke(licenseId: string): Promise<void>;
+    validate(licenseKey: string, hwuid?: string | null): Promise<boolean>;
+    /** Full POST /v1/licenses/verify JSON (optional license_token / license_jwks_uri). */
+    verifyWithDetails(licenseKey: string, hwuid?: string | null): Promise<Record<string, unknown>>;
+    listUserLicenses(userId: string, page?: number, limit?: number): Promise<LicenseListResponse>;
+    stats(): Promise<LicenseStats>;
+    private extractLicenseResponse;
+    private defaultHwuid;
+}
+
+interface User$1 {
+    id: string;
+    email: string;
+    name: string;
+    created_at: string;
+    updated_at: string;
+    metadata?: Record<string, any>;
+}
+interface CreateUserRequest {
+    email: string;
+    name: string;
+    password?: string;
+    metadata?: Record<string, any>;
+}
+interface UpdateUserRequest {
+    email?: string;
+    name?: string;
+    metadata?: Record<string, any>;
+}
+interface UserListResponse {
+    data: User$1[];
+    total: number;
+    page: number;
+    limit: number;
+}
+interface UserStats {
+    total: number;
+    active: number;
+    inactive: number;
+}
+declare class UserService {
+    private client;
+    constructor(client: ApiClient);
+    create(request: CreateUserRequest): Promise<User$1>;
+    get(userId: string): Promise<User$1>;
+    update(userId: string, updates: UpdateUserRequest): Promise<User$1>;
+    delete(userId: string): Promise<void>;
+    list(page?: number, limit?: number): Promise<UserListResponse>;
+    stats(): Promise<UserStats>;
+    private validateEmail;
+}
+
+interface Product {
+    id: string;
+    name: string;
+    description?: string;
+    price: number;
+    currency: string;
+    created_at: string;
+    updated_at: string;
+    metadata?: Record<string, any>;
+}
+interface CreateProductRequest {
+    name: string;
+    description?: string;
+    price: number;
+    currency: string;
+    metadata?: Record<string, any>;
+}
+interface UpdateProductRequest {
+    name?: string;
+    description?: string;
+    price?: number;
+    currency?: string;
+    metadata?: Record<string, any>;
+}
+interface ProductListResponse {
+    data: Product[];
+    total: number;
+    page: number;
+    limit: number;
+}
+interface ProductStats {
+    total: number;
+    active: number;
+    revenue: number;
+}
+declare class ProductService {
+    private client;
+    constructor(client: ApiClient);
+    create(request: CreateProductRequest): Promise<Product>;
+    get(productId: string): Promise<Product>;
+    update(productId: string, updates: UpdateProductRequest): Promise<Product>;
+    delete(productId: string): Promise<void>;
+    list(page?: number, limit?: number): Promise<ProductListResponse>;
+    stats(): Promise<ProductStats>;
+    private validateRequiredParams;
+}
+
+interface Webhook$1 {
+    id: string;
+    url: string;
+    events: string[];
+    secret?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateWebhookRequest$1 {
+    url: string;
+    events: string[];
+    secret?: string;
+}
+interface UpdateWebhookRequest$1 {
+    url?: string;
+    events?: string[];
+    secret?: string;
+}
+interface WebhookListResponse {
+    data: Webhook$1[];
+    total: number;
+    page: number;
+    limit: number;
+}
+declare class WebhookService {
+    private client;
+    constructor(client: ApiClient);
+    create(request: CreateWebhookRequest$1): Promise<Webhook$1>;
+    get(webhookId: string): Promise<Webhook$1>;
+    update(webhookId: string, updates: UpdateWebhookRequest$1): Promise<Webhook$1>;
+    delete(webhookId: string): Promise<void>;
+    list(): Promise<WebhookListResponse>;
+    private validateWebhookParams;
+    private validateUuid;
+    private normalizeWebhookPayload;
+}
+
+declare class LicenseChainClient {
+    private config;
+    private apiClient;
+    private licenses;
+    private users;
+    private products;
+    private webhooks;
+    constructor(config: Configuration | ConfigurationOptions);
+    getConfiguration(): Configuration;
+    getLicenses(): LicenseService;
+    getUsers(): UserService;
+    getProducts(): ProductService;
+    getWebhooks(): WebhookService;
+    validateLicense(licenseKey: string, hwuid?: string): Promise<{
+        valid: boolean;
+    }>;
+    ping(): Promise<any>;
+    health(): Promise<any>;
+    static create(apiKey: string, baseUrl?: string): LicenseChainClient;
+    static fromEnvironment(): LicenseChainClient;
+    updateConfig(config: {
+        apiKey?: string;
+        baseUrl?: string;
+        timeout?: number;
+        retries?: number;
+    }): void;
+    private defaultHwuid;
+}
+
+declare class WebhookHandler {
+    private secret;
+    private tolerance;
+    constructor(secret: string, tolerance?: number);
+    verifySignature(payload: string, signature: string): boolean;
+    verifyTimestamp(timestamp: string): void;
+    verifyWebhook(payload: string, signature: string, timestamp: string): void;
+    processEvent(eventData: any): void;
+    private handleLicenseCreated;
+    private handleLicenseUpdated;
+    private handleLicenseRevoked;
+    private handleLicenseExpired;
+    private handleUserCreated;
+    private handleUserUpdated;
+    private handleUserDeleted;
+    private handleProductCreated;
+    private handleProductUpdated;
+    private handleProductDeleted;
+    private handlePaymentCompleted;
+    private handlePaymentFailed;
+    private handlePaymentRefunded;
+}
+declare class WebhookEvents {
+    static readonly LICENSE_CREATED = "license.created";
+    static readonly LICENSE_UPDATED = "license.updated";
+    static readonly LICENSE_REVOKED = "license.revoked";
+    static readonly LICENSE_EXPIRED = "license.expired";
+    static readonly USER_CREATED = "user.created";
+    static readonly USER_UPDATED = "user.updated";
+    static readonly USER_DELETED = "user.deleted";
+    static readonly PRODUCT_CREATED = "product.created";
+    static readonly PRODUCT_UPDATED = "product.updated";
+    static readonly PRODUCT_DELETED = "product.deleted";
+    static readonly PAYMENT_COMPLETED = "payment.completed";
+    static readonly PAYMENT_FAILED = "payment.failed";
+    static readonly PAYMENT_REFUNDED = "payment.refunded";
+}
+declare function createOutgoingWebhookSignature(payload: string, secret: string): string;
+declare function verifyIncomingWebhookSignature(payload: string, signature: string, secret: string): boolean;
+
+/**
+ * TypeScript type definitions for LicenseChain JavaScript SDK
+ */
+interface LicenseChainConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+interface User {
+    id?: string;
+    email: string;
+    name?: string;
+    company?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    emailVerified?: boolean;
+    status?: string;
+}
+interface Application {
+    id?: string;
+    name: string;
+    description?: string;
+    apiKey?: string;
+    webhookUrl?: string;
+    allowedOrigins?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+    status?: string;
+    licenseCount?: number;
+}
+interface License {
+    id?: string;
+    key?: string;
+    appId: string;
+    userId?: string;
+    userEmail: string;
+    userName?: string;
+    status?: string;
+    expiresAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    metadata?: Record<string, any>;
+    features?: string[];
+    usageCount?: number;
+}
+interface Webhook {
+    id?: string;
+    appId: string;
+    url: string;
+    events?: string[];
+    secret?: string;
+    status?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    lastTriggeredAt?: string;
+    failureCount?: number;
+}
+interface Analytics {
+    totalLicenses?: number;
+    activeLicenses?: number;
+    expiredLicenses?: number;
+    revokedLicenses?: number;
+    validationsToday?: number;
+    validationsThisWeek?: number;
+    validationsThisMonth?: number;
+    topFeatures?: string[];
+    usageByDay?: Array<Record<string, any>>;
+    usageByWeek?: Array<Record<string, any>>;
+    usageByMonth?: Array<Record<string, any>>;
+}
+interface PaginatedResponse<T = any> {
+    data: T[];
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+}
+interface ValidationResult {
+    valid: boolean;
+    license?: Record<string, any>;
+    user?: Record<string, any>;
+    app?: Record<string, any>;
+    expiresAt?: string;
+    metadata?: Record<string, any>;
+    error?: string;
+}
+interface ApiResponse<T = any> {
+    data?: T;
+    error?: string;
+    message?: string;
+    status?: number;
+}
+interface RequestOptions {
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+    headers?: Record<string, string>;
+}
+interface WebhookEvent {
+    id: string;
+    type: string;
+    createdAt: string;
+    data: Record<string, any>;
+}
+interface WebhookPayload {
+    id: string;
+    type: string;
+    createdAt: string;
+    data: Record<string, any>;
+    signature?: string;
+}
+interface LicenseValidationRules {
+    maxUsage?: number;
+    allowedFeatures?: string[];
+    requiredFeatures?: string[];
+    maxConcurrentUsers?: number;
+    allowedDomains?: string[];
+    allowedIPs?: string[];
+}
+interface CreateLicenseRequest {
+    appId: string;
+    userEmail: string;
+    userName?: string;
+    expiresAt?: string;
+    metadata?: Record<string, any>;
+    features?: string[];
+}
+interface UpdateLicenseRequest {
+    status?: string;
+    expiresAt?: string;
+    metadata?: Record<string, any>;
+    features?: string[];
+}
+interface CreateApplicationRequest {
+    name: string;
+    description?: string;
+    webhookUrl?: string;
+    allowedOrigins?: string[];
+}
+interface UpdateApplicationRequest {
+    name?: string;
+    description?: string;
+    webhookUrl?: string;
+    allowedOrigins?: string[];
+}
+interface CreateWebhookRequest {
+    appId: string;
+    url: string;
+    events: string[];
+    secret?: string;
+}
+interface UpdateWebhookRequest {
+    url?: string;
+    events?: string[];
+    secret?: string;
+    status?: string;
+}
+interface ListOptions {
+    page?: number;
+    limit?: number;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    filter?: Record<string, any>;
+}
+interface LicenseListOptions extends ListOptions {
+    appId?: string;
+    status?: string;
+    userId?: string;
+    userEmail?: string;
+}
+interface ApplicationListOptions extends ListOptions {
+    status?: string;
+}
+interface WebhookListOptions extends ListOptions {
+    appId?: string;
+    status?: string;
+}
+interface AnalyticsOptions {
+    appId?: string;
+    startDate?: string;
+    endDate?: string;
+    metric?: string;
+    period?: string;
+}
+interface UsageStatsOptions {
+    appId?: string;
+    period?: string;
+    granularity?: 'day' | 'week' | 'month';
+}
+interface PaginationInfo {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    nextPage?: number;
+    previousPage?: number;
+}
+interface ErrorResponse {
+    error: string;
+    message?: string;
+    code?: string;
+    details?: Record<string, any>;
+    timestamp?: string;
+}
+interface RateLimitInfo {
+    limit: number;
+    remaining: number;
+    reset: number;
+    retryAfter?: number;
+}
+interface ClientInfo {
+    version: string;
+    userAgent: string;
+    platform?: string;
+    language?: string;
+}
+interface WebhookVerificationResult {
+    valid: boolean;
+    event?: WebhookEvent;
+    error?: string;
+}
+interface LicenseValidationContext {
+    licenseKey: string;
+    appId?: string;
+    userId?: string;
+    userEmail?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    timestamp?: string;
+    metadata?: Record<string, any>;
+}
+
+/**
+ * LicenseChain License Validator
+ *
+ * Easy-to-use license validation functionality.
+ */
+
+declare class LicenseValidator {
+    private client;
+    constructor(config: {
+        apiKey: string;
+        baseUrl?: string;
+        timeout?: number;
+        retryAttempts?: number;
+        retryDelay?: number;
+    });
+    /**
+     * Validate a license key
+     */
+    validateLicense(licenseKey: string, appId?: string, context?: Partial<LicenseValidationContext>): Promise<ValidationResult>;
+    /**
+     * Check if license is valid (quick check)
+     */
+    isValid(licenseKey: string, appId?: string): Promise<boolean>;
+    /**
+     * Get license information
+     */
+    getLicenseInfo(licenseKey: string, appId?: string): Promise<ValidationResult | null>;
+    /**
+     * Check if license is expired
+     */
+    isExpired(licenseKey: string, appId?: string): Promise<boolean>;
+    /**
+     * Get days until expiration
+     */
+    getDaysUntilExpiration(licenseKey: string, appId?: string): Promise<number | null>;
+    /**
+     * Validate multiple licenses
+     */
+    validateLicenses(licenseKeys: string[], appId?: string): Promise<ValidationResult[]>;
+    /**
+     * Validate with custom validation rules
+     */
+    validateWithRules(licenseKey: string, rules: LicenseValidationRules, appId?: string): Promise<ValidationResult>;
+    /**
+     * Check if license has specific feature
+     */
+    hasFeature(licenseKey: string, feature: string, appId?: string): Promise<boolean>;
+    /**
+     * Get license usage count
+     */
+    getUsageCount(licenseKey: string, appId?: string): Promise<number | null>;
+    /**
+     * Get license metadata
+     */
+    getMetadata(licenseKey: string, appId?: string): Promise<Record<string, any> | null>;
+    /**
+     * Get license features
+     */
+    getFeatures(licenseKey: string, appId?: string): Promise<string[]>;
+    /**
+     * Get user information from license
+     */
+    getUserInfo(licenseKey: string, appId?: string): Promise<{
+        email?: string;
+        name?: string;
+        id?: string;
+    } | null>;
+    /**
+     * Get application information from license
+     */
+    getAppInfo(licenseKey: string, appId?: string): Promise<{
+        name?: string;
+        id?: string;
+    } | null>;
+    /**
+     * Validate license with context
+     */
+    validateWithContext(context: LicenseValidationContext): Promise<ValidationResult>;
+    /**
+     * Batch validate licenses with rules
+     */
+    batchValidateWithRules(licenses: Array<{
+        licenseKey: string;
+        appId?: string;
+        rules?: LicenseValidationRules;
+    }>): Promise<ValidationResult[]>;
+    /**
+     * Get client instance for advanced operations
+     */
+    getClient(): LicenseChainClient;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: {
+        apiKey?: string;
+        baseUrl?: string;
+        timeout?: number;
+        retryAttempts?: number;
+        retryDelay?: number;
+    }): void;
+}
+
+/** Must match Core API `LICENSE_TOKEN_USE_CLAIM`. */
+declare const LICENSE_TOKEN_USE_CLAIM = "licensechain_license_v1";
+type VerifyLicenseAssertionOptions = {
+    /** When set, payload `aud` must equal this Dashboard app id. */
+    expectedAppId?: string;
+    /** When set, passed to JWT issuer verification. */
+    issuer?: string;
+};
+/**
+ * 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`).
+ */
+declare function verifyLicenseAssertionJwt(token: string, jwksUrl: string, options?: VerifyLicenseAssertionOptions): Promise<jose.JWTPayload>;
+
+/**
+ * LicenseChain JavaScript SDK Exceptions
+ *
+ * Custom exceptions for the LicenseChain JavaScript SDK.
+ */
+declare class LicenseChainException extends Error {
+    readonly code?: string;
+    readonly statusCode?: number;
+    readonly details?: Record<string, any>;
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class AuthenticationError extends LicenseChainException {
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class ValidationError extends LicenseChainException {
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class NotFoundError extends LicenseChainException {
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class RateLimitError extends LicenseChainException {
+    readonly retryAfter?: number;
+    readonly limit?: number;
+    readonly remaining?: number;
+    readonly reset?: number;
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>, retryAfter?: number, limit?: number, remaining?: number, reset?: number);
+}
+declare class ServerError extends LicenseChainException {
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class NetworkError extends LicenseChainException {
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class WebhookVerificationError extends LicenseChainException {
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class LicenseValidationError extends LicenseChainException {
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class ConfigurationError extends LicenseChainException {
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class TimeoutError extends LicenseChainException {
+    constructor(message?: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+declare const NetworkException: typeof NetworkError;
+declare const ServerException: typeof ServerError;
+declare const ValidationException: typeof ValidationError;
+declare const AuthenticationException: typeof AuthenticationError;
+declare const NotFoundException: typeof NotFoundError;
+declare const RateLimitException: typeof RateLimitError;
+declare const ConfigurationException: typeof ConfigurationError;
+/**
+ * Error factory for creating appropriate exceptions based on HTTP status codes
+ */
+declare function createErrorFromResponse(statusCode: number, message: string, code?: string, details?: Record<string, any>): LicenseChainException;
+/**
+ * Check if an error is a LicenseChain exception
+ */
+declare function isLicenseChainError(error: any): error is LicenseChainException;
+/**
+ * Check if an error is a retryable error
+ */
+declare function isRetryableError(error: any): boolean;
+
+declare function validateEmail(email: string): boolean;
+declare function validateLicenseKey(licenseKey: string): boolean;
+declare function validateUuid(uuid: string): boolean;
+declare function validateAmount(amount: number): boolean;
+declare function validateCurrency(currency: string): boolean;
+declare function validateStatus(status: string, allowedStatuses: string[]): boolean;
+declare function sanitizeInput(input: string): string;
+declare function sanitizeMetadata(metadata: Record<string, any>): Record<string, any>;
+declare function generateLicenseKey(): string;
+declare function generateUuid(): string;
+declare function formatTimestamp(timestamp: number): string;
+declare function parseTimestamp(timestamp: string): number;
+declare function validatePagination(page?: number, limit?: number): [number, number];
+declare function validateDateRange(startDate: string, endDate: string): void;
+declare function createWebhookSignature(payload: string, secret: string): string;
+declare function verifyWebhookSignature(payload: string, signature: string, secret: string): boolean;
+declare function retryWithBackoff<T>(fn: () => Promise<T>, maxRetries?: number, initialDelay?: number): Promise<T>;
+declare function formatBytes(bytes: number): string;
+declare function formatDuration(seconds: number): string;
+declare function capitalizeFirst(text: string): string;
+declare function toSnakeCase(text: string): string;
+declare function toPascalCase(text: string): string;
+declare function truncateString(text: string, maxLength: number): string;
+declare function removeSpecialChars(text: string): string;
+declare function slugify(text: string): string;
+declare function validateNotEmpty(value: string, fieldName: string): void;
+declare function validatePositive(value: number, fieldName: string): void;
+declare function validateRange(value: number, min: number, max: number, fieldName: string): void;
+declare function jsonSerialize(obj: any): string;
+declare function jsonDeserialize(jsonString: string): any;
+declare function deepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any>;
+declare function chunkArray<T>(array: T[], chunkSize: number): T[][];
+declare function flattenObject(obj: Record<string, any>, separator?: string): Record<string, any>;
+declare function unflattenObject(obj: Record<string, any>, separator?: string): Record<string, any>;
+declare function generateRandomString(length: number, characters?: string): string;
+declare function generateRandomBytes(length: number): Buffer;
+declare function sha256(data: string): string;
+declare function sha1(data: string): string;
+declare function md5(data: string): string;
+declare function base64Encode(data: string): string;
+declare function base64Decode(data: string): string;
+declare function urlEncode(data: string): string;
+declare function urlDecode(data: string): string;
+declare function isValidJson(jsonString: string): boolean;
+declare function isValidUrl(url: string): boolean;
+declare function isValidIp(ip: string): boolean;
+declare function isValidEmail(email: string): boolean;
+declare function getCurrentTimestamp(): number;
+declare function getCurrentDate(): string;
+declare function getCurrentDateFormatted(format: string): string;
+declare function sleep(ms: number): Promise<void>;
+declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+declare function throttle<T extends (...args: any[]) => any>(func: T, limit: number): (...args: Parameters<T>) => void;
+
+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 };
+export type { Analytics, AnalyticsOptions, ApiResponse, Application, ApplicationListOptions, ClientInfo, ConfigurationOptions, CreateApplicationRequest, CreateLicenseRequest, CreateWebhookRequest, ErrorResponse, License, LicenseChainConfig, LicenseListOptions, LicenseValidationContext, LicenseValidationRules, ListOptions, PaginatedResponse, PaginationInfo, RateLimitInfo, RequestOptions, UpdateApplicationRequest, UpdateLicenseRequest, UpdateWebhookRequest, UsageStatsOptions, User, ValidationResult, VerifyLicenseAssertionOptions, Webhook, WebhookEvent, WebhookListOptions, WebhookPayload, WebhookVerificationResult };