@arrowsphere/api-client 3.193.0-rc-bdj-3 → 3.194.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.194.0] - 2025.05.12
+
+### Added
+- [customers] Add unknown licenses endpoint for reconciliation
+
+## [3.193.0] - 2025.05.09
+
+### Added
+- [licenses] allow to get aggregations for licenses
+
+
 ## [3.192.0] - 2025.04.29
 
 ### Added

package/build/customers/customersClient.d.ts

@@ -2,6 +2,7 @@ import { AbstractRestfulClient, Parameters } from '../abstractRestfulClient';
 import { GetResult } from '../getResult';
 import { DataCustomers } from './entities/dataCustomers';
 import { DataInvitation } from './entities/dataInvitation';
+import { DataUnknownLicenses } from './entities/dataUnknownLicenses';
 import { DataListOrders } from '../orders';
 import { CustomerContactList } from './entities/customers/customerContact/customerContactList';
 import { CustomerContact, CustomerContactRoleType, CustomerContactTypeType } from './entities/customers/customerContact/customerContact';
@@ -135,4 +136,5 @@ export declare class CustomersClient extends AbstractRestfulClient {
     cancelCustomerMigration(customerReference: string, program: string): Promise<void | APIResponseError>;
     postCustomerProvision(customerReference: string, payload: PostCustomerMigrationPayload): Promise<void>;
     getCustomerProvision(customerReference: string, program: string): Promise<GetResult<CustomerProvision>>;
+    getUnknownLicenses(customerReference: string, parameters?: Parameters): Promise<GetResult<DataUnknownLicenses>>;
 }

package/build/customers/customersClient.js

@@ -5,6 +5,7 @@ const abstractRestfulClient_1 = require("../abstractRestfulClient");
 const getResult_1 = require("../getResult");
 const dataCustomers_1 = require("./entities/dataCustomers");
 const dataInvitation_1 = require("./entities/dataInvitation");
+const dataUnknownLicenses_1 = require("./entities/dataUnknownLicenses");
 const orders_1 = require("../orders");
 const customerContactList_1 = require("./entities/customers/customerContact/customerContactList");
 const customerContact_1 = require("./entities/customers/customerContact/customerContact");
@@ -123,6 +124,10 @@ class CustomersClient extends abstractRestfulClient_1.AbstractRestfulClient {
         this.path = `/${customerReference}/provision`;
         return new getResult_1.GetResult(customerProvision_1.CustomerProvision, await this.get({ program }));
     }
+    async getUnknownLicenses(customerReference, parameters = {}) {
+        this.path = `/${customerReference}/unknownlicenses`;
+        return new getResult_1.GetResult(dataUnknownLicenses_1.DataUnknownLicenses, await this.get(parameters));
+    }
 }
 exports.CustomersClient = CustomersClient;
 //# sourceMappingURL=customersClient.js.map

package/build/customers/entities/dataUnknownLicenses.d.ts

@@ -0,0 +1,14 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { UnknownLicense, UnknownLicenseType } from './unknownLicenses/unknownLicense';
+export declare enum DataUnknownLicensesFields {
+    COLUMN_UNKNOWN_LICENSES = "unknownLicenses"
+}
+export declare type DataUnknownLicenseType = {
+    [DataUnknownLicensesFields.COLUMN_UNKNOWN_LICENSES]: UnknownLicenseType[];
+};
+export declare class DataUnknownLicenses extends AbstractEntity<DataUnknownLicenseType> {
+    #private;
+    constructor(dataUnknownLicenseDataInput: DataUnknownLicenseType);
+    get unknownLicenses(): UnknownLicense[];
+    toJSON(): DataUnknownLicenseType;
+}

package/build/customers/entities/dataUnknownLicenses.js

