License API

Provides a direct interface to the LicenseSpring API. The LicenseAPI class encapsulates API calls, input checks, authentication and signature verification. Typescript definitions are provided for the arguments and return types of the class methods.

To import the LicenseAPI class use:

example.js

const { LicenseAPI } = require('@licensespring/node-sdk');

Creating an instance

example.js

const licenseAPI = new LicenseAPI({
  apiKey: '12345678-4bfe-4e3a-8737-757004d6294c',
  sharedKey: 'eYuHrlajvIVTiSFIXpxpKhw78f4Ewy-00-12345678',
  appName: 'js-sdk-test-1',
  appVersion: '0.0.1',
  /** NOTE: the following properties are set to their default values by the SDK and can be overriden manually: */
  // apiPath: 'http://api.dev.licensespring.com/api/v4',
  // publicKey: '...',
});

The constructor takes a single argument of the following type:

types.ts

{
  /** your Licensespring API key */
  apiKey: string,
  /** your Licensespring API Shared key **/
  sharedKey: string,
  /** custom name for your application */
  appName: string,
  /** custom version string for your application */
  appVersion: string,
  /** your Air Gap Activation key (optional) */
  airGapKey?: string,
  /** override for License API url (default is https://api.licensespring.com/api/v4/) **/
  apiPath?: string,
  /** override for License API public key (default is pub key for api.licensespring.com) **/
  publicKey?: string,
  /** override for License File filename (default is "License") */
  filename?: string,
  /** override for License File path (default is current directory) */
  filePath?: string,
  /** override for License File encryption key */
  fileKey?: string,
  /** override for license grace period duration in hours (default is 24) */
  gracePeriod?: number,
  /** override for License File guard file (default is false) */
  isGuardFileEnabled?: boolean,
  /** override for Hardware ID calculation method (default is 0, for more info see "Hardware ID" section) */
  hardwareIDMethod?: number,
  /** a custom provided Hardware ID (overrides HWID calculation) */
  hardwareID?: string,
}

API methods

For type declarations see Type Declarations.

Hardware ID

Generates a Hardware ID. This value is required for various API method calls.

If the optional argument is not provided, it defaults to the value set in the configuration object provided when instantiating the LicensespringAPI object. If no value was provided in the config object, it defaults to 0 (the default Hardware ID method).

types.ts

getHardwareID(algorithm?: HardwareIdAlgorithm): string

Check License

See: Check License

types.ts

checkLicense(
  payload: CheckLicensePayload, 
  includeExpiredFeatures: boolean = false
): Promise<CheckLicenseResponse>

type CheckLicensePayload = ({
  username: string;
} | {
  license_key: string;
}) & {
  product: string;
  hardware_id: string;
  env: string | undefined;
  license_id: number | undefined;
  sdk_ver: string | undefined;
  app_ver: string | undefined;
  hostname: string | undefined;
  os_hostname: string | undefined;
  ip_local: string | undefined;
  mac_address: string | undefined;
  ip: string | undefined;
  os_ver: string | undefined;
  channel: string | undefined;
};

type CheckLicenseResponse = {
  id: number,
  allow_grace_period: boolean,
  allow_overages: boolean,
  allow_unlimited_activations: boolean,
  allow_offline_activation: boolean,
  can_borrow: boolean,
  custom_fields: CustomField[],
  customer: CustomerResponse,
  enable_maintenance_period: boolean,
  floating_timeout: number,
  floating_users?: number,
  grace_period: number | null,
  is_air_gapped: boolean,
  is_floating: boolean,
  is_floating_cloud: boolean,
  is_hardware_key_auth: boolean,
  license_key: string | undefined,
  license_template_id?: number,
  maintenance_period: string | null,
  max_activations: number,
  max_borrow_time: number,
  max_license_users?: number,
  max_overages: number,
  max_transfers?: number,
  metadata: JSONObjectRequired,
  metadata_string?: string,
  order_store_id?: string,
  prevent_vm: boolean,
  company: {
    id: number,
  },
  product_details?: ProductDetailsResponse,
  product_features: FeatureResponse[],
  start_date: string | null,
  times_activated: number,
  transfer_count: number,
  validity_period: string | null,
  is_trial: boolean,
  trial_days?: number,
  user?: LicenseUserResponse,
  license_type: LicenseTypes,
  allow_negative_consumptions?: boolean,
  allow_unlimited_consumptions?: boolean,
  consumption_period?: 'daily' | 'weekly' | 'monthly' | 'annually' | null,
  max_consumptions?: number,
  reset_consumption?: boolean,
  total_consumptions?: number,
  borrowed_until: string | null,
  floating_in_use_devices?: number,
  is_borrowed: boolean,
  is_expired: boolean,
  license_active: boolean,
  license_enabled: boolean,
  license_signature: string,
};

