Type Declarations

The package provides typescript declarations for classes, methods and properties.

Response Types

response-types.d.ts

export type ActivateBundleResponse = ActivateLicenseResponse[];

export type ActivateLicenseResponse = LicenseResponseBase & {
  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;
  })[];
}

export type ActivateOfflineBundleResponse = {
  licenses: ActivateOfflineResponseSublicense[];
  bundle_signature_v2: string,
}

export type ActivateOfflineResponseSublicense = ActivateLicenseResponse & {
  date: string,
  offline_signature: string,
}

export type ActivateOfflineResponse = ActivateOfflineResponseSublicense & {
  date: string,
  offline_signature: string,
  license_signature_v2: string,
}

export 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;
  };
};

export 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;
};

export type ChangePasswordResponse = 'password_changed';

export type CheckBundleResponse = CheckLicenseResponse[];

export 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;
};

export type CheckLicenseResponse = LicenseResponse & {
  license_active: boolean,
  license_enabled: boolean,
  license_signature: string,
  license_signature_v2?: string, // isFromPlatform only
};

export 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;
  })[];
};

export type DeactivateBundleResponse = 'license_deactivated';

export type DeactivateLicenseResponse = 'license_deactivated';

export type DeactivateOfflineBundleResponse = 'license_deactivated';

export type DeactivateOfflineResponse = 'license_deactivated';

export type DeviceLicensesResponse = FormatLicenseResponse & {
  user?: LicenseUserResponse
};

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

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

export type GetUserLicensesResponse = ({
  license: FormatLicenseResponse,
  user: LicenseUserResponse,
})[];

export 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;
  };
};

export type OauthUrlResponse = {
  url: string;
  login_type: string;
};

export 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 }[]
};

export type ProductsResponse = ({
  id: number;
  created_at: Date;
  product_name: string;
  short_code: string;
  active: boolean;
  valid_duration?: string;
  trial_days: number;
  max_activations?: number;
  hardware_id_required: boolean;
  is_upgrade: boolean;
  company_id: number;
  allow_trial: boolean;
  enable_maintenance_period?: boolean;
  floating_users: number;
  is_floating: boolean;
  is_node_locked: boolean;
  is_user_locked: boolean;
  maintenance_duration?: string;
  subscription_duration?: string;
  default_license_type: LicenseTypes,
  max_consumptions: number;
  authorization_method: AuthorizationMethod;
  prevent_vm: boolean;
  allow_overages: boolean;
  consumption_period?: ConsumptionPeriod;
  max_overages: number;
  reset_consumption: boolean;
  is_archived: boolean;
  is_floating_cloud: boolean;
  floating_timeout: number;
  is_bundle: boolean;
  metadata: JSONObjectRequired,
  features: {
    id: number;
    code: string;
    feature_type: 'activation' | 'consumption';
    max_consumption: number;
    metadata: JSONObjectRequired,
    metadata_string?: string;
  }[];
})[];

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

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

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

export 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;
});

export type TrialResponse = TrialExistingResponse | TrialNewResponse;

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

export type LicenseUserResponse = {
  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,
};

export type LicenseResponseBase = {
  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 | null,
  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 | null,
  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 | null,
  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,
}

export type FormatLicenseResponse = LicenseResponseBase & {
  license_active: boolean,
  license_enabled: boolean,
};

export type LicenseResponse = LicenseResponseBase & {
  borrowed_until: string | null,
  floating_in_use_devices?: number,
  is_borrowed: boolean,
  is_expired: boolean,
};

export type FeatureResponse = {
  id: number,
  code: string,
  name?: string,
  expiry_date: string | null,
  is_floating: boolean,
  is_floating_cloud: boolean,
  floating_timeout?: number,
  floating_users?: number,
  metadata: JSONObjectRequired,
  metadata_string?: string,
} & ({
  feature_type: 'activation',
} | {
  feature_type: 'consumption',
  allow_negative_consumptions: boolean,
  allow_overages: boolean,
  allow_unlimited_consumptions: boolean,
  consumption_period: 'daily' | 'weekly' | 'monthly' | 'annually',
  max_consumption: number,
  max_overages: number,
  reset_consumption: boolean,
  total_consumptions: number,
});