@@ -0,0 +1,39 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DataUnknownLicenses_unknownLicenses;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataUnknownLicenses = exports.DataUnknownLicensesFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const unknownLicense_1 = require("./unknownLicenses/unknownLicense");
+var DataUnknownLicensesFields;
+(function (DataUnknownLicensesFields) {
+    DataUnknownLicensesFields["COLUMN_UNKNOWN_LICENSES"] = "unknownLicenses";
+})(DataUnknownLicensesFields = exports.DataUnknownLicensesFields || (exports.DataUnknownLicensesFields = {}));
+class DataUnknownLicenses extends abstractEntity_1.AbstractEntity {
+    constructor(dataUnknownLicenseDataInput) {
+        super(dataUnknownLicenseDataInput);
+        _DataUnknownLicenses_unknownLicenses.set(this, void 0);
+        __classPrivateFieldSet(this, _DataUnknownLicenses_unknownLicenses, dataUnknownLicenseDataInput[DataUnknownLicensesFields.COLUMN_UNKNOWN_LICENSES].map((result) => new unknownLicense_1.UnknownLicense(result)), "f");
+    }
+    get unknownLicenses() {
+        return __classPrivateFieldGet(this, _DataUnknownLicenses_unknownLicenses, "f");
+    }
+    toJSON() {
+        return {
+            [DataUnknownLicensesFields.COLUMN_UNKNOWN_LICENSES]: this.unknownLicenses.map((result) => result.toJSON()),
+        };
+    }
+}
+exports.DataUnknownLicenses = DataUnknownLicenses;
+_DataUnknownLicenses_unknownLicenses = new WeakMap();
+//# sourceMappingURL=dataUnknownLicenses.js.map

package/build/customers/entities/unknownLicenses/relation.d.ts

@@ -0,0 +1,19 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum RelationFields {
+    COLUMN_TYPE = "type",
+    COLUMN_PARTNER_REF = "partnerRef",
+    COLUMN_SCOPE = "scope"
+}
+export declare type RelationType = {
+    [RelationFields.COLUMN_TYPE]: string;
+    [RelationFields.COLUMN_PARTNER_REF]?: string;
+    [RelationFields.COLUMN_SCOPE]: string;
+};
+export declare class Relation extends AbstractEntity<RelationType> {
+    #private;
+    constructor(relationDataInput: RelationType);
+    get type(): string;
+    get partnerRef(): string | undefined;
+    get scope(): string;
+    toJSON(): RelationType;
+}

package/build/customers/entities/unknownLicenses/relation.js

@@ -0,0 +1,53 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Relation_type, _Relation_partnerRef, _Relation_scope;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Relation = exports.RelationFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var RelationFields;
+(function (RelationFields) {
+    RelationFields["COLUMN_TYPE"] = "type";
+    RelationFields["COLUMN_PARTNER_REF"] = "partnerRef";
+    RelationFields["COLUMN_SCOPE"] = "scope";
+})(RelationFields = exports.RelationFields || (exports.RelationFields = {}));
+class Relation extends abstractEntity_1.AbstractEntity {
+    constructor(relationDataInput) {
+        var _a;
+        super(relationDataInput);
+        _Relation_type.set(this, void 0);
+        _Relation_partnerRef.set(this, void 0);
+        _Relation_scope.set(this, void 0);
+        __classPrivateFieldSet(this, _Relation_type, relationDataInput[RelationFields.COLUMN_TYPE], "f");
+        __classPrivateFieldSet(this, _Relation_partnerRef, (_a = relationDataInput[RelationFields.COLUMN_PARTNER_REF]) !== null && _a !== void 0 ? _a : undefined, "f");
+        __classPrivateFieldSet(this, _Relation_scope, relationDataInput[RelationFields.COLUMN_SCOPE], "f");
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _Relation_type, "f");
+    }
+    get partnerRef() {
+        return __classPrivateFieldGet(this, _Relation_partnerRef, "f");
+    }
+    get scope() {
+        return __classPrivateFieldGet(this, _Relation_scope, "f");
+    }
+    toJSON() {
+        return {
+            [RelationFields.COLUMN_TYPE]: this.type,
+            [RelationFields.COLUMN_PARTNER_REF]: this.partnerRef,
+            [RelationFields.COLUMN_SCOPE]: this.scope,
+        };
+    }
+}
+exports.Relation = Relation;
+_Relation_type = new WeakMap(), _Relation_partnerRef = new WeakMap(), _Relation_scope = new WeakMap();
+//# sourceMappingURL=relation.js.map