Check License Offline

Checks an offline license file

types.ts

checkLicenseOffline(payloadBase64: string): Promise<LicenseFilePayload>

type LicenseFilePayload = {
  id: number,
  allow_grace_period: boolean,
  allow_overages: boolean,
  allow_unlimited_activations: boolean,
  allow_offline_activation: boolean,
  can_borrow: boolean,
  custom_fields: CustomField[],
  customer: CustomerResponse,
  enable_maintenance_period: boolean,
  floating_timeout: number,
  floating_users?: number,
  grace_period: number | null,
  is_air_gapped: boolean,
  is_floating: boolean,
  is_floating_cloud: boolean,
  is_hardware_key_auth: boolean,
  license_key: string | undefined,
  license_template_id?: number,
  maintenance_period: string | null,
  max_activations: number,
  max_borrow_time: number,
  max_license_users?: number,
  max_overages: number,
  max_transfers?: number,
  metadata: JSONObjectRequired,
  metadata_string?: string,
  order_store_id?: string,
  prevent_vm: boolean,
  company: {
    id: number,
  },
  product_details?: ProductDetailsResponse,
  product_features: FeatureResponse[],
  start_date: string | null,
  times_activated: number,
  transfer_count: number,
  validity_period: string | null,
  is_trial: boolean,
  trial_days?: number,
  user?: LicenseUserResponse,
  license_type: LicenseTypes,
  allow_negative_consumptions?: boolean,
  allow_unlimited_consumptions?: boolean,
  consumption_period?: 'daily' | 'weekly' | 'monthly' | 'annually' | null,
  max_consumptions?: number,
  reset_consumption?: boolean,
  total_consumptions?: number,
  request: string,
  active: boolean,
  device_id: number,
  validity_period: string | null,
  is_expired: boolean,
  hardware_id: string,
  username?: string,
  max_license_users?: number,
  is_floating_cloud: boolean,
  floating_in_use?: boolean,
  license_signature: string,
  variables?: ({
    value: string;
    device_id: number;
    variable: string;
    created_at: string | null;
  })[];
  date: string,
  offline_signature: string,
  date: string,
  offline_signature: string,
  license_signature_v2: string,
  offline_signature: string,
};

Check Bundle

See: Check Bundle

types.ts

checkBundle(
  payload: CheckBundlePayload, 
  includeExpiredFeatures: boolean = false
): Promise<CheckBundleResponse>

type CheckBundlePayload = ({
  username: string;
} | {
  license_key: string;
}) & {
  product: string;
  hardware_id: string;
  env: string | undefined;
  license_id: number | undefined;
  sdk_ver: string | undefined;
  app_ver: string | undefined;
  hostname: string | undefined;
  os_hostname: string | undefined;
  ip_local: string | undefined;
  mac_address: string | undefined;
  ip: string | undefined;
  os_ver: string | undefined;
  channel: string | undefined;
};

type CheckBundleResponse = CheckLicenseResponse[];
// see CheckLicenseResponse declaration in "Check License" section above

Check Bundle Offline

Checks an offline bundle license file

types.ts

checkBundleOffline(payloadBase64: string): Promise<Record<string, LicenseFilePayload>>

// see LicenseFilePayload declaration in "Check License Offline" section above

Activate License Online

See: Activate License (Online Method)

types.ts

activateLicense(payload: ActivateLicensePayload): Promise<ActivateLicenseResponse>

type ActivateLicensePayload = ({ 
  license_key: string; 
} | {
  username: string;
  password: string;
} | {
  code: string;
  customer_account_code: string;
} | {
  id_token: string;
  customer_account_code: string;
}) & {
  hardware_id: string;
  product: string;
  variables: { [key: string]: string | number | boolean } | undefined;
};

