@licensespring/node-sdk 1.0.2

package/dist/src/types.d.ts

@@ -0,0 +1,513 @@
+export type JSON = {
+    [key: string]: JSON | Array<JSON> | string | number | boolean;
+};
+export type Dictionary<T = string> = {
+    [key: string]: T;
+};
+export type DateInputString = string;
+export type DateISO8601UTC = string;
+export type DateRFC7231 = string;
+export type LicensespringConfig = {
+    apiKey: string;
+    sharedKey: string;
+    apiPath: string;
+    publicKey: string;
+    productCode: string;
+    appName: string;
+    appVersion: string;
+    filePath: string;
+    filename: string;
+    gracePeriod: number;
+    fileKey: string;
+    airGapKey?: string;
+    isGuardFileEnabled: boolean;
+    hardwareIDMethod: number;
+    sdkVersion: string;
+};
+export type LicensespringAPIConfig = Omit<LicensespringConfig, 'productCode'>;
+export type LicensespringConfigDef = Omit<LicensespringConfig, 'apiPath' | 'publicKey' | 'filename' | 'filePath' | 'gracePeriod' | 'fileKey' | 'isGuardFileEnabled' | 'hardwareIDMethod' | 'sdkVersion'> & {
+    apiPath?: string;
+    publicKey?: string;
+    filename?: string;
+    filePath?: string;
+    gracePeriod?: number;
+    fileKey?: string;
+    isGuardFileEnabled?: boolean;
+    hardwareIDMethod?: number;
+};
+export type LicensespringAPIConfigDef = Omit<LicensespringAPIConfig, 'apiPath' | 'publicKey' | 'filename' | 'filePath' | 'gracePeriod' | 'fileKey' | 'isGuardFileEnabled' | 'hardwareIDMethod' | 'sdkVersion'> & {
+    apiPath?: string;
+    publicKey?: string;
+    filename?: string;
+    filePath?: string;
+    gracePeriod?: number;
+    fileKey?: string;
+    isGuardFileEnabled?: boolean;
+    hardwareIDMethod?: number;
+};
+export type LicensespringFloatingConfig = {
+    apiPath: string;
+    appVersion: string;
+    hardwareIDMethod: number;
+    sdkVersion: string;
+};
+export type LicensespringFloatingConfigDef = Omit<LicensespringFloatingConfig, 'hardwareIDMethod' | 'sdkVersion'> & {
+    hardwareIDMethod?: number;
+};
+type LicenseIdentificatorKeyBased = {
+    license_key: string;
+};
+type LicenseIdentificatorUserBased = {
+    username: string;
+};
+type LicenseActivationIdentificatorUserBased = {
+    username: string;
+    password: string;
+};
+type LicenseIdentificatorUserSSOBased = ({
+    id_token: string;
+} | {
+    code: string;
+}) & {
+    customer_account_code: string;
+};
+export type SSOURLParams = {
+    product: string;
+    type: 'token' | 'code';
+};
+type LicenseIdentificatiorRequired = {
+    hardware_id: string;
+    product: string;
+    bundle_code?: string;
+    license_id?: number;
+};
+export type LicenseActivationIdentificatorWithVariables = LicenseActivationIdentificator & {
+    variables?: Dictionary<string>;
+};
+export type LicenseActivationIdentificatorOfflineWithVariables = LicenseActivationIdentificator & OfflineActivationRequest & {
+    variables?: Dictionary<string>;
+};
+export type LicenseIdentificatorWithVariables = LicenseIdentificator & {
+    variables?: Dictionary<string>;
+};
+export type LicenseIdentificatorOfflineWithVariables = LicenseIdentificator & OfflineActivationRequest & {
+    variables?: Dictionary<string>;
+};
+export type TrialKeyPayload = {
+    email: string;
+    product: string;
+    hardware_id: string;
+};
+export type GetUserLicensesPayload = {
+    username: string;
+    password: string;
+    product: string;
+};
+export type GetCustomerLicensesPayload = {
+    customer: string;
+    product: string;
+};
+export type LicenseIdentificatorAndFeature = LicenseIdentificator & {
+    feature: string;
+};
+export type LicenseIdentificatorAddConsumptions = LicenseIdentificator & {
+    consumptions: number;
+};
+export type LicenseIdentificatorAddFeatureConsumptions = LicenseIdentificator & {
+    feature: string;
+    consumptions: number;
+};
+export type ProductDetailsPayload = {
+    product: string;
+    include_expired_features?: boolean;
+    include_latest_version?: boolean;
+    include_custom_fields?: boolean;
+};
+export type LicenseIdentificatorWithBorrowedUntil = LicenseIdentificator & {
+    borrowed_until: DateInputString;
+};
+export type PasswordChangePayload = {
+    username: string;
+    password: string;
+    new_password: string;
+};
+export type LicenseIdentificatorWithInstallation = LicenseIdentificator & {
+    env: string;
+    channel: string;
+    version: string;
+};
+export type Managed<T> = Omit<T, 'product' | 'hardware_id'>;
+type ListProps<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+type EvalIfIs<T, U> = unknown extends T ? never : U;
+type XOR<A, B, C = unknown, D = unknown, E = unknown, F = unknown, G = unknown, H = unknown> = ListProps<(Without<B & C & D & E & F & G & H, A> & A) | (Without<A & C & D & E & F & G & H, B> & B) | EvalIfIs<C, Without<A & B & D & E & F & G & H, C> & C> | EvalIfIs<D, Without<A & B & C & E & F & G & H, D> & D> | EvalIfIs<E, Without<A & B & C & D & F & G & H, E> & E> | EvalIfIs<F, Without<A & B & C & D & E & G & H, F> & F> | EvalIfIs<G, Without<A & B & C & D & E & F & H, G> & G> | EvalIfIs<H, Without<A & B & C & D & E & F & G, H> & H>>;
+export type LicenseIdentificator = (XOR<LicenseIdentificatorKeyBased, LicenseIdentificatorUserBased>) & LicenseIdentificatiorRequired;
+export type LicenseActivationIdentificator = (XOR<LicenseIdentificatorKeyBased, LicenseActivationIdentificatorUserBased, LicenseIdentificatorUserSSOBased>) & LicenseIdentificatiorRequired;
+export type LicenseUser = {
+    id: number;
+    email: string;
+    first_name: string;
+    last_name: string;
+    phone_number: string;
+    is_initial_password: boolean;
+    allow_unlimited_activations: boolean;
+    max_activations: number;
+    total_activations: number;
+};
+export type ProductDetails = {
+    product_id: number;
+    product_name: string;
+    short_code: string;
+    authorization_method: 'license-key' | 'user';
+    metadata: JSON;
+};
+export type Customer = {
+    email: string;
+    company_name: string;
+    reference: string;
+    phone: string;
+    first_name: string;
+    last_name: string;
+    city: string;
+    postcode: string;
+    state: string;
+    country: string;
+    address: string;
+    customer_account: string | null;
+    metadata: JSON;
+};
+export type CustomField = {
+    name: string;
+    data_type: 'numer' | 'text' | 'date/time';
+    value: string;
+};
+export type ProductFeature = {
+    id: number;
+    code: string;
+    name: string;
+    expiry_date: string;
+    metadata: JSON;
+    is_floating_cloud: boolean;
+} & XOR<{
+    feature_type: 'activation';
+}, {
+    feature_type: 'consumption';
+    max_consumption: number;
+    allow_unlimited_consumptions: boolean;
+    total_consumptions: number;
+    allow_overages: number;
+    max_overages: number;
+    reset_consumption: boolean;
+    consumption_period: string | null;
+}> & XOR<{
+    is_floating: false;
+}, {
+    is_floating: true;
+    floating_users: number;
+    floating_timeout?: number;
+}>;
+export type LicenseType = 'perpetual' | 'time-limited' | 'consumption' | 'subscription';
+export type LicenseResponse = {
+    id: number;
+    allow_grace_period: boolean;
+    allow_overages: boolean;
+    allow_unlimited_activations: boolean;
+    borrowed_until: string | null;
+    can_borrow: boolean;
+    channel: string;
+    device_id: number;
+    enable_maintenance_period: boolean;
+    environment: string;
+    eula_link: string;
+    floating_timeout: number;
+    grace_period: number;
+    hash_md5: string;
+    installation_file: string;
+    is_air_gapped: boolean;
+    is_borrowed: boolean;
+    is_expired: boolean;
+    is_hardware_key_auth: boolean;
+    license_active: boolean;
+    license_enabled: boolean;
+    license_signature: string;
+    license_type: LicenseType;
+    maintenance_period: string | null;
+    max_activations: number;
+    max_borrow_time: number;
+    max_license_users: number;
+    max_overages: number;
+    max_transfers: number;
+    order_store_id: string;
+    prevent_vm: boolean;
+    release_date: string;
+    release_notes_link: string;
+    requires_version: string;
+    size: string;
+    start_date: string | null;
+    times_activated: number;
+    transfer_count: number;
+    validity_period: DateISO8601UTC | null;
+    version: string;
+    product_features: ProductFeature[];
+    custom_fields: CustomField[];
+    customer: Customer;
+    product_details: ProductDetails;
+    metadata: JSON;
+} & XOR<{
+    license_key: string;
+}, {
+    user: LicenseUser;
+}> & XOR<({
+    is_floating: true;
+    is_floating_cloud: boolean;
+    floating_in_use_devices: number;
+} | {
+    is_floating: boolean;
+    is_floating_cloud: true;
+    floating_in_use_devices: number;
+}) & {
+    floating_users: number;
+    floating_timeout: number;
+}, {
+    is_floating_cloud: false;
+    is_floating: false;
+}> & XOR<{
+    is_trial: false;
+}, {
+    is_trial: true;
+    trial_days: number;
+}> & XOR<{
+    license_type: 'consumption';
+    max_consumptions: number;
+    total_consumptions: number;
+    allow_unlimited_consumptions: boolean;
+    allow_overages: boolean;
+    max_overages: number;
+    reset_consumption: boolean;
+    consumption_period: DateISO8601UTC | null;
+}, {}>;
+export type LicenseResponseOffline = LicenseResponse & {
+    license_signature_v2: string;
+};
+export type LicenseFilePayload = LicenseResponseOffline & {
+    offline_signature: string;
+};
+export type OfflineActivationRequest = {
+    prefix?: string;
+    os_ver?: string;
+    sdk_build_version?: string;
+    hostname?: string;
+    ip?: string;
+    external_ip?: string;
+    app_ver?: string;
+    mac_address?: string;
+};
+export type DeviceVariable = {
+    id: number;
+    device_id: number;
+    created_at: DateISO8601UTC;
+    variable: string;
+    value: string;
+};
+type LicenseTrialExisting = {};
+type LicenseTrialNewCommon = {
+    license_key: string;
+    id: number;
+    order_id: number;
+    product_id: number;
+    max_license_users: number;
+    max_activations: number;
+    times_activated: number;
+    is_trial: true;
+    active: boolean;
+    enabled: boolean;
+    max_transfers: number;
+    trial_days: number;
+    maintenance_duration: DateISO8601UTC | null;
+    validity_period: DateISO8601UTC | null;
+    enable_maintenance_period: boolean;
+    prevent_vm: boolean;
+    is_hardware_key_auth: boolean;
+    license_user: string;
+    initial_password: string;
+    metadata: JSON;
+    created_at: number;
+    updated_at: number;
+    LicenseProductFeatures: LicenseProductFeature[];
+    LicenseCustomFields: {
+        product_custom_field_id: number;
+        value: string;
+    }[];
+};
+type LicenseTrialNew = LicenseTrialNewCommon & (XOR<{
+    is_floating_cloud: true;
+    floating_users: number;
+    floating_timeout: number;
+}, {}>) & (XOR<{
+    license_type: 'consumption';
+    allow_overages: boolean;
+    max_overages: number;
+    max_consumptions: number;
+    valid_duration: null;
+    consumption_period: string | null;
+    reset_consumption: boolean;
+}, XOR<{
+    license_type: 'subscription';
+    grace_period: number;
+    allow_grace_period: boolean;
+}, {
+    license_type: 'perpetual' | 'time-limited';
+}>>);
+export type LicenseTrialResponse = (LicenseTrialNew | LicenseTrialExisting) & {
+    license_type: LicenseType;
+    is_trial: boolean;
+    license_user: string;
+};
+type CustomerLicenseUser = {
+    email: string;
+    is_active: boolean;
+    first_name: string;
+    last_name: string;
+    phone_number: string;
+    is_initial_password: boolean;
+    initial_password: string;
+    max_activations: number;
+    total_activations: number;
+    license_id: number;
+    order_id: number;
+    order_store_id: string;
+};
+export type CustomerLicenseUsersResponse = {
+    customer: {
+        email: string | null;
+        first_name: string | null;
+        last_name: string | null;
+        company_name: string | null;
+        phone: string | null;
+        reference: string | null;
+        address: string | null;
+        postcode: string | null;
+        city: string | null;
+        country: string | null;
+        state: string | null;
+        customer_account: null | {
+            id: string;
+            name: string;
+            code: string;
+        };
+        metadata: JSON;
+    };
+    users: CustomerLicenseUser[];
+};
+export type LicenseFeatureResponse = {
+    id: number;
+    code: string;
+    name: string;
+    floating_timeout: number | null;
+    floating_users: number | null;
+    feature_type: 'activation' | 'consumption';
+    expiry_date: DateISO8601UTC | null;
+    metadata: JSON;
+    is_floating: boolean;
+    is_floating_cloud: boolean;
+    floating_in_use_devices: number;
+    license_id: number;
+};
+export type LicenseProductFeature = {
+    id: number;
+    product_feature_id: number;
+    max_consumption: number;
+    allow_overages: boolean;
+    max_overages: number;
+    reset_consumption: number;
+    consumption_period: string | null;
+    expiry_date: DateISO8601UTC | null;
+    is_floating: boolean;
+    is_floating_cloud: boolean;
+    metadata: JSON;
+} & XOR<({
+    is_floating: true;
+} | {
+    is_floating_cloud: true;
+}) & {
+    floating_timeout: number;
+    floating_users: number;
+}, {}>;
+export type LicenseConsumptionsResponse = {
+    id: number;
+    max_consumptions: number;
+    total_consumptions: number;
+    allow_unlimited_consumptions: boolean;
+    allow_negative_consumptions: boolean;
+    allow_overages: boolean;
+    max_overages: number;
+    reset_consumption: boolean;
+    consumption_period: string | null;
+};
+export type LicenseFeatureConsumptionResponse = {
+    total_consumptions: number;
+    is_floating: boolean;
+    is_floating_cloud: boolean;
+    floating_timeout: number;
+    floating_users: number;
+};
+export type ProductDetailsResponse = ProductDetails & {
+    floating_timeout: number;
+    max_overages: number;
+    trial_days: number;
+    allow_overages: boolean;
+    allow_trial: boolean;
+    prevent_vm: boolean;
+    custom_fields: {
+        id: number;
+        name: string;
+        default_value: string;
+    }[];
+    latest_version: null | (InstallationFileBase & {
+        id: number;
+        product_id: number;
+        enabled: boolean;
+        created_at: DateISO8601UTC;
+        updated_at: DateISO8601UTC;
+        full_link: string | null;
+        filename: string | null;
+    });
+};
+export type LicenseBorrowResponse = {
+    license_id: number;
+    device_id: number;
+    borrowed_until: DateInputString;
+    max_borrow_time: number;
+};
+type InstallationFileBase = {
+    version: string | null;
+    environment: string | null;
+    hash_md5: string | null;
+    eula_link: string | null;
+    release_notes_link: string | null;
+    size: string | null;
+    requires_version: string | null;
+    channel: string | null;
+    release_date: DateISO8601UTC | null;
+};
+export type InstallationFileResponse = InstallationFileBase & {
+    installation_file: string | null;
+};
+export type VersionsResponse = {
+    version: string;
+    release_date: DateISO8601UTC;
+}[];
+export type LicenseDataMethod = 'check_license' | 'activate_license' | 'activate_license_offline' | 'activate_air_gap' | 'update_license_offline' | 'product_details' | 'device_variables' | 'normal' | 'license_consumption' | 'feature_consumption' | 'register_feature' | 'floating_server_register';
+export declare enum HardwareIdAlgorithm {
+    Default = 0,
+    WindowsHardwareFingerprintId = 1,
+    WindowsComputerSystemProductId = 2,
+    WindowsCryptographyId = 3,
+    LinuxMachineId = 4,
+    CloudPlatformsId = 5
+}
+export {};