package/build/customers/entities/unknownLicenses/unknownLicense.d.ts

@@ -0,0 +1,56 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { Relation, RelationType } from './relation';
+export declare enum UnknownLicenseFields {
+    COLUMN_VENDOR_REFERENCE_ID = "vendorReferenceId",
+    COLUMN_OFFER_NAME = "offerName",
+    COLUMN_OFFER_SKU = "offerSku",
+    COLUMN_PRICEBAND_ARROWSPHERE_SKU = "pricebandArrowsphereSku",
+    COLUMN_QUANTITY = "quantity",
+    COLUMN_SUBSCRIPTION_START_DATE = "subscriptionStartDate",
+    COLUMN_FRIENDLY_NAME = "friendlyName",
+    COLUMN_IS_RECONCILABLE = "isReconcilable",
+    COLUMN_RECONCILABLE_MESSAGE = "reconcilableMessage",
+    COLUMN_IS_ADDON = "isAddon",
+    COLUMN_PARENT_SUBSCRIPTION_VENDOR_REFERENCE_ID = "parentSubscriptionVendorReferenceId",
+    COLUMN_PARENT_PARTNER_REF = "parentPartnerRef",
+    COLUMN_STATUS = "status",
+    COLUMN_GROUP = "group",
+    COLUMN_RELATIONS = "relations"
+}
+export declare type UnknownLicenseType = {
+    [UnknownLicenseFields.COLUMN_VENDOR_REFERENCE_ID]: string;
+    [UnknownLicenseFields.COLUMN_OFFER_NAME]: string | null;
+    [UnknownLicenseFields.COLUMN_OFFER_SKU]: string | null;
+    [UnknownLicenseFields.COLUMN_PRICEBAND_ARROWSPHERE_SKU]: string | null;
+    [UnknownLicenseFields.COLUMN_QUANTITY]: number | null;
+    [UnknownLicenseFields.COLUMN_SUBSCRIPTION_START_DATE]: string | null;
+    [UnknownLicenseFields.COLUMN_FRIENDLY_NAME]: string;
+    [UnknownLicenseFields.COLUMN_IS_RECONCILABLE]: boolean;
+    [UnknownLicenseFields.COLUMN_RECONCILABLE_MESSAGE]: string;
+    [UnknownLicenseFields.COLUMN_IS_ADDON]: boolean;
+    [UnknownLicenseFields.COLUMN_PARENT_SUBSCRIPTION_VENDOR_REFERENCE_ID]: string | undefined;
+    [UnknownLicenseFields.COLUMN_PARENT_PARTNER_REF]: string | undefined;
+    [UnknownLicenseFields.COLUMN_STATUS]: string | null;
+    [UnknownLicenseFields.COLUMN_GROUP]: string | null;
+    [UnknownLicenseFields.COLUMN_RELATIONS]: RelationType[];
+};
+export declare class UnknownLicense extends AbstractEntity<UnknownLicenseType> {
+    #private;
+    constructor(UnknownLicenseDataInput: UnknownLicenseType);
+    get vendorReferenceId(): string;
+    get offerName(): string | null;
+    get offerSku(): string | null;
+    get pricebandArrowsphereSku(): string | null;
+    get quantity(): number | null;
+    get subscriptionStartDate(): string | null;
+    get friendlyName(): string;
+    get isReconcilable(): boolean;
+    get reconcilableMessage(): string;
+    get isAddon(): boolean;
+    get parentSubscriptionVendorReferenceId(): string | undefined;
+    get parentPartnerRef(): string | undefined;
+    get status(): string | null;
+    get group(): string | null;
+    get relations(): Relation[];
+    toJSON(): UnknownLicenseType;
+}

package/build/customers/entities/unknownLicenses/unknownLicense.js