type ActivateLicenseResponse = {
  id: number,
  allow_grace_period: boolean,
  allow_overages: boolean,
  allow_unlimited_activations: boolean,
  allow_offline_activation: boolean,
  can_borrow: boolean,
  custom_fields: CustomField[],
  customer: CustomerResponse,
  enable_maintenance_period: boolean,
  floating_timeout: number,
  floating_users?: number,
  grace_period: number | null,
  is_air_gapped: boolean,
  is_floating: boolean,
  is_floating_cloud: boolean,
  is_hardware_key_auth: boolean,
  license_key: string | undefined,
  license_template_id?: number,
  maintenance_period: string | null,
  max_activations: number,
  max_borrow_time: number,
  max_license_users?: number,
  max_overages: number,
  max_transfers?: number,
  metadata: JSONObjectRequired,
  metadata_string?: string,
  order_store_id?: string,
  prevent_vm: boolean,
  company: {
    id: number,
  },
  product_details?: ProductDetailsResponse,
  product_features: FeatureResponse[],
  start_date: string | null,
  times_activated: number,
  transfer_count: number,
  validity_period: string | null,
  is_trial: boolean,
  trial_days?: number,
  user?: LicenseUserResponse,
  license_type: LicenseTypes,
  allow_negative_consumptions?: boolean,
  allow_unlimited_consumptions?: boolean,
  consumption_period?: 'daily' | 'weekly' | 'monthly' | 'annually' | null,
  max_consumptions?: number,
  reset_consumption?: boolean,
  total_consumptions?: number,
  request: string,
  active: boolean,
  device_id: number,
  validity_period: string | null,
  is_expired: boolean,
  hardware_id: string,
  username?: string,
  max_license_users?: number,
  is_floating_cloud: boolean,
  floating_in_use?: boolean,
  license_signature: string,
  variables?: ({
    value: string;
    device_id: number;
    variable: string;
    created_at: string | null;
  })[];
};

Deactivate License Online

See: Deactivate License (Online Method)

types.ts

deactivateLicense(payload: ({  
  username: string;
} | {
  license_key: string;
}) & {
  product: string;
  hardware_id: string;
}): Promise<boolean>

Activate License Offline

See: Activate License (Offline Method)

types.ts

activateOffline(payload: string): Promise<ActivateOfflineResponse>

type ActivateOfflineResponse = {
  id: number,
  allow_grace_period: boolean,
  allow_overages: boolean,
  allow_unlimited_activations: boolean,
  allow_offline_activation: boolean,
  can_borrow: boolean,
  custom_fields: CustomField[],
  customer: CustomerResponse,
  enable_maintenance_period: boolean,
  floating_timeout: number,
  floating_users?: number,
  grace_period: number | null,
  is_air_gapped: boolean,
  is_floating: boolean,
  is_floating_cloud: boolean,
  is_hardware_key_auth: boolean,
  license_key: string | undefined,
  license_template_id?: number,
  maintenance_period: string | null,
  max_activations: number,
  max_borrow_time: number,
  max_license_users?: number,
  max_overages: number,
  max_transfers?: number,
  metadata: JSONObjectRequired,
  metadata_string?: string,
  order_store_id?: string,
  prevent_vm: boolean,
  company: {
    id: number,
  },
  product_details?: ProductDetailsResponse,
  product_features: FeatureResponse[],
  start_date: string | null,
  times_activated: number,
  transfer_count: number,
  validity_period: string | null,
  is_trial: boolean,
  trial_days?: number,
  user?: LicenseUserResponse,
  license_type: LicenseTypes,
  allow_negative_consumptions?: boolean,
  allow_unlimited_consumptions?: boolean,
  consumption_period?: 'daily' | 'weekly' | 'monthly' | 'annually' | null,
  max_consumptions?: number,
  reset_consumption?: boolean,
  total_consumptions?: number,
  request: string,
  active: boolean,
  device_id: number,
  validity_period: string | null,
  is_expired: boolean,
  hardware_id: string,
  username?: string,
  max_license_users?: number,
  is_floating_cloud: boolean,
  floating_in_use?: boolean,
  license_signature: string,
  variables?: ({
    value: string;
    device_id: number;
    variable: string;
    created_at: string | null;
  })[];
  date: string,
  offline_signature: string,
  license_signature_v2: string,
};

Deactivate License Offline

See: Deactivate License (Offline Method)

types.ts

deactivateOffline(payload: string): Promise<boolean>

Activate Bundle Online

See: Activate Bundle (Online Method)

types.ts