package/dist/src/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HardwareIdAlgorithm = void 0;
+var HardwareIdAlgorithm;
+(function (HardwareIdAlgorithm) {
+    HardwareIdAlgorithm[HardwareIdAlgorithm["Default"] = 0] = "Default";
+    HardwareIdAlgorithm[HardwareIdAlgorithm["WindowsHardwareFingerprintId"] = 1] = "WindowsHardwareFingerprintId";
+    HardwareIdAlgorithm[HardwareIdAlgorithm["WindowsComputerSystemProductId"] = 2] = "WindowsComputerSystemProductId";
+    HardwareIdAlgorithm[HardwareIdAlgorithm["WindowsCryptographyId"] = 3] = "WindowsCryptographyId";
+    HardwareIdAlgorithm[HardwareIdAlgorithm["LinuxMachineId"] = 4] = "LinuxMachineId";
+    HardwareIdAlgorithm[HardwareIdAlgorithm["CloudPlatformsId"] = 5] = "CloudPlatformsId";
+})(HardwareIdAlgorithm || (exports.HardwareIdAlgorithm = HardwareIdAlgorithm = {}));
+;
+//# sourceMappingURL=types.js.map

package/dist/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";;;AA4pBA,IAAY,mBAOX;AAPD,WAAY,mBAAmB;IAC7B,mEAAW,CAAA;IACX,6GAAgC,CAAA;IAChC,iHAAkC,CAAA;IAClC,+FAAyB,CAAA;IACzB,iFAAkB,CAAA;IAClB,qFAAoB,CAAA;AACtB,CAAC,EAPW,mBAAmB,mCAAnB,mBAAmB,QAO9B;AAAA,CAAC"}