export type CustomerResponse = {
  email: string | undefined;
  company_name: string | undefined;
  reference: string | undefined;
  phone: string | undefined;
  first_name: string | undefined;
  last_name: string | undefined;
  city: string | undefined;
  postcode: string | undefined;
  state: string | undefined;
  country: string | undefined;
  address: string | undefined;
  customer_account: {
      id: number;
      name: string;
      code: string;
  } | null;
  metadata: JSONObjectRequired;
  metadata_string?: string;
};

export type CustomField = {
  name: string,
  data_type: 'numer' | 'text' | 'date/time',
  value: string | undefined;
};

export type ProductDetailsResponse = {
  product_id: number,
  product_name?: string,
  short_code: string,
  authorization_method: 'license-key' | 'user',
  metadata: JSONObjectRequired,
  metadata_string?: string,
}

export type AuthorizationMethod = 'license-key' | 'user';

export type ConsumptionPeriod = 'daily' | 'weekly' | 'monthly' | 'annually';

export enum LicenseTypes {
  perpetual = 'perpetual',
  time_limited = 'time-limited',
  consumption = 'consumption',
  subscription = 'subscription',
};

// eslint-disable-next-line @typescript-eslint/no-empty-object-type
export type JSONObjectRequired = { [key: string]: JSONValue } | {};

type JSONValue =
| string
| number
| boolean
| null
| JSONValue[]
| { [key: string]: JSONValue };

Parameters and Internal Types

internal-types.d.ts

export type LicensespringClientAuth = ({
  apiKey: string,
  sharedKey: string,
} | {
  clientID: string,
  clientSecret: string,
  tokenUrl: string,
});

export type LicensespringConfig = LicensespringClientAuth & {
  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,
  proxy?: AxiosProxyConfig,
  logLevel?: LogLevel,
};

export type LicensespringAPIConfig = LicensespringClientAuth & Omit<LicensespringConfig, 'productCode'>;

export type LicensespringConfigDef = Pick<LicensespringConfig, 'productCode'|'appName'|'appVersion'|'airGapKey'> & LicensespringClientAuth & {
  apiPath?: string,
  proxy?: AxiosProxyConfig,
  publicKey?: string,
  filename?: string,
  filePath?: string,
  gracePeriod?: number,
  fileKey?: string,
  isGuardFileEnabled?: boolean,
  hardwareIDMethod?: number,
  logLevel?: LogLevel,
  hardwareID?: string,
};

export type LicensespringAPIConfigDef = Pick<LicensespringConfig, 'appName'|'appVersion'|'airGapKey'> & LicensespringClientAuth & {
  apiPath?: string,
  proxy?: AxiosProxyConfig,
  publicKey?: string,
  filename?: string,
  filePath?: string,
  gracePeriod?: number,
  fileKey?: string,
  isGuardFileEnabled?: boolean,
  hardwareIDMethod?: number,
  logLevel?: LogLevel,
  hardwareID?: string,
};

export type LicensespringFloatingConfig = {
  apiPath: string,
  appVersion: string,
  hardwareIDMethod: number,
  sdkVersion: string,
  proxy?: AxiosProxyConfig,
};

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,
};

type LicenseIdentificatiorRequired = {
  hardware_id: string,
  product: string,
  bundle_code?: string,
  license_id?: number,
};

export type Managed<T> = Omit<T, 'product' | 'hardware_id'>;