activatBundle(payload: ActivateBundlePayload): Promise<ActivateBundleResponse>

type ActivateBundlePayload = ({ 
  license_key: string; 
} | {
  username: string;
  password: string;
} | {
  code: string;
  customer_account_code: string;
} | {
  id_token: string;
  customer_account_code: string;
}) & {
  hardware_id: string;
  product: string;
  variables: { [key: string]: string | number | boolean } | undefined;
};

type ActivateBundleResponse = ActivateLicenseResponse[];
// see ActivateLicenseResponse in "Activate License Online" section above

Deactivate Bundle Online

See: Deactivate Bundle (Online Method)

types.ts

deactivateBundle(payload: ({  
  username: string;
} | {
  license_key: string;
}) & {
  product: string;
  hardware_id: string;
}): Promise<boolean>

Get Trial Key

See: Trial Key

types.ts

getTrialKey(payload: GetTrialKeyPayload): Promise<TrialResponse>

type GetTrialKeyPayload = {
    sdk_ver: string | undefined;
    email: string | undefined;
    license_policy: string | undefined;
    first_name: string | undefined;
    last_name: string | undefined;
    phone: string | undefined;
    address: string | undefined;
    postcode: string | undefined;
    state: string | undefined;
    country: string | undefined;
    city: string | undefined;
    reference: string | undefined;
    company_name: string | undefined;
    hardware_id: string;
    product: string;
};

type TrialResponse = TrialExistingResponse | TrialNewResponse;

type TrialExistingResponse = {
  license_type: LicenseTypes,
  is_trial: boolean,
  license: string,
} | {
  license_type: LicenseTypes,
  is_trial: boolean,
  license_user: string,
};

type TrialNewResponse = {
  id: number;
  order_id: number;
  product_id: number;
  created_at: number;
  updated_at: number;
  active: boolean;
  enable_maintenance_period: boolean;
  enabled: boolean;
  is_floating: boolean;
  is_hardware_key_auth: boolean;
  is_trial: boolean;
  license_type: LicenseTypes;
  maintenance_duration: string | null;
  max_activations: number;
  max_transfers: number;
  metadata_string: string | undefined;
  metadata: JSONObjectRequired,
  prevent_vm: boolean;
  times_activated: number;
  trial_days: number;
  validity_period?: string;
  company: {
    id: number;
  };
  LicenseProductFeatures: ({
    id: number;
    product_feature_id: number;
    max_consumption: number;
    allow_overages: boolean;
    max_overages: number;
    reset_consumption: boolean;
    consumption_period?: ConsumptionPeriod;
    is_floating: boolean;
    is_floating_cloud: boolean;
    metadata: JSONObjectRequired,
    metadata_string?: string;
    floating_timeout?: number;
    floating_users?: number;
  })[];
  LicenseCustomFields: ({
    product_custom_field_id: number;
    value: string | undefined;
  })[];
  is_floating_cloud: boolean;
  floating_users: number;
  floating_timeout: number;
  allow_overages: boolean;
  max_overages: number;
  max_consumptions: number;
  valid_duration: null;
  consumption_period: ConsumptionPeriod | null;
  reset_consumption?: boolean;
  grace_period: number;
  allow_grace_period: boolean;
} & ({
  license: string;
  license_key: string;
} | {
  license_user: string;
  initial_password: string;
  license_user_id: number | null;
  max_license_users: number;
});

List Licenses for User

See: Licenses for User

types.ts

getUserLicenses(payload: GetUserLicensesPayload): Promise<GetUserLicensesResponse>

type GetUserLicensesPayload = ({ 
  license_key: string; 
} | {
  username: string;
  password: string;
} | {
  code: string;
  customer_account_code: string;
} | {
  id_token: string;
  customer_account_code: string;
}) & {
  product?: string;
};

