@licensespring/node-sdk 1.0.5 → 1.0.6

package/README.md

@@ -1 +1,1452 @@
-# sdk-javascript
+# LicenseSpring node.js SDK
+
+This package is a node.js implementation of Licensespring SDK. For more information and tutorials, see: [https://docs.licensespring.com/sdk](https://docs.licensespring.com/sdk)
+
+### Install
+
+To install the SDK in your nodejs or typescript project run:
+```
+npm i --save @licensespring/node-sdk
+```
+
+## LicenseAPI
+
+Provides a direct interface to the [LicenseSpring API](https://docs.licensespring.com/license-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:
+```javascript
+const { LicenseAPI } = require('@licensespring/node-sdk');
+```
+
+### Creating an instance
+
+```javascript
+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 the a single argument of the following type:
+```typescript
+{
+  /** 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,
+}
+```
+
+### API methods
+
+For more information on API functionality, see our [LicenseSpring API docs](https://docs.licensespring.com/license-api/).
+
+For type definitions see [Types](#types).
+
+#### getHardwareID
+
+Generates a [Hardware ID](#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).
+
+```typescript
+getHardwareID(algorithm?: HardwareIdAlgorithm): string
+```
+
+#### Check License
+[https://docs.licensespring.com/license-api/check](https://docs.licensespring.com/license-api/check)
+
+```typescript
+checkLicense(payload: LicenseIdentificator, includeExpiredFeatures: boolean = false): Promise<LicenseResponse>
+```
+
+#### Activate License Online
+
+[https://docs.licensespring.com/license-api/activation-deactivation/activation](https://docs.licensespring.com/license-api/activation-deactivation/activation)
+
+```typescript
+activateLicense(payload: LicenseActivationIdentificatorWithVariables): Promise<LicenseResponse>
+```
+
+#### Deactivate License Online
+
+[https://docs.licensespring.com/license-api/activation-deactivation/deactivation](https://docs.licensespring.com/license-api/activation-deactivation/deactivation)
+
+```typescript
+deactivateLicense(payload: LicenseIdentificator): Promise<boolean>
+```
+
+#### Activate License Offline
+
+[https://docs.licensespring.com/license-api/activation-deactivation/offline-activation](https://docs.licensespring.com/license-api/activation-deactivation/offline-activation)
+
+```typescript
+activateOffline(payload: LicenseActivationIdentificatorOfflineWithVariables): Promise<LicenseResponseOffline>
+```
+
+#### Deactivate License Offline
+
+[https://docs.licensespring.com/license-api/activation-deactivation/offline-deactivation](https://docs.licensespring.com/license-api/activation-deactivation/offline-deactivation)
+
+```typescript
+deactivateOffline(payload: LicenseIdentificator): Promise<boolean>
+```
+
+#### Get Trial License Key
+
+[https://docs.licensespring.com/license-api/trial-key](https://docs.licensespring.com/license-api/trial-key)
+
+```typescript
+getTrialKey(payload: TrialKeyPayload): Promise<LicenseTrialResponse>
+```
+
+#### List Licenses for a User
+
+[https://docs.licensespring.com/license-api/user-licenses](https://docs.licensespring.com/license-api/user-licenses)
+
+```typescript
+getUserLicenses(payload: GetUserLicensesPayload): Promise<LicenseResponse[]>
+```
+
+#### List License Users for a Customer
+
+[https://docs.licensespring.com/license-api/customer-license-users](https://docs.licensespring.com/license-api/customer-license-users)
+
+```typescript
+getCustomerLicenseUsers(payload: GetCustomerLicensesPayload): Promise<CustomerLicenseUsersResponse>
+```
+
+#### Check License Feature
+
+[https://docs.licensespring.com/license-api/license-feature-check](https://docs.licensespring.com/license-api/license-feature-check)
+
+```typescript
+checkLicenseFeature(payload: LicenseIdentificatorAndFeature): Promise<LicenseFeatureResponse>
+```
+
+#### Add License Consumption
+
+[https://docs.licensespring.com/license-api/consumption/add](https://docs.licensespring.com/license-api/consumption/add)
+
+```typescript
+addConsumption(payload: LicenseIdentificatorAddConsumptions): Promise<LicenseConsumptionsResponse>
+```
+
+#### Add License Feature Consumption
+
+[https://docs.licensespring.com/license-api/consumption/add-feature](https://docs.licensespring.com/license-api/consumption/add-feature)
+
+```typescript
+addFeatureConsumption(payload: LicenseIdentificatorAddFeatureConsumptions): Promise<LicenseFeatureConsumptionResponse>
+```
+
+#### Product Details
+
+[https://docs.licensespring.com/license-api/product-details](https://docs.licensespring.com/license-api/product-details)
+
+```typescript
+getProductDetails(payload: ProductDetailsPayload): Promise<ProductDetailsResponse>
+```
+
+#### Get Device Variables
+
+[https://docs.licensespring.com/license-api/device-variables/get](https://docs.licensespring.com/license-api/device-variables/get)
+
+```typescript
+getDeviceVariables(payload: LicenseIdentificator): Promise<DeviceVariable[]>
+```
+
+#### Track Device Variables
+
+[https://docs.licensespring.com/license-api/device-variables/track](https://docs.licensespring.com/license-api/device-variables/track)
+
+```typescript
+trackDeviceVariables(payload: LicenseIdentificatorWithVariables): Promise<DeviceVariable[]>
+```
+
+#### Borrow Floating License
+
+[https://docs.licensespring.com/license-api/floating/license/borrow](https://docs.licensespring.com/license-api/floating/license/borrow)
+
+```typescript
+floatingBorrow(payload: LicenseIdentificatorWithBorrowedUntil): Promise<LicenseBorrowResponse>
+```
+
+#### Release Floating License
+
+[https://docs.licensespring.com/license-api/floating/license/release](https://docs.licensespring.com/license-api/floating/license/release)
+
+```typescript
+floatingRelease(payload: LicenseIdentificator): Promise<boolean>
+```
+
+#### Release Floating Feature
+
+[https://docs.licensespring.com/license-api/floating/feature/release](https://docs.licensespring.com/license-api/floating/feature/release)
+
+```typescript
+featureRelease(payload: LicenseIdentificatorAndFeature): Promise<boolean>
+```
+
+#### Change User Password
+
+[https://docs.licensespring.com/license-api/change-password](https://docs.licensespring.com/license-api/change-password)
+
+```typescript
+changePassword(payload: PasswordChangePayload): Promise<boolean>
+```
+
+#### List Product Versions for License
+
+[https://docs.licensespring.com/license-api/versions](https://docs.licensespring.com/license-api/versions)
+
+```typescript
+getVersions(payload: LicenseIdentificator): Promise<VersionsResponse>
+```
+
+#### Product Installation File Info for License
+
+[https://docs.licensespring.com/license-api/installation-file](https://docs.licensespring.com/license-api/installation-file)
+
+```typescript
+getInstallationFile(payload: LicenseIdentificatorWithInstallation): Promise<InstallationFileResponse>
+```
+
+#### Get Single Sign On URL
+
+[https://docs.licensespring.com/license-api/sso-url](https://docs.licensespring.com/license-api/sso-url)
+
+```typescript
+getSSOUrl(payload: SSOURLParams): Promise<{ url: string }>
+```
+
+#### Get Air Gap Activation Code
+
+[https://docs.licensespring.com/license-entitlements/activation-types/air-gapped](https://docs.licensespring.com/license-entitlements/activation-types/air-gapped)
+
+```typescript
+getAirGapActivationCode(initializationCode: string, licenseKey: string): string
+```
+
+#### Verify Air-Gap Confirmation Code
+
+```typescript
+verifyConfirmationCode(confirmationCode: string, licenseKey: string, policyId?: string): boolean
+```
+
+#### Activate Air-Gapped License
+
+[https://docs.licensespring.com/license-entitlements/activation-types/air-gapped](https://docs.licensespring.com/license-entitlements/activation-types/air-gapped)
+
+```typescript
+activateAirgappedLicense(activationPayload: OfflineActivation, licenseKey: string, policyId: string): LicenseResponse
+```
+
+## LicenseManager
+
+Provides a high-level interface for managing licenses, including local licenses. The LicenseManager is required to work with local license files. Typescript definitions are provided for the arguments and return types of the class methods.
+
+To import the LicenseManager class use:
+```javascript
+const { LicenseManager } = require('@licensespring/node-sdk');
+```
+
+To create an instance:
+
+```javascript
+const licenseManager = new LicenseManager({
+  apiKey: '12345678-4bfe-4e3a-8737-757004d6294c',
+  sharedKey: 'eYuHrlajvIVTiSFIXpxpKhw78f4Ewy-00-12345678',
+  appName: 'js-sdk-test-1',
+  appVersion: '0.0.1',
+  productCode: 'lkp',
+  /** 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 the a single argument of the following type:
+```typescript
+{
+  /** 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 product short code */
+  productCode: 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,
+}
+```
+
+### Methods
+
+Methods that take a `Managed` License identificator are the same as in License API, except that `product` and `hardware_id` do not have to be specified in the payload as they are provided by the License Manager object.
+
+#### Check License
+[https://docs.licensespring.com/license-api/check](https://docs.licensespring.com/license-api/check)
+
+```javascript
+checkLicense(payload: Managed<LicenseIdentificator>): Promise<LicenseResponse>
+```
+
+#### Activate License Online
+
+[https://docs.licensespring.com/license-api/activation-deactivation/activation](https://docs.licensespring.com/license-api/activation-deactivation/activation)
+
+```javascript
+activateLicense(payload: Managed<LicenseIdentificatorWithVariables>): Promise<LicenseResponse>
+```
+
+#### Deactivate License Online
+
+[https://docs.licensespring.com/license-api/activation-deactivation/deactivation](https://docs.licensespring.com/license-api/activation-deactivation/deactivation)
+
+```javascript
+deactivateLicense(payload: Managed<LicenseIdentificator>): Promise<boolean>
+```
+
+#### Activate License Offline
+
+[https://docs.licensespring.com/license-api/activation-deactivation/offline-activation](https://docs.licensespring.com/license-api/activation-deactivation/offline-activation)
+
+```javascript
+activateOffline(payload: Managed<LicenseIdentificatorOfflineWithVariables>): Promise<LicenseResponseOffline>
+```
+
+#### Deactivate License Offline
+
+[https://docs.licensespring.com/license-api/activation-deactivation/offline-deactivation](https://docs.licensespring.com/license-api/activation-deactivation/offline-deactivation)
+
+```javascript
+deactivateOffline(payload: Managed<LicenseIdentificator>): Promise<boolean>
+```
+
+#### Get Trial License Key
+
+[https://docs.licensespring.com/license-api/trial-key](https://docs.licensespring.com/license-api/trial-key)
+
+```javascript
+getTrialKey(payload: Managed<TrialKeyPayload>): Promise<LicenseTrialResponse>
+```
+
+#### List Licenses for a User
+
+[https://docs.licensespring.com/license-api/user-licenses](https://docs.licensespring.com/license-api/user-licenses)
+
+```javascript
+getUserLicenses(payload: Managed<GetUserLicensesPayload>): Promise<LicenseResponse[]>
+```
+
+#### List License Users for a Customer
+
+[https://docs.licensespring.com/license-api/customer-license-users](https://docs.licensespring.com/license-api/customer-license-users)
+
+```javascript
+getCustomerLicenseUsers(payload: Managed<GetCustomerLicensesPayload>): Promise<CustomerLicenseUsersResponse>
+```
+
+#### Check License Feature
+
+[https://docs.licensespring.com/license-api/license-feature-check](https://docs.licensespring.com/license-api/license-feature-check)
+
+```javascript
+checkLicenseFeature(payload: Managed<LicenseIdentificatorAndFeature>): Promise<LicenseFeatureResponse>
+```
+
+#### Add License Consumption
+
+[https://docs.licensespring.com/license-api/consumption/add](https://docs.licensespring.com/license-api/consumption/add)
+
+```javascript
+addConsumption(payload: Managed<LicenseIdentificatorAddConsumptions>): Promise<LicenseConsumptionsResponse>
+```
+
+#### Add License Feature Consumption
+
+[https://docs.licensespring.com/license-api/consumption/add-feature](https://docs.licensespring.com/license-api/consumption/add-feature)
+
+```javascript
+addFeatureConsumption(payload: Managed<LicenseIdentificatorAddFeatureConsumptions>): Promise<LicenseFeatureConsumptionResponse>
+```
+
+#### Product Details
+
+[https://docs.licensespring.com/license-api/product-details](https://docs.licensespring.com/license-api/product-details)
+
+```javascript
+getProductDetails(payload: Managed<ProductDetailsPayload>): Promise<ProductDetailsResponse>
+```
+
+#### Get Device Variables
+
+[https://docs.licensespring.com/license-api/device-variables/get](https://docs.licensespring.com/license-api/device-variables/get)
+
+```javascript
+getDeviceVariables(payload: Managed<LicenseIdentificator>): Promise<DeviceVariable[]>
+```
+
+#### Track Device Variables
+
+[https://docs.licensespring.com/license-api/device-variables/track](https://docs.licensespring.com/license-api/device-variables/track)
+
+```javascript
+trackDeviceVariables(payload: Managed<LicenseIdentificatorWithVariables>): Promise<DeviceVariable[]>
+```
+
+#### Borrow Floating License
+
+[https://docs.licensespring.com/license-api/floating/license/borrow](https://docs.licensespring.com/license-api/floating/license/borrow)
+
+```javascript
+floatingBorrow(payload: Managed<LicenseIdentificatorWithBorrowedUntil>): Promise<LicenseBorrowResponse>
+```
+
+#### Release Floating License
+
+[https://docs.licensespring.com/license-api/floating/license/release](https://docs.licensespring.com/license-api/floating/license/release)
+
+```javascript
+floatingRelease(payload: Managed<LicenseIdentificator>): Promise<boolean>
+```
+
+#### Release Floating Feature
+
+[https://docs.licensespring.com/license-api/floating/feature/release](https://docs.licensespring.com/license-api/floating/feature/release)
+
+```javascript
+featureRelease(payload: Managed<LicenseIdentificatorAndFeature>): Promise<boolean>
+```
+
+#### Change User Password
+
+[https://docs.licensespring.com/license-api/change-password](https://docs.licensespring.com/license-api/change-password)
+
+```javascript
+changePassword(payload: PasswordChangePayload): Promise<boolean>
+```
+
+#### List Product Versions for License
+
+[https://docs.licensespring.com/license-api/versions](https://docs.licensespring.com/license-api/versions)
+
+```javascript
+getVersions(payload: Managed<LicenseIdentificator>): Promise<VersionsResponse>
+```
+
+#### Product Installation File Info for License
+
+[https://docs.licensespring.com/license-api/installation-file](https://docs.licensespring.com/license-api/installation-file)
+
+```javascript
+getInstallationFile(payload: Managed<LicenseIdentificatorWithInstallation>): Promise<InstallationFileResponse>
+```
+
+#### Get Single Sign On URL
+
+[https://docs.licensespring.com/license-api/sso-url](https://docs.licensespring.com/license-api/sso-url)
+
+```javascript
+getSSOUrl(payload: SSOURLParams): Promise<{ url: string }>
+```
+
+#### Get Air Gap Activation Code
+
+[https://docs.licensespring.com/license-entitlements/activation-types/air-gapped](https://docs.licensespring.com/license-entitlements/activation-types/air-gapped)
+
+```javascript
+getAirGapActivationCode(initializationCode: string, licenseKey: string)
+```
+
+#### Activate Air-Gapped License
+
+Performs `verifyConfirmationCode` and activates Air-Gapped License:
+```javascript
+activateAirGapLicense(confirmationCode: string, licenseKey: string, policyFilePath: string, policyID: string)
+```
+
+#### Is License Valid
+
+Checks if License is enabled, active and not expired:
+```javascript
+isValid(license: LicenseResponse): boolean
+```
+
+#### Maintenance Days Remaining
+
+Returns days remaining in maintenance period:
+```javascript
+maintenanceDaysRemaining(license: LicenseResponse): number
+```
+
+#### Validity Days Remaining
+
+Returns days remaining in license validity period:
+```javascript
+daysRemaining(license: LicenseResponse): number
+```
+
+#### Load License File
+
+See [License File](#license-file)
+
+```javascript
+loadLicense(): License
+```
+
+#### Check License File For Corruption
+
+```javascript
+isLicenseFileCorrupted(): boolean
+```
+
+#### Clear Local Storage
+
+```javascript
+clearLocalStorage(): void
+```
+
+## License File
+
+For more info see our docs: [https://docs.licensespring.com/sdks/tutorials/best-practices/local-license-file](https://docs.licensespring.com/sdks/tutorials/best-practices/local-license-file) and [https://docs.licensespring.com/sdks/python/licensefile](https://docs.licensespring.com/sdks/python/licensefile)
+
+To load a local license file, create an instance of `LicenseManager` and call the method `loadLicense`:
+```javascript
+const licenseFile = licenseManager.loadLicense();
+```
+
+The License class provides an interface for working with the License File.
+
+### Methods
+
+#### Get Feature Data
+```javascript
+public featureData(featureCode: string): ProductFeature
+```
+
+#### Check License Status
+Throws an exception if the license is disabled, inactive or expired
+```javascript
+checkLicenseStatus(): void
+```
+
+#### Perform Full License Check
+Checks License status and saves to local license file
+```javascript
+check(includeExpiredFeatures: boolean = false): Promise<LicenseResponse>
+```
+
+#### Get Air-Gap License Deactivation Code
+```javascript
+getDeactivationCode(initializationCode: string): string
+```
+
+#### Deactivate Air-Gap License
+```javascript
+deactivateAirGap(confirmationCode: string): void
+```
+
+#### Deactivate License
+Deactivates a License, updates local license file. Optionally deletes license file
+```javascript
+deactivate(deleteLicense: boolean = false): Promise<boolean>
+```
+
+#### Local License Check
+Performs a local check using the local license file. Throws an exception if license is not valid
+```javascript
+localCheck(): Promise<true>
+```
+
+#### Change Password
+Performs password change for user associated to License
+```javascript
+changePassword(oldPassword: string, newPassword: string): Promise<boolean>
+```
+
+#### Add Local Consumption
+Adds a License consumption to the local license data
+```javascript
+addLocalConsumption(consumptions: number = 1)
+```
+
+#### Add Local Feature Consumption
+Adds a License feature consumption to the local license data
+```javascript
+addLocalFeatureConsumption(featureCode: string, consumptions: number = 1)
+```
+
+#### Sync License Feature Consumption
+Sends a feature consumption request to the server and updates local data
+```javascript
+syncFeatureConsumption(feature: { code: string, local_consumption: number }): Promise<boolean>
+```
+
+#### Sync License Consumption
+Syncs local consumptions to server
+```javascript
+syncConsumption(overages: number = -1): Promise<boolean>
+```
+
+#### Borrow Floating License
+```javascript
+floatingBorrow(borrowUntil: string, password?: string): Promise<boolean>
+```
+
+#### Release Floating License
+```javascript
+floatingRelease(): Promise<boolean>
+```
+
+#### Check Feature Status
+Checks License Feature status, throws exception if not active
+```javascript
+checkFeature(featureCode: string): Promise<void>
+```
+
+#### Release Borrowed Feature
+```javascript
+releaseFeature(featureCode: string): Promise<void>
+```
+
+#### Update Offline
+```javascript
+Update local cache from Offline License File (at given `path`). Optionally reset local consumption value.
+public updateOffline(path: string, resetConsumption: boolean): boolean
+```
+
+#### Deactivate Offline License
+```javascript
+deactivateOffline(offlinePath: string): Promise<void>
+```
+
+#### Get Product Details
+Retrieves Product Details from server
+```javascript
+productDetails(includeLatestVersion: boolean = false, includeCustomFields: boolean = false, includeExpiredFeatures: boolean = false): Promise<ProductDetailsResponse>
+```
+
+#### Get Product Details Local
+Retrieves Product Details from local data
+```javascript
+get productDetailsLocal()
+```
+
+#### Set Device Variables Local
+Set custom variables to local data
+```javascript
+setDeviceVariablesLocal(variables: { [key: string]: string|number }, save: boolean = true): void
+```
+
+#### Set Device Variables
+Send locally stored variables to server. Optionally save to license file
+```javascript
+setDeviceVariables(save: boolean = false): Promise<void>
+```
+
+#### Get Device Variable Local
+Get the value of a variable from local data
+```javascript
+getDeviceVariableLocal(variable: string)
+```
+
+#### Get Device Variables Local
+Get all variables from local data
+```javascript
+getDeviceVariablesLocal()
+```
+
+#### Get Device Variables
+```javascript
+getDeviceVariables(): Promise<DeviceVariable[]>
+```
+
+### Getters
+
+```javascript
+get allowGraceSubscriptionPeriod()
+get allowOverages()
+get allowUnlimitedActivations()
+get allowUnlimitedConsumptions()
+get borrowUntil()
+get consumptionPeriod()
+get consumptionReset()
+get customerInformation()
+get customFields()
+get daysRemaining()
+get daysSinceLastCheck()
+get expiryDate()
+get features()
+get floatingClientId()
+get floatingEndDate()
+get floatingInUseDevices()
+get floatingTimeout()
+get gracePeriod()
+get gracePeriodHoursRemaining()
+get id()
+get isAirGapped()
+get isBorrowed()
+get isControlledByFloatingServer()
+get isDeviceTransferAllowed()
+get isDeviceTransferLimited()
+get isExpired()
+get isFloating()
+get isFloatingExpired()
+get isGracePeriod()
+get isGracePeriodStarted()
+get isMaintenancePeriodExpired()
+get isSubcriptionGracePeriodStarted()
+get isTrial()
+get isValid()
+get isValidityPeriodExpired()
+get lastCheck()
+get lastUsage()
+get licenseActive()
+get licenseEnabled()
+get licenseKey()
+get licenseType()
+get licenseUser()
+get localConsumptions()
+get maintenanceDaysRemaining()
+get maintenancePeriod()
+get maxActivations()
+get maxConsumptions()
+get maxFloatingUsers()
+get maxOverages()
+get maxTransfers()
+get metadata()
+get policyID()
+get preventVm()
+get startDate()
+get subscriptionGracePeriod()
+get totalConsumptions()
+get transferCount()
+get validityPeriod()
+get validityWithGracePeriod()
+```
+
+## Hardware ID
+
+Both LicenseAPI and LicenseManager use the Hardware ID module to calculate a unique fingerprint for the local machine. The module provides multiple methods of determining the ID:
+```typescript
+export enum HardwareIdAlgorithm {
+  Default = 0,
+  WindowsHardwareFingerprintId = 1,
+  WindowsComputerSystemProductId = 2,
+  WindowsCryptographyId = 3,
+  LinuxMachineId = 4,
+  CloudPlatformsId = 5,
+};
+```
+The default method (0) covers all cases and fallbacks. If you override the default method, the method used should be consistent accross your project. For both LicenseAPI and LicenseManager, this can be overriden globally by setting the required value in the config object when initializing the LicenseAPI/LicenseManager, e.g.:
+
+```javascript
+const licenseAPI = new LicenseAPI({
+  apiKey: '12345678-4bfe-4e3a-8737-757004d6294c',
+  sharedKey: 'eYuHrlajvIVTiSFIXpxpKhw78f4Ewy-00-12345678',
+  appName: 'js-sdk-test-1',
+  appVersion: '0.0.1',
+  hardwareIDMethod: 5,
+});
+```
+
+
+## Types
+
+The following are typescript definitions for all the types used in the SDK:
+
+```typescript
+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,
+  /** @defaultValue false */
+  include_expired_features?: boolean,
+  /** @defaultValue false */
+  include_latest_version?: boolean,
+  /** @defaultValue false */
+  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 };
+
+/**
+ * @type {LicenseIdentificator}
+ *
+ * An object that identifies a License using either a license-key, user credentials or single sign-on credentials.
+ * Optionally can include a `license_id` property to force a specific license is being selected.
+ */
+export type LicenseIdentificator = (
+  XOR<LicenseIdentificatorKeyBased, LicenseIdentificatorUserBased>
+) & LicenseIdentificatiorRequired;
+
+export type LicenseActivationIdentificator = (
+  XOR<LicenseIdentificatorKeyBased, LicenseActivationIdentificatorUserBased, LicenseIdentificatorUserSSOBased>
+) & LicenseIdentificatiorRequired;
+
+/**
+ * @type {LicenseUser}
+ *
+ * An object describing a User associated to a specific license
+ */
+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,
+};
+
+/**
+ * @type {ProductDetails}
+ *
+ * An object describing the basic properties of a Product
+ */
+export type ProductDetails = {
+  product_id: number,
+  product_name: string,
+  short_code: string,
+  authorization_method: 'license-key' | 'user',
+  metadata: JSON,
+};
+
+/**
+ * @type {Customer}
+ *
+ * An object describing a Customer
+ */
+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,
+};
+
+/**
+ * @type {CustomField}
+ *
+ * An object describing a Custom Field. These are key-value pairs assigned to a Product and inherited by that product's Licenses. They can be overriden on the License level
+ */
+export type CustomField = {
+  name: string,
+  data_type: 'numer' | 'text' | 'date/time',
+  value: string,
+};
+
+/**
+ * @type {ProductFeature}
+ *
+ * An object describing a Product Feature. These are custom attributes assigned to a Product and inherited by that product's Licenses
+ */
+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,
+}>;
+
+/**
+ * @type {LicenseType}
+ *
+ * Declares the type of License which is always one of the following:
+ *
+ * - *perpetual*: A perpetual license does not expire. The `is_expired` field on such a license will always be `false`.
+ * Note that a perpetual *trial* license (`is_trial` flag is set to `true`) does have an `validity_period`, which refers to the end of the trial period.
+ *
+ * - *time-limited*: Has a `validity_period` set as a calendar date. After the date has passed, the `is_expired` flag will be set to `true`.
+ *
+ * - *subscription*: Uses an external source of truth such as a 3rd party service to determine the state of the License.
+ *
+ * - *consumption*: Permits usage metering. These licenses set a value the vendor wishes to meter, and then record the times that resource has been used.
+ * Includes the following properties: `max_consumptions`, `total_consumptions`, `allow_unlimited_consumptions`, `allow_overages`, `max_overages`, `reset_consumption` and `consumption_period`.
+ *
+ */
+export type LicenseType = 'perpetual' | 'time-limited' | 'consumption' | 'subscription';
+
+/**
+ * @type {LicenseResponse}
+ *
+ * The License object received as a response when checking or activating a License. Includes a set of common properties and additional ones which may or may not appear depending on `license_type`, `is_trial`, `is_floating`/`is_floating_cloud` and Product `authorization_method` (key-based vs. user based).
+ */
+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,
+},
+{}
+>;
+
+/**
+ * @type {LicenseResponseOffline}
+ *
+ * The License object received as a response when activating a License using the Offline method.
+ * This type is equal to LicenseResponse with the addition of the `license_signature_v2` property.
+ */
+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,
+  /** Username */
+  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 enum HardwareIdAlgorithm {
+  Default = 0,
+  WindowsHardwareFingerprintId = 1,
+  WindowsComputerSystemProductId = 2,
+  WindowsCryptographyId = 3,
+  LinuxMachineId = 4,
+  CloudPlatformsId = 5,
+};
+
+/** Date string in ISO 8601 format (always in UTC timezone) with optional separators and optional time component, e.g.:
+ *
+ * "2024-09-27T23:30:48.016Z"
+ *
+ * "2024-09-27 23:30:48.016"
+ *
+ * "2024-09-27 23:30:48"
+ *
+ * "2024-09-27 23:30"
+ *
+ * "2024-09-27"
+ *
+ */
+export type DateInputString = string;
+
+/** Date string in full ISO 8601 format, e.g. "2024-09-27T23:30:48.016Z". Note: this is always in UTC timezone */
+export type DateISO8601UTC = string;
+
+/** Date string in RFC 7231 format, e.g. "Fri, 27 Sep 2024 23:30:48 GMT". Note: this is always in GMT timezone */
+export type DateRFC7231 = 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>
+  >;
+```