@@ -0,0 +1,142 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _UnknownLicense_vendorReferenceId, _UnknownLicense_offerName, _UnknownLicense_offerSku, _UnknownLicense_pricebandArrowsphereSku, _UnknownLicense_quantity, _UnknownLicense_subscriptionStartDate, _UnknownLicense_friendlyName, _UnknownLicense_isReconcilable, _UnknownLicense_reconcilableMessage, _UnknownLicense_isAddon, _UnknownLicense_parentSubscriptionVendorReferenceId, _UnknownLicense_parentPartnerRef, _UnknownLicense_status, _UnknownLicense_group, _UnknownLicense_relations;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownLicense = exports.UnknownLicenseFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const relation_1 = require("./relation");
+var UnknownLicenseFields;
+(function (UnknownLicenseFields) {
+    UnknownLicenseFields["COLUMN_VENDOR_REFERENCE_ID"] = "vendorReferenceId";
+    UnknownLicenseFields["COLUMN_OFFER_NAME"] = "offerName";
+    UnknownLicenseFields["COLUMN_OFFER_SKU"] = "offerSku";
+    UnknownLicenseFields["COLUMN_PRICEBAND_ARROWSPHERE_SKU"] = "pricebandArrowsphereSku";
+    UnknownLicenseFields["COLUMN_QUANTITY"] = "quantity";
+    UnknownLicenseFields["COLUMN_SUBSCRIPTION_START_DATE"] = "subscriptionStartDate";
+    UnknownLicenseFields["COLUMN_FRIENDLY_NAME"] = "friendlyName";
+    UnknownLicenseFields["COLUMN_IS_RECONCILABLE"] = "isReconcilable";
+    UnknownLicenseFields["COLUMN_RECONCILABLE_MESSAGE"] = "reconcilableMessage";
+    UnknownLicenseFields["COLUMN_IS_ADDON"] = "isAddon";
+    UnknownLicenseFields["COLUMN_PARENT_SUBSCRIPTION_VENDOR_REFERENCE_ID"] = "parentSubscriptionVendorReferenceId";
+    UnknownLicenseFields["COLUMN_PARENT_PARTNER_REF"] = "parentPartnerRef";
+    UnknownLicenseFields["COLUMN_STATUS"] = "status";
+    UnknownLicenseFields["COLUMN_GROUP"] = "group";
+    UnknownLicenseFields["COLUMN_RELATIONS"] = "relations";
+})(UnknownLicenseFields = exports.UnknownLicenseFields || (exports.UnknownLicenseFields = {}));
+class UnknownLicense extends abstractEntity_1.AbstractEntity {
+    constructor(UnknownLicenseDataInput) {
+        var _a;
+        super(UnknownLicenseDataInput);
+        _UnknownLicense_vendorReferenceId.set(this, void 0);
+        _UnknownLicense_offerName.set(this, void 0);
+        _UnknownLicense_offerSku.set(this, void 0);
+        _UnknownLicense_pricebandArrowsphereSku.set(this, void 0);
+        _UnknownLicense_quantity.set(this, void 0);
+        _UnknownLicense_subscriptionStartDate.set(this, void 0);
+        _UnknownLicense_friendlyName.set(this, void 0);
+        _UnknownLicense_isReconcilable.set(this, void 0);
+        _UnknownLicense_reconcilableMessage.set(this, void 0);
+        _UnknownLicense_isAddon.set(this, void 0);
+        _UnknownLicense_parentSubscriptionVendorReferenceId.set(this, void 0);
+        _UnknownLicense_parentPartnerRef.set(this, void 0);
+        _UnknownLicense_status.set(this, void 0);
+        _UnknownLicense_group.set(this, void 0);
+        _UnknownLicense_relations.set(this, void 0);
+        __classPrivateFieldSet(this, _UnknownLicense_vendorReferenceId, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_VENDOR_REFERENCE_ID], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_offerName, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_OFFER_NAME], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_offerSku, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_OFFER_SKU], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_pricebandArrowsphereSku, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_PRICEBAND_ARROWSPHERE_SKU], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_quantity, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_QUANTITY], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_subscriptionStartDate, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_SUBSCRIPTION_START_DATE], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_friendlyName, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_FRIENDLY_NAME], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_isReconcilable, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_IS_RECONCILABLE], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_reconcilableMessage, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_RECONCILABLE_MESSAGE], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_isAddon, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_IS_ADDON], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_parentSubscriptionVendorReferenceId, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_PARENT_SUBSCRIPTION_VENDOR_REFERENCE_ID], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_parentPartnerRef, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_PARENT_PARTNER_REF], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_status, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_STATUS], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_group, UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_GROUP], "f");
+        __classPrivateFieldSet(this, _UnknownLicense_relations, ((_a = UnknownLicenseDataInput[UnknownLicenseFields.COLUMN_RELATIONS]) !== null && _a !== void 0 ? _a : []).map((result) => new relation_1.Relation(result)), "f");
+    }
+    get vendorReferenceId() {
+        return __classPrivateFieldGet(this, _UnknownLicense_vendorReferenceId, "f");
+    }
+    get offerName() {
+        return __classPrivateFieldGet(this, _UnknownLicense_offerName, "f");
+    }
+    get offerSku() {
+        return __classPrivateFieldGet(this, _UnknownLicense_offerSku, "f");
+    }
+    get pricebandArrowsphereSku() {
+        return __classPrivateFieldGet(this, _UnknownLicense_pricebandArrowsphereSku, "f");
+    }
+    get quantity() {
+        return __classPrivateFieldGet(this, _UnknownLicense_quantity, "f");
+    }
+    get subscriptionStartDate() {
+        return __classPrivateFieldGet(this, _UnknownLicense_subscriptionStartDate, "f");
+    }
+    get friendlyName() {
+        return __classPrivateFieldGet(this, _UnknownLicense_friendlyName, "f");
+    }
+    get isReconcilable() {
+        return __classPrivateFieldGet(this, _UnknownLicense_isReconcilable, "f");
+    }
+    get reconcilableMessage() {
+        return __classPrivateFieldGet(this, _UnknownLicense_reconcilableMessage, "f");
+    }
+    get isAddon() {
+        return __classPrivateFieldGet(this, _UnknownLicense_isAddon, "f");
+    }
+    get parentSubscriptionVendorReferenceId() {
+        return __classPrivateFieldGet(this, _UnknownLicense_parentSubscriptionVendorReferenceId, "f");
+    }
+    get parentPartnerRef() {
+        return __classPrivateFieldGet(this, _UnknownLicense_parentPartnerRef, "f");
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _UnknownLicense_status, "f");
+    }
+    get group() {
+        return __classPrivateFieldGet(this, _UnknownLicense_group, "f");
+    }
+    get relations() {
+        return __classPrivateFieldGet(this, _UnknownLicense_relations, "f");
+    }
+    toJSON() {
+        return {
+            [UnknownLicenseFields.COLUMN_VENDOR_REFERENCE_ID]: this.vendorReferenceId,
+            [UnknownLicenseFields.COLUMN_OFFER_NAME]: this.offerName,
+            [UnknownLicenseFields.COLUMN_OFFER_SKU]: this.offerSku,
+            [UnknownLicenseFields.COLUMN_PRICEBAND_ARROWSPHERE_SKU]: this
+                .pricebandArrowsphereSku,
+            [UnknownLicenseFields.COLUMN_QUANTITY]: this.quantity,
+            [UnknownLicenseFields.COLUMN_SUBSCRIPTION_START_DATE]: this
+                .subscriptionStartDate,
+            [UnknownLicenseFields.COLUMN_FRIENDLY_NAME]: this.friendlyName,
+            [UnknownLicenseFields.COLUMN_IS_RECONCILABLE]: this.isReconcilable,
+            [UnknownLicenseFields.COLUMN_RECONCILABLE_MESSAGE]: this
+                .reconcilableMessage,
+            [UnknownLicenseFields.COLUMN_IS_ADDON]: this.isAddon,
+            [UnknownLicenseFields.COLUMN_PARENT_SUBSCRIPTION_VENDOR_REFERENCE_ID]: this
+                .parentSubscriptionVendorReferenceId,
+            [UnknownLicenseFields.COLUMN_PARENT_PARTNER_REF]: this.parentPartnerRef,
+            [UnknownLicenseFields.COLUMN_STATUS]: this.status,
+            [UnknownLicenseFields.COLUMN_GROUP]: this.group,
+            [UnknownLicenseFields.COLUMN_RELATIONS]: this.relations.map((result) => result.toJSON()),
+        };
+    }
+}
+exports.UnknownLicense = UnknownLicense;
+_UnknownLicense_vendorReferenceId = new WeakMap(), _UnknownLicense_offerName = new WeakMap(), _UnknownLicense_offerSku = new WeakMap(), _UnknownLicense_pricebandArrowsphereSku = new WeakMap(), _UnknownLicense_quantity = new WeakMap(), _UnknownLicense_subscriptionStartDate = new WeakMap(), _UnknownLicense_friendlyName = new WeakMap(), _UnknownLicense_isReconcilable = new WeakMap(), _UnknownLicense_reconcilableMessage = new WeakMap(), _UnknownLicense_isAddon = new WeakMap(), _UnknownLicense_parentSubscriptionVendorReferenceId = new WeakMap(), _UnknownLicense_parentPartnerRef = new WeakMap(), _UnknownLicense_status = new WeakMap(), _UnknownLicense_group = new WeakMap(), _UnknownLicense_relations = new WeakMap();
+//# sourceMappingURL=unknownLicense.js.map