type GetUserLicensesResponse = ({
  
  license: {
    id: number,
    allow_grace_period: boolean,
    allow_overages: boolean,
    allow_unlimited_activations: boolean,
    allow_offline_activation: boolean,
    can_borrow: boolean,
    custom_fields: CustomField[],
    customer: CustomerResponse,
    enable_maintenance_period: boolean,
    floating_timeout: number,
    floating_users?: number,
    grace_period: number | null,
    is_air_gapped: boolean,
    is_floating: boolean,
    is_floating_cloud: boolean,
    is_hardware_key_auth: boolean,
    license_key: string | undefined,
    license_template_id?: number,
    maintenance_period: string | null,
    max_activations: number,
    max_borrow_time: number,
    max_license_users?: number,
    max_overages: number,
    max_transfers?: number,
    metadata: JSONObjectRequired,
    metadata_string?: string,
    order_store_id?: string,
    prevent_vm: boolean,
    company: {
      id: number,
    },
    product_details?: ProductDetailsResponse,
    product_features: FeatureResponse[],
    start_date: string | null,
    times_activated: number,
    transfer_count: number,
    validity_period: string | null,
    is_trial: boolean,
    trial_days?: number,
    user?: LicenseUserResponse,
    license_type: LicenseTypes,
    allow_negative_consumptions?: boolean,
    allow_unlimited_consumptions?: boolean,
    consumption_period?: 'daily' | 'weekly' | 'monthly' | 'annually' | null,
    max_consumptions?: number,
    reset_consumption?: boolean,
    total_consumptions?: number,
    license_active: boolean,
    license_enabled: boolean,
  },
  
  user: {
    id: number,
    email: string,
    first_name: string,
    is_initial_password: boolean,
    last_name: string,
    phone_number: string,
    allow_unlimited_activations?: boolean,
    max_activations?: number,
    total_activations?: number,
  },
})[];

List License Users for Customer

See: List License Users for Customer

types.ts

getCustomerLicenseUsers(payload: {
    product: string;
    customer: string;
}): Promise<CustomerLicenseUsersResponse>

type CustomerLicenseUsersResponse = {
  company: {
    id: number;
  };
  customer: CustomerResponse;
  users: ({
    email: string | undefined;
    allow_unlimited_activations: boolean;
    first_name: string;
    initial_password: string;
    is_active: boolean;
    is_initial_password: boolean;
    last_name: string;
    license_id: number;
    max_activations: number;
    order_id: number;
    order_store_id: string;
    phone_number: string;
    total_activations: number;
  })[];
};

Check License Feature

See: License Feature Check

types.ts

checkLicenseFeature(payload: CheckLicenseFeaturePayload): Promise<CheckLicenseFeatureResponse>

type CheckLicenseFeaturePayload = ({
  license_key: string;
} | {
  username: string;
}) & {
  license_id: number | undefined;
  sdk_ver: string | undefined;
  include_metadata_string: boolean | undefined;
  hardware_id: string;
  product: string;
  feature: string;
};

type CheckLicenseFeatureResponse = {
  id: number;
  license_id: number;
  code: string;
  name: string;
  metadata: JSONObjectRequired,
  metadata_string?: string;
  is_floating: boolean;
  is_floating_cloud: boolean;
  floating_in_use_devices?: number;
  expiry_date: string | null;
  feature_type: 'activation';
} | {
  id: number;
  license_id: number;
  code: string;
  name: string;
  metadata: JSONObjectRequired,
  metadata_string?: string;
  is_floating: boolean;
  is_floating_cloud: boolean;
  floating_in_use_devices?: number;
  expiry_date: string | null;
  feature_type: 'consumption';
  consumption_period: ConsumptionPeriod;
  allow_negative_consumptions: boolean;
  allow_overages: boolean;
  allow_unlimited_consumptions: boolean;
  max_consumption: number;
  max_overages: number;
  reset_consumption: boolean;
  total_consumptions: number;
};

Add License Consumption

See: Add Consumption

types.ts

addConsumption(payload: AddConsumptionPayload): Promise<AddConsumptionResponse>

type AddConsumptionPayload = ({
  license_key: string;
} | {
  username: string;
}) & {
  product: string;
  hardware_id: string;
  consumptions: number;
  sdk_ver: string | undefined;
  license_id: number | undefined;
  ignore_events: boolean | undefined;
  allow_overages: boolean | undefined;
  max_overages: number | undefined;
  event: ("consumption_add" | "offline_floating_consumptions_sync")[] | undefined;
};

type AddConsumptionResponse = {
  id: number;
  max_consumptions: number;
  allow_unlimited_consumptions: boolean;
  allow_negative_consumptions: boolean;
  allow_overages: boolean;
  max_overages: number;
  reset_consumption: boolean;
  consumption_period: ConsumptionPeriod | undefined;
  total_consumptions: number;
  company: {
    id: number;
  };
};

Add License Feature Consumption

See: Add Feature Consumption

types.ts