/**
 * @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: 'daily' | 'weekly' | 'monthly' | 'annualy' | 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';

export type LicenseFilePayload = ActivateOfflineResponse & {
  offline_signature: string,
};

export type LicenseSaved = LicenseResponse & {
  policy_id: string;
};

export type LicenseData = {
  id: number;
  allow_grace_period: boolean,
  allow_overages?: boolean,
  allow_unlimited_activations: boolean,
  allow_unlimited_consumptions?: boolean,
  borrowed_until: string | null,
  can_borrow: boolean,
  channel: string,
  consumption_period?: ConsumptionPeriod,
  custom_fields: CustomField[],
  customer: Customer,
  device_id: number,
  enable_maintenance_period: boolean
  environment: string,
  eula_link: string,
  floating_in_use_devices?: number,
  floating_timeout: number,
  floating_users?: number,
  grace_period: number,
  hardware_id: string,
  hash_md5: string,
  installation_file: string,
  is_air_gapped: boolean,
  is_borrowed: boolean,
  is_expired: boolean,
  is_floating_cloud: boolean,
  is_floating: boolean,
  is_hardware_key_auth: boolean,
  is_trial: 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_consumptions?: number,
  max_license_users: number,
  max_overages?: number,
  max_transfers?: number,
  metadata: JSON,
  order_store_id: string,
  prevent_vm: boolean,
  product_details: ProductDetails,
  product_features: ProductFeature[],
  release_date: string,
  release_notes_link: string,
  requires_version: string,
  reset_consumption?: boolean,
  size: string,
  start_date: string | null,
  times_activated: number,
  total_consumptions?: number,
  transfer_count: number,
  trial_days?: number,
  validity_period: DateISO8601UTC | null,
  version: string,
} & ({
  license_key: string,
} | {
  user: LicenseUser,
});

export type GuardFileData = {
  id: string,
  device_id: string,
  date_created: string,
};

export type DeviceVariable = {
  id: number,
  device_id: number,
  created_at: DateISO8601UTC,
  variable: string,
  value: string,
};

export type LicenseProductFeature = {
  id: number,
  product_feature_id: number,
  max_consumption: number,
  allow_overages: boolean,
  max_overages: number,
  reset_consumption: number,
  consumption_period: 'daily' | 'weekly' | 'monthly' | 'annually' | 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 CreateOfflineActivationRequestPayload = {
  bundle_code?: string,
  hardware_id: string,
  hostname?: string,
  ip?: string,
  mac_address?: string,
  os_ver?: string,
  product: string,
  variables?: Record<string, any>,
  vm_info?: string,
} & ({
  license_key?: string,
} | {
  username?: string,
  password?: string,
});

export type CreateOfflineDeactivationRequestPayload = {
  bundle_code?: string,
  hardware_id: string,
  hostname?: string,
  ip?: string,
  mac_address?: string,
  os_ver?: string,
  product: string,
  vm_info?: string,
  consumptions?: number,
} & ({
  license_key?: string,
} | {
  username?: string,
  password?: string,
});

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;

/** Length of time expressed in days, months or years, e.g. 5d, 2m, 3y */
export type TimeLength = string;

export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'off';

Floating API v2 Types

floating-api-v2.d.ts

type FloatingAPIConfig = {
  apiPath: string,
  hardwareID?: string,
  hardwareIDMethod?: number,
  logLevel?: LogLevel,
  proxy?: AxiosProxyConfig,
  certChain: string,
  disableUserAuth?: boolean,
} & (
    {
      apiKey: string,
      sharedKey: string
    } | {
      clientID: string,
      clientSecret: string,
      tokenUrl: string
    }
  );

type AnyJson = Record<string, any>;
type RFC3339 = string; // RFC3339 (UTC), e.g. "2025-06-01T12:00:00Z"

interface PingResponse {
  message: string;
  version: string;
}

interface LoginResponse {
  token: string;
  expires_at: RFC3339;
  expires_in: number;  // seconds (float)
}

interface User {
  id: number;
  username: string;
  role: 'admin' | 'user';
  created_at: RFC3339;
  updated_at: RFC3339;
}

interface LoginUser {
  username: string;
  password: string;
}

interface ChangePasswordReq {
  username: string;
  old_password: string;
  new_password: string;
}

interface SetPasswordReq {
  password: string;
}

type AuthMeSuccessBody = {
  expires_at?: RFC3339;
  ExpiresAt?: RFC3339; 
  [key: string]: unknown;
};

interface CloudConfig {
  airGapPublicKey: string;
  apikey: string;
  apiprefix: string;
  baseURL: string;
  cacertificatePath: string;
  certificatePath: string;
  clientId: string;
  clientSecret: string;
  disableSync: boolean;
  id: number;
  privateKeyPath: string;
  serverPublicKey: string;
  sharedKey: string;
  syncIntervalHours: number;
  syncIntervalMinutes: number;
  useHardwareKey: boolean;
  useOAuth: boolean;
}

interface CloudConfigUpdate {
  airgap_public_key?: string;
  api_key?: string;
  api_prefix?: string;
  base_url?: string;
  client_id?: string;
  client_secret?: string;
  server_public_key?: string;
  shared_key?: string;
  use_oauth?: boolean;
}

interface AddLicenseRequest {
  product?: string;
  license_key?: string;
}