package/build/customers/index.d.ts

@@ -6,5 +6,8 @@ export * from './entities/customers/customer';
 export * from './entities/customers/details/details';
 export * from './entities/dataCustomers';
 export * from './entities/dataInvitation';
+export * from './entities/dataUnknownLicenses';
 export * from './entities/invitations/company/company';
 export * from './entities/invitations/contact/invitationContact';
+export * from './entities/unknownLicenses/relation';
+export * from './entities/unknownLicenses/unknownLicense';

package/build/customers/index.js

@@ -22,6 +22,9 @@ __exportStar(require("./entities/customers/customer"), exports);
 __exportStar(require("./entities/customers/details/details"), exports);
 __exportStar(require("./entities/dataCustomers"), exports);
 __exportStar(require("./entities/dataInvitation"), exports);
+__exportStar(require("./entities/dataUnknownLicenses"), exports);
 __exportStar(require("./entities/invitations/company/company"), exports);
 __exportStar(require("./entities/invitations/contact/invitationContact"), exports);
+__exportStar(require("./entities/unknownLicenses/relation"), exports);
+__exportStar(require("./entities/unknownLicenses/unknownLicense"), exports);
 //# sourceMappingURL=index.js.map

package/build/graphqlApi/types/entities/order.d.ts

@@ -69,27 +69,3 @@ export declare type GraphqlApiOrderHistoryType = {
     order?: OrdersType;
     user?: UserType;
 };