addFeatureConsumption(payload: AddFeatureConsumptionPayload): Promise<AddFeatureConsumptionResponse>

type AddFeatureConsumptionPayload = ({
  license_key: string;
} | {
  username: string;
}) & {
  product: string;
  hardware_id: string;
  consumptions: number;
  feature: string;
  sdk_ver: string | undefined;
  license_id: number | undefined;
  ignore_events: boolean | undefined;
  allow_overages: boolean | undefined;
  max_overages: number | undefined;
  event: ("consumption_add" | "offline_floating_consumptions_sync")[] | undefined;
};

type AddFeatureConsumptionResponse = {
  id: number;
  license_id: number;
  company: {
    id: number;
  };
  total_consumptions: number;
  max_consumptions: number;
  allow_negative_consumptions: boolean;
  allow_unlimited_consumptions: boolean;
  allow_overages: boolean;
  max_overages: number;
  reset_consumption: boolean;
  consumption_period: ConsumptionPeriod;
  is_floating: boolean;
  is_floating_cloud: boolean;
  floating_timeout?: number;
  floating_users?: number;
};

Get Product Details

See: Get Product Details

types.ts

getProductDetails(payload: ProductDetailsPayload): Promise<GetProductDetailsResponse>

type ProductDetailsPayload = {
    product: string;
    include_latest_version: boolean | undefined;
    include_custom_fields: boolean | undefined;
    env: string | undefined;
};

type GetProductDetailsResponse = {
  product_id: number,
  product_name: string,
  short_code: string,
  allow_trial: boolean,
  trial_days: number,
  authorization_method: AuthorizationMethod,
  floating_timeout: number,
  allow_overages: boolean,
  max_overages: number,
  prevent_vm: boolean,
  metadata: JSONObjectRequired,
  metadata_string?: string,
  company: {
    id: number
  },
  latest_version?: {
    id: number;
    version: string | undefined;
    full_link: string | undefined;
    filename: string | undefined;
    release_date: string | null;
    hash_md5: string | undefined;
    environment: string;
    eula_link: string | undefined;
    release_notes_link: string | undefined;
    size: string | undefined;
    requires_version: string | undefined;
    channel: string | undefined;
    created_at: string | null;
    updated_at: string | null;
    enabled: boolean;
    product_id: number;
  } | null,
  custom_fields?: { id: number, name: string, default_value: string }[]
};

Get Device Variables

See: Get Device Variables

types.ts

getDeviceVariables(payload: GetDeviceVariablesPayload): Promise<GetDeviceVariablesResponse>

type GetDeviceVariablesPayload = ({
    license_key: string;
} | {
    username: string;
}) & {
    product: string;
    hardware_id: string;
    sdk_ver: string | undefined;
    license_id: number | undefined;
};

type GetDeviceVariablesResponse = {
  id: number;
  created_at: string;
  variable?: string;
  value?: string;
  device_id: number;
}[];

Track Device Variables

See: Track Device Variables

types.ts

trackDeviceVariables(payload: TrackDeviceVariablesPayload): Promise<TrackDeviceVariablesResponse>

type TrackDeviceVariablesPayload = ({
    license_key: string;
} | {
    username: string;
}) & {
    product: string;
    hardware_id: string;
    variables: { [key: string]: string | number | boolean },
    sdk_ver: string | undefined;
    license_id: number | undefined;
};

type TrackDeviceVariablesResponse = {
  variable: string;
  value: string;
  device_id: number;
  created_at: number;
}[];

Borrow Floating License

See: Borrow Floating License

types.ts

floatingBorrow(payload: FloatingBorrowPayload): Promise<FloatingBorrowResponse>

type FloatingBorrowPayload = ({
    license_key: string;
} | {
    username: string;
    password: string;
}) & {
    product: string;
    hardware_id: string;
    borrowed_until: string | null;
    sdk_ver: string | undefined;
    license_id: number | undefined;
};

type FloatingBorrowResponse = {
  borrowed_until: string | null;
  max_borrow_time: number;
  device_id: number;
  license_id: number;
  company: {
    id: number;
  };
};

Release Floating License

See: Release Floating License

types.ts

floatingRelease(payload: FloatingReleasePayload): Promise<boolean>

type FloatingReleasePayload = ({
    license_key: string;
} | {
    username: string;
}) & {
    product: string;
    hardware_id: string;
    sdk_ver: string | undefined;
    license_id: number | undefined;
};