interface Company {
  id: number;
}

interface LicenseUser {
  id: number;
  email: string;
  is_active?: boolean;
  first_name: string;
  last_name: string;
  phone_number: string;
  is_initial_password: boolean;
  initial_password?: string;
  license_id?: number;
  order_store_id?: string;
  order_id?: number;
  max_activations: number;
  allow_unlimited_activations: boolean;
  total_activations: number;
}

interface ProductDetails {
  product_id: number;
  product_name: string;
  short_code: string;
  authorization_method: string;
  metadata: AnyJson | null;
  company_id: number;
  trial_days?: number;
  allow_overages?: boolean;
  max_overages?: number;
  prevent_vm?: boolean;
  floating_timeout?: number;
  validity_period?: string | null;
}

interface CustomerAccount {
  code: string;
  id: number;
  name: string;
}

interface Customer {
  email: string;
  first_name: string;
  last_name: string;
  company_name: string;
  phone: string;
  reference: string;
  address: string;
  postcode: string;
  city: string;
  country: string;
  state: string;
  customer_account?: CustomerAccount;
  metadata: AnyJson | null;
}

interface CustomField {
  name: string,
  value: string,
  data_type: string,
}

interface LicenseData {

  product?: string;
  hardware_id?: string;
  policy_id: number; // air-gapped
  is_licensed?: boolean;
  is_unlicensed_copy?: boolean;
  is_valid?: boolean;
  is_dirty?: boolean;
  local_consumptions?: number;
  last_check?: RFC3339;
  last_usage_date?: RFC3339;
  grace_period_start?: RFC3339;
  floating_vp?: RFC3339;

  custom_fields: CustomField[] | null;
  user_data?: Record<string, string>;
  metadata: AnyJson | null;

  // License Info
  id: number;
  license_active: boolean;
  license_enabled: boolean;
  is_expired: boolean;
  license_type: string;
  start_date: RFC3339 | null;
  signature?: string;
  is_trial?: boolean;
  trial_days: number;
  validity_period: RFC3339 | null;
  maintenance_period: RFC3339 | null;

  // consumption
  allow_overages: boolean;
  max_overages: number;
  max_consumptions: number;
  total_consumptions: number;
  allow_unlimited_consumptions: boolean;
  allow_negative_consumptions?: boolean;
  reset_consumption: boolean;
  consumption_period: string | null;

  // floating
  is_floating_cloud: boolean;
  is_floating: boolean;
  floating_timeout: number;
  floating_in_use_devices: number;
  floating_users: number;

  // borrowing / transfer
  max_borrow_time: number;
  prevent_vm: boolean;
  is_air_gapped: boolean;
  times_activated: number;
  max_activations: number;
  transfer_count: number;
  max_transfers: number;
  is_borrowed: boolean;
  offline_activated?: boolean;
  grace_period: number;

  // bundle
  is_bundle_activated?: boolean;
  bundle_license_id?: number;
  bundle_licenses?: LicenseData[];
  is_bundle?: boolean;

  customer: Customer;
  user?: LicenseUser;
  product_details: ProductDetails;
  license_features: LicenseFeature[];
  company?: Company;
  variables: DeviceVariable[];

  channel: string;
  enable_maintenance_period: boolean;
  environment: string;
  eula_link: string;
  hash_md5: string;
  installation_file: string;
  is_hardware_key_auth: boolean;
  offline_signature: string;
  license_signature_v2: string;
  release_date: string;
  release_notes_link: string;
  requires_version: string;
  size: string;
  version: string;
  max_license_users: number;

  allow_grace_period: boolean;
  allow_unlimited_activations: boolean;
  can_borrow: boolean;
  device_id: number;
  license_signature: string;
  order_store_id: string;
}

interface DeviceVariable {
  id?: number;
  name?: string;
  value?: string;
  variable?: string;
  created_at: RFC3339;
  device_id?: number;
}

interface LicenseFeature {
  id: number;
  code: string;
  name: string;
  feature_type: string;
  expiry_date: string;
  max_consumption: number;
  total_consumptions: number;
  local_consumptions?: number;
  allow_overages: boolean;
  max_overages: number;
  allow_unlimited_consumptions: boolean;
  allow_negative_consumptions?: boolean;
  reset_consumption: boolean;
  consumption_period: string | null;
  is_floating_cloud: boolean;
  is_floating: boolean;
  floating_timeout?: number;
  floating_users?: number;
  floating_in_use_devices?: number;
  floating_start?: RFC3339;
  floating_end?: RFC3339;
  metadata: AnyJson | null;
}