-export declare type GraphqlApiOrderListType = {
-    id?: number;
-    country?: string;
-    createdAt?: string;
-    createdBy?: string;
-    createdByImpersonate?: string;
-    currency?: string;
-    endCustomerName?: string;
-    orderType?: string;
-    partnerId?: number;
-    partnerName?: string;
-    partnerTags?: string;
-    programId?: number;
-    programName?: string;
-    reference?: string;
-    scheduledAt?: string;
-    status?: string;
-    statusId?: number;
-    totalCommitment?: number;
-    totalPrice?: number;
-    updatedAt?: string;
-    uuid?: number;
-    vendorName?: string;
-};

package/build/graphqlApi/types/graphqlApiQueries.d.ts

@@ -3,7 +3,7 @@ import { ContactsType } from './entities/contact';
 import { GraphqlApiStaffType } from './entities/contributor';
 import { ContinentType, CountryType } from './entities/country';
 import { LicenseBudgetType } from './entities/licenseBudget';
-import { GraphqlApiOrderHistoryType, GraphqlApiOrderListType, OrdersType } from './entities/order';
+import { GraphqlApiOrderHistoryType, OrdersType } from './entities/order';
 import { OrganizationUnitsType } from './entities/organizationUnit';
 import { PartnertagType } from './entities/partnertag';
 import { GraphqlApiProgramType, ProgramLevelOptionGroupType, ProgramLevelType, SubscribedProgramType } from './entities/program';