package/dist/src/version.d.ts

@@ -0,0 +1,2 @@
+declare const SDK_VERSION = "0.0.1";
+export default SDK_VERSION;

package/dist/src/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SDK_VERSION = '0.0.1';
+exports.default = SDK_VERSION;
+//# sourceMappingURL=version.js.map

package/dist/src/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";;AAAA,MAAM,WAAW,GAAG,OAAO,CAAC;AAC5B,kBAAe,WAAW,CAAC"}

package/dist/src/watchdog.d.ts

@@ -0,0 +1,18 @@
+import License from './license';
+export declare class Watchdog {
+    private license;
+    private intervalPointer?;
+    private runningForLicense;
+    private runningForFeatures;
+    private callbackLicense?;
+    private callbackFeatures?;
+    private interval;
+    constructor(license: License);
+    setupForLicense(callback: () => any): void;
+    setupForLicenseFeatures(callback: (featureCode: string) => any): void;
+    stopForLicense(): void;
+    stopForFeatures(): void;
+    private runner;
+    private startCheck;
+    private cleanupCheck;
+}

package/dist/src/watchdog.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Watchdog = void 0;
+class Watchdog {
+    constructor(license) {
+        this.license = license;
+        this.runningForLicense = false;
+        this.runningForFeatures = false;
+        this.interval = 60 * 60 * 1000;
+    }
+    setupForLicense(callback) {
+        this.runningForLicense = true;
+        this.callbackLicense = callback;
+        this.startCheck();
+    }
+    setupForLicenseFeatures(callback) {
+        this.runningForFeatures = true;
+        this.callbackFeatures = callback;
+        this.startCheck();
+    }
+    stopForLicense() {
+        this.runningForLicense = false;
+        this.callbackLicense = undefined;
+        this.cleanupCheck();
+    }
+    stopForFeatures() {
+        this.runningForFeatures = false;
+        this.callbackFeatures = undefined;
+        this.cleanupCheck();
+    }
+    runner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.runningForLicense) {
+                try {
+                    yield this.license.check();
+                }
+                catch (error) {
+                    this.callbackLicense();
+                }
+            }
+            if (this.runningForFeatures) {
+                const features = ((_a = this.license.features) === null || _a === void 0 ? void 0 : _a.map(feature => feature.code)) || [];
+                for (const featureCode in features) {
+                    try {
+                        yield this.license.checkFeature(featureCode);
+                    }
+                    catch (error) {
+                        this.callbackFeatures(featureCode);
+                    }
+                }
+            }
+        });
+    }
+    startCheck() {
+        if (this.runningForLicense || this.runningForFeatures) {
+            if (this.intervalPointer == undefined) {
+                clearInterval(this.intervalPointer);
+                this.intervalPointer = setInterval(this.runner.bind(this), this.interval);
+            }
+        }
+    }
+    cleanupCheck() {
+        if (!this.runningForLicense && !this.runningForFeatures) {
+            clearInterval(this.intervalPointer);
+            this.intervalPointer = undefined;
+        }
+    }
+}
+exports.Watchdog = Watchdog;
+//# sourceMappingURL=watchdog.js.map