Release Floating Feature

See: Release Floating Feature

types.ts

featureRelease(payload: FloatingFeatureReleasePayload): Promise<boolean>

type FloatingFeatureReleasePayload = ({
    license_key: string;
} | {
    username: string;
}) & {
    product: string;
    hardware_id: string;
    feature: string;
    sdk_ver: string | undefined;
    license_id: number | undefined;
};

Change Password

See: Change Password

types.ts

changePassword(payload: {
    username: string;
    password: string;
    new_password: string;
}): Promise<boolean>

Get Product Versions

See: Get Product Versions

types.ts

getVersions(payload: GetVersionsPayload): Promise<VersionsResponse>

type GetVersionsPayload = ({
    license_key: string;
} | {
    username: string;
}) & {
    product: string;
    hardware_id: string;
    sdk_ver: string | undefined;
    env: string | undefined;
    channel: string | undefined;
};

type VersionsResponse = ({
  version: string | undefined;
  release_date: string | null;
})[];

Get Product Installation File

See: Get Installation File

types.ts

getInstallationFile(payload: GetInstallationFilePayload): Promise<InstallationFileResponse>

type GetInstallationFilePayload = ({
    license_key: string;
} | {
    username: string;
}) & {
    product: string;
    hardware_id: string;
    sdk_ver: string | undefined;
    env: string | undefined;
    channel: string | undefined;
    version: string | undefined;
};

type InstallationFileResponse = {
  id: number;
  version: string | undefined;
  installation_file: string | undefined;
  release_date: string | null;
  hash_md5: string | undefined;
  environment: string;
  eula_link: string | undefined;
  release_notes_link: string | undefined;
  size: string | undefined;
  requires_version: string | undefined;
  channel: string | undefined;
  company: {
    id: number;
  };
};

Get Single Sign-On URL

See: Single Sign On URL

types.ts

getSSOUrl(payload: {
    response_type: 'token' | 'code' | undefined;
    product: string;
    customer_account_code: string;
}): Promise<SSOUrlResponse>

type SSOUrlResponse = {
  url: string;
  openid_configuration: {
    [key: string]: string | number | boolean;
  };
};

Air-Gapped License Code

https://docs.licensespring.com/license-entitlements/activation-types/air-gapped

types.ts

getAirGapActivationCode(
  initializationCode: string, 
  licenseKey: string
): string

verifyConfirmationCode(
  confirmationCode: string, 
  licenseKey: string, 
  policyId?: string
): boolean

activateAirgappedLicense(
  activationPayload: OfflineActivation, 
  licenseKey: string, 
  policyId: string
): LicenseSaved

type LicenseSaved = {
  id: number,
  allow_grace_period: boolean,
  allow_overages: boolean,
  allow_unlimited_activations: boolean,
  allow_offline_activation: boolean,
  can_borrow: boolean,
  custom_fields: CustomField[],
  customer: CustomerResponse,
  enable_maintenance_period: boolean,
  floating_timeout: number,
  floating_users?: number,
  grace_period: number | null,
  is_air_gapped: boolean,
  is_floating: boolean,
  is_floating_cloud: boolean,
  is_hardware_key_auth: boolean,
  license_key: string | undefined,
  license_template_id?: number,
  maintenance_period: string | null,
  max_activations: number,
  max_borrow_time: number,
  max_license_users?: number,
  max_overages: number,
  max_transfers?: number,
  metadata: JSONObjectRequired,
  metadata_string?: string,
  order_store_id?: string,
  prevent_vm: boolean,
  company: {
    id: number,
  },
  product_details?: ProductDetailsResponse,
  product_features: FeatureResponse[],
  start_date: string | null,
  times_activated: number,
  transfer_count: number,
  validity_period: string | null,
  is_trial: boolean,
  trial_days?: number,
  user?: LicenseUserResponse,
  license_type: LicenseTypes,
  allow_negative_consumptions?: boolean,
  allow_unlimited_consumptions?: boolean,
  consumption_period?: 'daily' | 'weekly' | 'monthly' | 'annually' | null,
  max_consumptions?: number,
  reset_consumption?: boolean,
  total_consumptions?: number,
  borrowed_until: string | null,
  floating_in_use_devices?: number,
  is_borrowed: boolean,
  is_expired: boolean,
  policy_id: string;
};