interface ActivateBundleResponse {
  status: 'ok';
  message: 'bundle added';
  license_ids: number[];
  bundle_license_id: number;
}

interface DeactivateBundleResponse {
  status: 'ok';
  message: 'bundle deactivated';
}

interface FloatingUser {
  id?: number; // ommited?
  username: string;
  email: string;
  license_id: number;
  product: string;
  product_id: number;
  floating_amount: number;
  floating_end_time: RFC3339;
  created_at: RFC3339;
  last_check: RFC3339;
  vendor_id: number;
  is_borrowed: boolean;
}

interface ActivateLicenseResponse {
  status: 'ok';
  message: 'license added';
  product: string;
  license_id: number;
}

interface AddConsumptionRequest {
  consumptions: number;
  allow_overages?: boolean;
  max_overages?: number;
}

interface ConsumptionResponse {
  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;
  license_signature: string;
}

interface FeatureConsumptionResponse extends ConsumptionResponse {
  is_floating_cloud: boolean;
  is_floating: boolean;
  floating_timeout: number;
  floating_users: number;
}

interface AddFeatureConsumptionRequest {
  consumptions: number;
  feature: string;
}

interface RegisterFeatureRequest {
  username: string;
  feature?: string;
  email?: string;
}
interface UnregisterFeatureRequest {
  username?: string;
  feature?: string;
}

interface AllFeatureUsersRequest {
  feature?: string;
}

interface RegisterRequestBody {
  username: string,
  role?: string,
  password: string,
}

interface RegisterRequestBodyInternal {
  Username: string,
  Role: string,
  Password: string,
}

interface UsernameRequest {
  username: string;
}

interface BorrowUserRequest {
  username: string;
  borrowed_until?: RFC3339;
}

interface BorrowResponse {
  license_id?: number;
  device_id?: string;
  borrowed_until?: string;
  license_signature?: string;
  max_borrow_time?: number;
}

interface OfflineRequestInput {
  product?: string;
  license_key?: string;
}

interface BundleRequest {
  bundle: string;
  license_key: string;
}

interface GenerateOfflineRequestResponse {
  status: 'ok';
  request_data: string; // base64 payload
}

interface GenerateAirgapRequestBody {
  initialization_code: string;
  license_key: string;
  product: string;
}

interface GenerateAirgapDeactivationRequestBody {
  initialization_code: string;
  license_key: string;
}

interface DeactivateAirgapRequestBody {
  confirmation_code: string;
  license_key: string;
}

interface SyncConfig {
  enabled: boolean;
  hours: number;
  minutes: number;
}

interface SyncEnableReq {
  enabled: boolean;
  hours?: number;
  minutes?: number;
}

interface FloatingFeatureUser {
  feature_id: number;
  username: string;
  email: string;
  license_id: number;
  feature: string;
  product: string;
  floating_amount: number;
  floating_end_time: RFC3339; 
  created_at: RFC3339;        
  last_check: RFC3339;        
  vendor_code: string;
  vendor_id: number;
}

interface FeatureCodeID {
  feature_id: number;
  feature_code: string;
  users_list: FloatingFeatureUser[];
}

type AllFeatureUsersResponse = FeatureCodeID[];

interface RegisterFeatureResponse extends LicenseFeature {
  license_id: number,
}

interface FeatureReleasedAllResponse {
  status: 'ok';
  message: 'all features released';
  license_id: number;
  feature: string;
}

interface UnregisterAllUsersResponse {
  status: 'ok';
  message: 'all users unregistered';
  license_id: number;
}

interface AirgapActivationCodeResponse {
  status: 'ok';
  hardware_id: string,
  activation_code: string,
}

interface AirgapDeactivationCodeResponse {
  status: 'ok';
  hardware_id: string,
  deactivation_code: string,
}

interface AirgapeDeactivatedResponse {
  status: 'ok';
  message: 'license_deactivated';
}

interface AirgapActivatedResponse {
  status: 'ok';
  message: 'airgap license activated';
  license_id: number;
}