package/dist/src/watchdog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchdog.js","sourceRoot":"","sources":["../../src/watchdog.ts"],"names":[],"mappings":";;;;;;;;;;;;AAEA,MAAa,QAAQ;IASnB,YAAoB,OAAgB;QAAhB,YAAO,GAAP,OAAO,CAAS;QAN5B,sBAAiB,GAAY,KAAK,CAAC;QACnC,uBAAkB,GAAY,KAAK,CAAC;QAGpC,aAAQ,GAAW,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAI1C,CAAC;IAED,eAAe,CAAC,QAAmB;QACjC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;QAChC,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAED,uBAAuB,CAAC,QAAsC;QAC5D,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC;QACjC,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAED,cAAc;QACZ,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;QAC/B,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;QACjC,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED,eAAe;QACb,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAChC,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC;QAClC,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAEa,MAAM;;;YAElB,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;gBAE7B,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,CAAC,eAAgB,EAAE,CAAC;gBAC1B,CAAC;YACH,CAAC;YAED,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC5B,MAAM,QAAQ,GAAG,CAAA,MAAA,IAAI,CAAC,OAAO,CAAC,QAAQ,0CAAE,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAI,EAAE,CAAC;gBAC3E,KAAK,MAAM,WAAW,IAAI,QAAQ,EAAE,CAAC;oBACnC,IAAI,CAAC;wBACH,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;oBAE/C,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,IAAI,CAAC,gBAAiB,CAAC,WAAW,CAAC,CAAC;oBACtC,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;KAAA;IAEO,UAAU;QAChB,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACtD,IAAI,IAAI,CAAC,eAAe,IAAI,SAAS,EAAE,CAAC;gBACtC,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gBACpC,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC5E,CAAC;QACH,CAAC;IACH,CAAC;IAEO,YAAY;QAClB,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACxD,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YACpC,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;QACnC,CAAC;IACH,CAAC;CACF;AA5ED,4BA4EC"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@licensespring/node-sdk",
+  "version": "1.0.2",
+  "main": "dist/src/index.js",
+  "modules": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "scripts": {
+    "postinstall": "node ./hwid/install.js",
+    "build": "NODE_ENV=dev npx eslint . && NODE_ENV=dev npx jest --passWithNoTests && NODE_ENV=test npx tsc && cpx .env.prod dist && cpx \"hwid/hardware_id_generator/**/*\" dist/hwid/hardware_id_generator",
+    "test": "NODE_ENV=dev npx jest",
+    "prepare": "ts-patch install && typia patch",
+    "dev-test": "NODE_ENV=dev npx ts-node index.ts"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@eslint/js": "^9.11.1",
+    "@types/elliptic": "^6.4.18",
+    "@types/eslint__js": "^8.42.3",
+    "@types/jest": "^29.5.13",
+    "cpx": "^1.5.0",
+    "dotenv": "^16.4.5",
+    "dotenv-run-script": "^0.4.1",
+    "eslint": "^9.11.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "ts-patch": "^3.2.1",
+    "typedoc": "^0.27.2",
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.7.0"
+  },
+  "dependencies": {
+    "axios": "^1.7.7",
+    "dayjs": "^1.11.13",
+    "elliptic": "^6.6.1",
+    "hash.js": "^1.1.7",
+    "koffi": "^2.9.1",
+    "typia": "^6.11.1",
+    "unzipper": "^0.12.3"
+  }
+}