@@ -127,7 +127,6 @@ export declare enum SelectDataField {
     ORGANIZATION_UNIT = "organizationUnit",
     ORDER = "order",
     ORDER_HISTORY = "orderHistory",
-    ORDER_LIST = "orderList",
     PARTNER = "partner",
     PARTNERTAG = "partnertag",
     PROGRAM = "program",
@@ -161,7 +160,6 @@ export declare type SelectAllResponseDataType = {
     [SelectDataField.ORGANIZATION_UNIT]?: OrganizationUnitsType[];
     [SelectDataField.ORDER]?: OrdersType[];
     [SelectDataField.ORDER_HISTORY]?: GraphqlApiOrderHistoryType[];
-    [SelectDataField.ORDER_LIST]?: GraphqlApiOrderListType[];
     [SelectDataField.PARTNER]?: PartnerType[];
     [SelectDataField.PARTNERTAG]?: PartnertagType[];
     [SelectDataField.PROGRAM]?: GraphqlApiProgramType[];

package/build/graphqlApi/types/graphqlApiQueries.js

@@ -99,7 +99,6 @@ var SelectDataField;
     SelectDataField["ORGANIZATION_UNIT"] = "organizationUnit";
     SelectDataField["ORDER"] = "order";
     SelectDataField["ORDER_HISTORY"] = "orderHistory";
-    SelectDataField["ORDER_LIST"] = "orderList";
     SelectDataField["PARTNER"] = "partner";
     SelectDataField["PARTNERTAG"] = "partnertag";
     SelectDataField["PROGRAM"] = "program";

package/build/graphqlApi/types/graphqlApiSchemas.d.ts

@@ -7,7 +7,7 @@ import { ErrorsType, PageType, Queries, SelectDataField, SelectableField } from
 import { ContactsType } from './entities/contact';
 import { SubscriptionType } from './entities/subscription';
 import { SpecialPriceRateType } from './entities/specialPriceRate';
-import { GraphqlApiOrderHistoryType, GraphqlApiOrderLinkType, GraphqlApiOrderListType, OrderItemsType, OrdersType } from './entities/order';
+import { GraphqlApiOrderHistoryType, GraphqlApiOrderLinkType, OrderItemsType, OrdersType } from './entities/order';
 import { GraphqlApiProgramType, ProgramBenefitType, ProgramLevelType, ProgramRequirementType, ProgramLevelOptionGroupType, ProgramLevelOptionType, SubscribedProgramType, SubscriptionExtraFieldType } from './entities/program';
 import { LicenseBudgetNotificationType, LicenseBudgetType } from './entities/licenseBudget';
 import { UserHistoryType, UserType } from './entities/user';
@@ -109,7 +109,6 @@ export declare type ErrorsSchema = Schema<ErrorsType, boolean>;
 export declare type GraphqlApiEavSchema = Schema<GraphqlApiEavType, boolean>;
 export declare type GraphqlApiOrderHistorySchema = Schema<GraphqlApiOrderHistoryType, boolean>;
 export declare type GraphqlApiOrderLinkSchema = Schema<GraphqlApiOrderLinkType, boolean>;
-export declare type GraphqlApiOrderListSchema = Schema<GraphqlApiOrderListType, boolean>;
 export declare type LicenseBudgetNotificationSchema = Schema<LicenseBudgetNotificationType, boolean>;
 export declare type BaseCompanySchema = Schema<BaseCompanyType, boolean>;
 export declare type OrganizationUnitSchema = Schema<OrganizationUnitsType, boolean>;

package/build/licenses/entities/filterFindResult.d.ts

@@ -1,10 +1,15 @@
 import { AbstractEntity } from '../../abstractEntity';
 import { LicenseFindResultFields } from './license/licenseFindResult';
+declare type FilterFindResultDataIterable = {
+    [field in LicenseFindResultFields]?: unknown;
+};
 /**
  * Filter data values
  */
-export declare type FilterFindResultDataValues = {
-    [field in LicenseFindResultFields]?: unknown;
+export declare type FilterFindResultDataValues = FilterFindResultDataIterable | LicenseFilterAggregationType[];
+export declare type LicenseFilterAggregationType = {
+    count: number;
+    values: string[];
 };
 /**
  * Filter data
@@ -44,3 +49,4 @@ export declare class FilterFindResult extends AbstractEntity<FilterFindResultDat
      */
     toJSON(): FilterFindResultData;
 }
+export {};

package/build/licenses/licensesClient.d.ts

@@ -32,6 +32,10 @@ import { LicenceCouponCodeHistoryResult } from './entities/history/licenceCoupon
  * Parameters passable to the request for refining search.
  */
 export declare enum LicenseFindParameters {
+    /**
+     * The key for aggregation search query parameter (to request extra aggregation, which are not provided by default)
+     */
+    DATA_AGGREGATION = "aggregations",
     /**
      * The key for keyword search query parameter (to search one string in all available search fields)
      */
@@ -177,6 +181,7 @@ export declare type LicenseRawFiltersParameters = {
  * Payload to pass the find request. Contains keyword(s), sort options, column filters and highlight option.
  */
 export declare type LicenseFindPayload = {
+    [LicenseFindParameters.DATA_AGGREGATION]?: string[];
     [LicenseFindParameters.DATA_KEYWORD]?: string;
     [LicenseFindParameters.DATA_KEYWORDS]?: LicenseKeywordsParameters;
     [LicenseFindParameters.DATA_FILTERS]?: LicenseFiltersParameters;
@@ -185,6 +190,7 @@ export declare type LicenseFindPayload = {
     [LicenseFindParameters.DATA_HIGHLIGHT]?: boolean;
 };
 export declare type LicenseFindRawPayload = {
+    [LicenseFindParameters.DATA_AGGREGATION]?: string[];
     [LicenseFindParameters.DATA_KEYWORD]?: string;
     [LicenseFindParameters.DATA_KEYWORDS]?: {
         license?: LicenseRawKeywordsParametersLicence;

package/build/licenses/licensesClient.js

@@ -27,6 +27,10 @@ const licenceCouponCodeHistoryResult_1 = require("./entities/history/licenceCoup
  */
 var LicenseFindParameters;
 (function (LicenseFindParameters) {
+    /**
+     * The key for aggregation search query parameter (to request extra aggregation, which are not provided by default)
+     */
+    LicenseFindParameters["DATA_AGGREGATION"] = "aggregations";
     /**
      * The key for keyword search query parameter (to search one string in all available search fields)
      */
@@ -257,6 +261,7 @@ class LicensesClient extends abstractRestfulClient_1.AbstractRestfulClient {
         this.setPerPage(perPage);
         this.setPage(page);
         const rawLicensePayload = {
+            aggregations: postData.aggregations,
             keyword: postData.keyword,
             highlight: postData.highlight,
         };
@@ -268,6 +273,14 @@ class LicensesClient extends abstractRestfulClient_1.AbstractRestfulClient {
                 ...this.createKeywords(postData.keywords, 'endCustomerOrganizationUnit'),
             };
         }
+        if (postData.keywords) {
+            // Flatten with prefix for each type of keyword (license and offer)
+            rawLicensePayload.keywords = {
+                ...this.createKeywords(postData.keywords, 'license'),
+                ...this.createKeywords(postData.keywords, 'offer'),
+                ...this.createKeywords(postData.keywords, 'endCustomerOrganizationUnit'),
+            };
+        }
         if (postData.filters) {
             // Flatten with prefix for each type of filter (license and offer)
             rawLicensePayload.filters = {

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/ArrowSphere/nodejs-api-client.git"
   },
-  "version": "3.193.0-rc-bdj-3",
+  "version": "3.194.0",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",