@revenexx/node 0.0.1 → 0.0.2

package/dist/services/products.js

@@ -0,0 +1,3006 @@
+'use strict';
+
+var client = require('../client');
+
+class Products {
+  constructor(client) {
+    this.client = client;
+  }
+  productsList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        sku: paramsOrFirst,
+        attributeValues: rest[0],
+        completeness: rest[1],
+        deletedAt: rest[2],
+        enabled: rest[3],
+        familyId: rest[4],
+        familyVariantId: rest[5],
+        kind: rest[6],
+        parentId: rest[7],
+        quantifiedAssociations: rest[8],
+        taxClass: rest[9]
+      };
+    }
+    const sku = params.sku;
+    const attributeValues = params.attributeValues;
+    const completeness = params.completeness;
+    const deletedAt = params.deletedAt;
+    const enabled = params.enabled;
+    const familyId = params.familyId;
+    const familyVariantId = params.familyVariantId;
+    const kind = params.kind;
+    const parentId = params.parentId;
+    const quantifiedAssociations = params.quantifiedAssociations;
+    const taxClass = params.taxClass;
+    if (typeof sku === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "sku"');
+    }
+    const apiPath = "/v1/products";
+    const apiPayload = {};
+    if (typeof attributeValues !== "undefined") {
+      apiPayload["attribute_values"] = attributeValues;
+    }
+    if (typeof completeness !== "undefined") {
+      apiPayload["completeness"] = completeness;
+    }
+    if (typeof deletedAt !== "undefined") {
+      apiPayload["deleted_at"] = deletedAt;
+    }
+    if (typeof enabled !== "undefined") {
+      apiPayload["enabled"] = enabled;
+    }
+    if (typeof familyId !== "undefined") {
+      apiPayload["family_id"] = familyId;
+    }
+    if (typeof familyVariantId !== "undefined") {
+      apiPayload["family_variant_id"] = familyVariantId;
+    }
+    if (typeof kind !== "undefined") {
+      apiPayload["kind"] = kind;
+    }
+    if (typeof parentId !== "undefined") {
+      apiPayload["parent_id"] = parentId;
+    }
+    if (typeof quantifiedAssociations !== "undefined") {
+      apiPayload["quantified_associations"] = quantifiedAssociations;
+    }
+    if (typeof sku !== "undefined") {
+      apiPayload["sku"] = sku;
+    }
+    if (typeof taxClass !== "undefined") {
+      apiPayload["tax_class"] = taxClass;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetFamiliesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/asset_families";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetFamiliesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        labels: rest[0],
+        namingConvention: rest[1]
+      };
+    }
+    const code = params.code;
+    const labels = params.labels;
+    const namingConvention = params.namingConvention;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    const apiPath = "/v1/products/asset_families";
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof namingConvention !== "undefined") {
+      apiPayload["naming_convention"] = namingConvention;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetFamiliesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/asset_families/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetFamiliesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/asset_families/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetFamiliesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        code: rest[0],
+        labels: rest[1],
+        namingConvention: rest[2]
+      };
+    }
+    const id = params.id;
+    const code = params.code;
+    const labels = params.labels;
+    const namingConvention = params.namingConvention;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/asset_families/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof namingConvention !== "undefined") {
+      apiPayload["naming_convention"] = namingConvention;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetsList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/assets";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetsCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        assetFamilyId: paramsOrFirst,
+        code: rest[0],
+        attributeValues: rest[1],
+        mediaUuid: rest[2]
+      };
+    }
+    const assetFamilyId = params.assetFamilyId;
+    const code = params.code;
+    const attributeValues = params.attributeValues;
+    const mediaUuid = params.mediaUuid;
+    if (typeof assetFamilyId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "assetFamilyId"');
+    }
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    const apiPath = "/v1/products/assets";
+    const apiPayload = {};
+    if (typeof assetFamilyId !== "undefined") {
+      apiPayload["asset_family_id"] = assetFamilyId;
+    }
+    if (typeof attributeValues !== "undefined") {
+      apiPayload["attribute_values"] = attributeValues;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof mediaUuid !== "undefined") {
+      apiPayload["media_uuid"] = mediaUuid;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetsDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/assets/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetsGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/assets/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssetsUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        assetFamilyId: rest[0],
+        attributeValues: rest[1],
+        code: rest[2],
+        mediaUuid: rest[3]
+      };
+    }
+    const id = params.id;
+    const assetFamilyId = params.assetFamilyId;
+    const attributeValues = params.attributeValues;
+    const code = params.code;
+    const mediaUuid = params.mediaUuid;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/assets/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof assetFamilyId !== "undefined") {
+      apiPayload["asset_family_id"] = assetFamilyId;
+    }
+    if (typeof attributeValues !== "undefined") {
+      apiPayload["attribute_values"] = attributeValues;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof mediaUuid !== "undefined") {
+      apiPayload["media_uuid"] = mediaUuid;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssociationTypesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/association_types";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssociationTypesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        isQuantified: rest[0],
+        isTwoWay: rest[1],
+        labels: rest[2]
+      };
+    }
+    const code = params.code;
+    const isQuantified = params.isQuantified;
+    const isTwoWay = params.isTwoWay;
+    const labels = params.labels;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    const apiPath = "/v1/products/association_types";
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof isQuantified !== "undefined") {
+      apiPayload["is_quantified"] = isQuantified;
+    }
+    if (typeof isTwoWay !== "undefined") {
+      apiPayload["is_two_way"] = isTwoWay;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssociationTypesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/association_types/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssociationTypesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/association_types/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAssociationTypesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        code: rest[0],
+        isQuantified: rest[1],
+        isTwoWay: rest[2],
+        labels: rest[3]
+      };
+    }
+    const id = params.id;
+    const code = params.code;
+    const isQuantified = params.isQuantified;
+    const isTwoWay = params.isTwoWay;
+    const labels = params.labels;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/association_types/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof isQuantified !== "undefined") {
+      apiPayload["is_quantified"] = isQuantified;
+    }
+    if (typeof isTwoWay !== "undefined") {
+      apiPayload["is_two_way"] = isTwoWay;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeGroupsList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/attribute_groups";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeGroupsCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        labels: rest[0],
+        position: rest[1]
+      };
+    }
+    const code = params.code;
+    const labels = params.labels;
+    const position = params.position;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    const apiPath = "/v1/products/attribute_groups";
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeGroupsDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/attribute_groups/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeGroupsGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/attribute_groups/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeGroupsUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        code: rest[0],
+        labels: rest[1],
+        position: rest[2]
+      };
+    }
+    const id = params.id;
+    const code = params.code;
+    const labels = params.labels;
+    const position = params.position;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/attribute_groups/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeOptionsList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/attribute_options";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeOptionsCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        attributeId: paramsOrFirst,
+        code: rest[0],
+        labels: rest[1],
+        position: rest[2],
+        swatch: rest[3]
+      };
+    }
+    const attributeId = params.attributeId;
+    const code = params.code;
+    const labels = params.labels;
+    const position = params.position;
+    const swatch = params.swatch;
+    if (typeof attributeId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "attributeId"');
+    }
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    const apiPath = "/v1/products/attribute_options";
+    const apiPayload = {};
+    if (typeof attributeId !== "undefined") {
+      apiPayload["attribute_id"] = attributeId;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof swatch !== "undefined") {
+      apiPayload["swatch"] = swatch;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeOptionsDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/attribute_options/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeOptionsGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/attribute_options/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributeOptionsUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        attributeId: rest[0],
+        code: rest[1],
+        labels: rest[2],
+        position: rest[3],
+        swatch: rest[4]
+      };
+    }
+    const id = params.id;
+    const attributeId = params.attributeId;
+    const code = params.code;
+    const labels = params.labels;
+    const position = params.position;
+    const swatch = params.swatch;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/attribute_options/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof attributeId !== "undefined") {
+      apiPayload["attribute_id"] = attributeId;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof swatch !== "undefined") {
+      apiPayload["swatch"] = swatch;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/attributes";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        type: rest[0],
+        config: rest[1],
+        entityRef: rest[2],
+        entityType: rest[3],
+        groupId: rest[4],
+        isFilterable: rest[5],
+        isUnique: rest[6],
+        labels: rest[7],
+        localizable: rest[8],
+        position: rest[9],
+        scopable: rest[10],
+        usableInGrid: rest[11],
+        validation: rest[12]
+      };
+    }
+    const code = params.code;
+    const type = params.type;
+    const config = params.config;
+    const entityRef = params.entityRef;
+    const entityType = params.entityType;
+    const groupId = params.groupId;
+    const isFilterable = params.isFilterable;
+    const isUnique = params.isUnique;
+    const labels = params.labels;
+    const localizable = params.localizable;
+    const position = params.position;
+    const scopable = params.scopable;
+    const usableInGrid = params.usableInGrid;
+    const validation = params.validation;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    if (typeof type === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "type"');
+    }
+    const apiPath = "/v1/products/attributes";
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof config !== "undefined") {
+      apiPayload["config"] = config;
+    }
+    if (typeof entityRef !== "undefined") {
+      apiPayload["entity_ref"] = entityRef;
+    }
+    if (typeof entityType !== "undefined") {
+      apiPayload["entity_type"] = entityType;
+    }
+    if (typeof groupId !== "undefined") {
+      apiPayload["group_id"] = groupId;
+    }
+    if (typeof isFilterable !== "undefined") {
+      apiPayload["is_filterable"] = isFilterable;
+    }
+    if (typeof isUnique !== "undefined") {
+      apiPayload["is_unique"] = isUnique;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof localizable !== "undefined") {
+      apiPayload["localizable"] = localizable;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof scopable !== "undefined") {
+      apiPayload["scopable"] = scopable;
+    }
+    if (typeof type !== "undefined") {
+      apiPayload["type"] = type;
+    }
+    if (typeof usableInGrid !== "undefined") {
+      apiPayload["usable_in_grid"] = usableInGrid;
+    }
+    if (typeof validation !== "undefined") {
+      apiPayload["validation"] = validation;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/attributes/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/attributes/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsAttributesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        code: rest[0],
+        config: rest[1],
+        entityRef: rest[2],
+        entityType: rest[3],
+        groupId: rest[4],
+        isFilterable: rest[5],
+        isUnique: rest[6],
+        labels: rest[7],
+        localizable: rest[8],
+        position: rest[9],
+        scopable: rest[10],
+        type: rest[11],
+        usableInGrid: rest[12],
+        validation: rest[13]
+      };
+    }
+    const id = params.id;
+    const code = params.code;
+    const config = params.config;
+    const entityRef = params.entityRef;
+    const entityType = params.entityType;
+    const groupId = params.groupId;
+    const isFilterable = params.isFilterable;
+    const isUnique = params.isUnique;
+    const labels = params.labels;
+    const localizable = params.localizable;
+    const position = params.position;
+    const scopable = params.scopable;
+    const type = params.type;
+    const usableInGrid = params.usableInGrid;
+    const validation = params.validation;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/attributes/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof config !== "undefined") {
+      apiPayload["config"] = config;
+    }
+    if (typeof entityRef !== "undefined") {
+      apiPayload["entity_ref"] = entityRef;
+    }
+    if (typeof entityType !== "undefined") {
+      apiPayload["entity_type"] = entityType;
+    }
+    if (typeof groupId !== "undefined") {
+      apiPayload["group_id"] = groupId;
+    }
+    if (typeof isFilterable !== "undefined") {
+      apiPayload["is_filterable"] = isFilterable;
+    }
+    if (typeof isUnique !== "undefined") {
+      apiPayload["is_unique"] = isUnique;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof localizable !== "undefined") {
+      apiPayload["localizable"] = localizable;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof scopable !== "undefined") {
+      apiPayload["scopable"] = scopable;
+    }
+    if (typeof type !== "undefined") {
+      apiPayload["type"] = type;
+    }
+    if (typeof usableInGrid !== "undefined") {
+      apiPayload["usable_in_grid"] = usableInGrid;
+    }
+    if (typeof validation !== "undefined") {
+      apiPayload["validation"] = validation;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsBatch(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        ids: paramsOrFirst,
+        skus: rest[0]
+      };
+    }
+    const ids = params.ids;
+    const skus = params.skus;
+    const apiPath = "/v1/products/batch";
+    const apiPayload = {};
+    if (typeof ids !== "undefined") {
+      apiPayload["ids"] = ids;
+    }
+    if (typeof skus !== "undefined") {
+      apiPayload["skus"] = skus;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/categories";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        labels: rest[0],
+        parentId: rest[1],
+        xpath: rest[2],
+        position: rest[3],
+        values: rest[4]
+      };
+    }
+    const code = params.code;
+    const labels = params.labels;
+    const parentId = params.parentId;
+    const xpath = params.xpath;
+    const position = params.position;
+    const values = params.values;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    const apiPath = "/v1/products/categories";
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof parentId !== "undefined") {
+      apiPayload["parent_id"] = parentId;
+    }
+    if (typeof xpath !== "undefined") {
+      apiPayload["path"] = xpath;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof values !== "undefined") {
+      apiPayload["values"] = values;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        code: rest[0],
+        labels: rest[1],
+        parentId: rest[2],
+        xpath: rest[3],
+        position: rest[4],
+        values: rest[5]
+      };
+    }
+    const id = params.id;
+    const code = params.code;
+    const labels = params.labels;
+    const parentId = params.parentId;
+    const xpath = params.xpath;
+    const position = params.position;
+    const values = params.values;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof parentId !== "undefined") {
+      apiPayload["parent_id"] = parentId;
+    }
+    if (typeof xpath !== "undefined") {
+      apiPayload["path"] = xpath;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof values !== "undefined") {
+      apiPayload["values"] = values;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamiliesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/families";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamiliesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        imageAttribute: rest[0],
+        labelAttribute: rest[1],
+        labels: rest[2]
+      };
+    }
+    const code = params.code;
+    const imageAttribute = params.imageAttribute;
+    const labelAttribute = params.labelAttribute;
+    const labels = params.labels;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    const apiPath = "/v1/products/families";
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof imageAttribute !== "undefined") {
+      apiPayload["image_attribute"] = imageAttribute;
+    }
+    if (typeof labelAttribute !== "undefined") {
+      apiPayload["label_attribute"] = labelAttribute;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamiliesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/families/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamiliesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/families/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamiliesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        code: rest[0],
+        imageAttribute: rest[1],
+        labelAttribute: rest[2],
+        labels: rest[3]
+      };
+    }
+    const id = params.id;
+    const code = params.code;
+    const imageAttribute = params.imageAttribute;
+    const labelAttribute = params.labelAttribute;
+    const labels = params.labels;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/families/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof imageAttribute !== "undefined") {
+      apiPayload["image_attribute"] = imageAttribute;
+    }
+    if (typeof labelAttribute !== "undefined") {
+      apiPayload["label_attribute"] = labelAttribute;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyAttributesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/family_attributes";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyAttributesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        attributeId: paramsOrFirst,
+        familyId: rest[0],
+        isRequired: rest[1],
+        position: rest[2],
+        requiredChannels: rest[3]
+      };
+    }
+    const attributeId = params.attributeId;
+    const familyId = params.familyId;
+    const isRequired = params.isRequired;
+    const position = params.position;
+    const requiredChannels = params.requiredChannels;
+    if (typeof attributeId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "attributeId"');
+    }
+    if (typeof familyId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "familyId"');
+    }
+    const apiPath = "/v1/products/family_attributes";
+    const apiPayload = {};
+    if (typeof attributeId !== "undefined") {
+      apiPayload["attribute_id"] = attributeId;
+    }
+    if (typeof familyId !== "undefined") {
+      apiPayload["family_id"] = familyId;
+    }
+    if (typeof isRequired !== "undefined") {
+      apiPayload["is_required"] = isRequired;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof requiredChannels !== "undefined") {
+      apiPayload["required_channels"] = requiredChannels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyAttributesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/family_attributes/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyAttributesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/family_attributes/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyAttributesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        attributeId: rest[0],
+        familyId: rest[1],
+        isRequired: rest[2],
+        position: rest[3],
+        requiredChannels: rest[4]
+      };
+    }
+    const id = params.id;
+    const attributeId = params.attributeId;
+    const familyId = params.familyId;
+    const isRequired = params.isRequired;
+    const position = params.position;
+    const requiredChannels = params.requiredChannels;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/family_attributes/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof attributeId !== "undefined") {
+      apiPayload["attribute_id"] = attributeId;
+    }
+    if (typeof familyId !== "undefined") {
+      apiPayload["family_id"] = familyId;
+    }
+    if (typeof isRequired !== "undefined") {
+      apiPayload["is_required"] = isRequired;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof requiredChannels !== "undefined") {
+      apiPayload["required_channels"] = requiredChannels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyVariantsList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/family_variants";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyVariantsCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        familyId: rest[0],
+        axes: rest[1],
+        labels: rest[2]
+      };
+    }
+    const code = params.code;
+    const familyId = params.familyId;
+    const axes = params.axes;
+    const labels = params.labels;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    if (typeof familyId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "familyId"');
+    }
+    const apiPath = "/v1/products/family_variants";
+    const apiPayload = {};
+    if (typeof axes !== "undefined") {
+      apiPayload["axes"] = axes;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof familyId !== "undefined") {
+      apiPayload["family_id"] = familyId;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyVariantsDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/family_variants/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyVariantsGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/family_variants/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsFamilyVariantsUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        axes: rest[0],
+        code: rest[1],
+        familyId: rest[2],
+        labels: rest[3]
+      };
+    }
+    const id = params.id;
+    const axes = params.axes;
+    const code = params.code;
+    const familyId = params.familyId;
+    const labels = params.labels;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/family_variants/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof axes !== "undefined") {
+      apiPayload["axes"] = axes;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof familyId !== "undefined") {
+      apiPayload["family_id"] = familyId;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsMeasurementFamiliesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/measurement_families";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsMeasurementFamiliesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        standardUnit: rest[0],
+        labels: rest[1],
+        units: rest[2]
+      };
+    }
+    const code = params.code;
+    const standardUnit = params.standardUnit;
+    const labels = params.labels;
+    const units = params.units;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    if (typeof standardUnit === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "standardUnit"');
+    }
+    const apiPath = "/v1/products/measurement_families";
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof standardUnit !== "undefined") {
+      apiPayload["standard_unit"] = standardUnit;
+    }
+    if (typeof units !== "undefined") {
+      apiPayload["units"] = units;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsMeasurementFamiliesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/measurement_families/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsMeasurementFamiliesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/measurement_families/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsMeasurementFamiliesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        code: rest[0],
+        labels: rest[1],
+        standardUnit: rest[2],
+        units: rest[3]
+      };
+    }
+    const id = params.id;
+    const code = params.code;
+    const labels = params.labels;
+    const standardUnit = params.standardUnit;
+    const units = params.units;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/measurement_families/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof standardUnit !== "undefined") {
+      apiPayload["standard_unit"] = standardUnit;
+    }
+    if (typeof units !== "undefined") {
+      apiPayload["units"] = units;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductAssociationsList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/product_associations";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductAssociationsCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        associationTypeId: paramsOrFirst,
+        productId: rest[0],
+        targetProductId: rest[1],
+        position: rest[2],
+        quantity: rest[3]
+      };
+    }
+    const associationTypeId = params.associationTypeId;
+    const productId = params.productId;
+    const targetProductId = params.targetProductId;
+    const position = params.position;
+    const quantity = params.quantity;
+    if (typeof associationTypeId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "associationTypeId"');
+    }
+    if (typeof productId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "productId"');
+    }
+    if (typeof targetProductId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "targetProductId"');
+    }
+    const apiPath = "/v1/products/product_associations";
+    const apiPayload = {};
+    if (typeof associationTypeId !== "undefined") {
+      apiPayload["association_type_id"] = associationTypeId;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof productId !== "undefined") {
+      apiPayload["product_id"] = productId;
+    }
+    if (typeof quantity !== "undefined") {
+      apiPayload["quantity"] = quantity;
+    }
+    if (typeof targetProductId !== "undefined") {
+      apiPayload["target_product_id"] = targetProductId;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductAssociationsDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/product_associations/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductAssociationsGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/product_associations/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductAssociationsUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        associationTypeId: rest[0],
+        position: rest[1],
+        productId: rest[2],
+        quantity: rest[3],
+        targetProductId: rest[4]
+      };
+    }
+    const id = params.id;
+    const associationTypeId = params.associationTypeId;
+    const position = params.position;
+    const productId = params.productId;
+    const quantity = params.quantity;
+    const targetProductId = params.targetProductId;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/product_associations/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof associationTypeId !== "undefined") {
+      apiPayload["association_type_id"] = associationTypeId;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof productId !== "undefined") {
+      apiPayload["product_id"] = productId;
+    }
+    if (typeof quantity !== "undefined") {
+      apiPayload["quantity"] = quantity;
+    }
+    if (typeof targetProductId !== "undefined") {
+      apiPayload["target_product_id"] = targetProductId;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/product_categories";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        categoryId: paramsOrFirst,
+        productId: rest[0],
+        position: rest[1]
+      };
+    }
+    const categoryId = params.categoryId;
+    const productId = params.productId;
+    const position = params.position;
+    if (typeof categoryId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "categoryId"');
+    }
+    if (typeof productId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "productId"');
+    }
+    const apiPath = "/v1/products/product_categories";
+    const apiPayload = {};
+    if (typeof categoryId !== "undefined") {
+      apiPayload["category_id"] = categoryId;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof productId !== "undefined") {
+      apiPayload["product_id"] = productId;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/product_categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/product_categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        categoryId: rest[0],
+        position: rest[1],
+        productId: rest[2]
+      };
+    }
+    const id = params.id;
+    const categoryId = params.categoryId;
+    const position = params.position;
+    const productId = params.productId;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/product_categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof categoryId !== "undefined") {
+      apiPayload["category_id"] = categoryId;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof productId !== "undefined") {
+      apiPayload["product_id"] = productId;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntitiesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/reference_entities";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntitiesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        image: rest[0],
+        labels: rest[1]
+      };
+    }
+    const code = params.code;
+    const image = params.image;
+    const labels = params.labels;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    const apiPath = "/v1/products/reference_entities";
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof image !== "undefined") {
+      apiPayload["image"] = image;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntitiesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/reference_entities/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntitiesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/reference_entities/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntitiesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        code: rest[0],
+        image: rest[1],
+        labels: rest[2]
+      };
+    }
+    const id = params.id;
+    const code = params.code;
+    const image = params.image;
+    const labels = params.labels;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/reference_entities/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof image !== "undefined") {
+      apiPayload["image"] = image;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntityRecordsList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const apiPath = "/v1/products/reference_entity_records";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntityRecordsCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        referenceEntityId: rest[0],
+        attributeValues: rest[1],
+        labels: rest[2]
+      };
+    }
+    const code = params.code;
+    const referenceEntityId = params.referenceEntityId;
+    const attributeValues = params.attributeValues;
+    const labels = params.labels;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "code"');
+    }
+    if (typeof referenceEntityId === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "referenceEntityId"');
+    }
+    const apiPath = "/v1/products/reference_entity_records";
+    const apiPayload = {};
+    if (typeof attributeValues !== "undefined") {
+      apiPayload["attribute_values"] = attributeValues;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof referenceEntityId !== "undefined") {
+      apiPayload["reference_entity_id"] = referenceEntityId;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntityRecordsDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/reference_entity_records/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntityRecordsGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/reference_entity_records/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsReferenceEntityRecordsUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        attributeValues: rest[0],
+        code: rest[1],
+        labels: rest[2],
+        referenceEntityId: rest[3]
+      };
+    }
+    const id = params.id;
+    const attributeValues = params.attributeValues;
+    const code = params.code;
+    const labels = params.labels;
+    const referenceEntityId = params.referenceEntityId;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/reference_entity_records/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof attributeValues !== "undefined") {
+      apiPayload["attribute_values"] = attributeValues;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof referenceEntityId !== "undefined") {
+      apiPayload["reference_entity_id"] = referenceEntityId;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        attributeValues: rest[0],
+        completeness: rest[1],
+        deletedAt: rest[2],
+        enabled: rest[3],
+        familyId: rest[4],
+        familyVariantId: rest[5],
+        kind: rest[6],
+        parentId: rest[7],
+        quantifiedAssociations: rest[8],
+        sku: rest[9],
+        taxClass: rest[10]
+      };
+    }
+    const id = params.id;
+    const attributeValues = params.attributeValues;
+    const completeness = params.completeness;
+    const deletedAt = params.deletedAt;
+    const enabled = params.enabled;
+    const familyId = params.familyId;
+    const familyVariantId = params.familyVariantId;
+    const kind = params.kind;
+    const parentId = params.parentId;
+    const quantifiedAssociations = params.quantifiedAssociations;
+    const sku = params.sku;
+    const taxClass = params.taxClass;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxAPIRevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof attributeValues !== "undefined") {
+      apiPayload["attribute_values"] = attributeValues;
+    }
+    if (typeof completeness !== "undefined") {
+      apiPayload["completeness"] = completeness;
+    }
+    if (typeof deletedAt !== "undefined") {
+      apiPayload["deleted_at"] = deletedAt;
+    }
+    if (typeof enabled !== "undefined") {
+      apiPayload["enabled"] = enabled;
+    }
+    if (typeof familyId !== "undefined") {
+      apiPayload["family_id"] = familyId;
+    }
+    if (typeof familyVariantId !== "undefined") {
+      apiPayload["family_variant_id"] = familyVariantId;
+    }
+    if (typeof kind !== "undefined") {
+      apiPayload["kind"] = kind;
+    }
+    if (typeof parentId !== "undefined") {
+      apiPayload["parent_id"] = parentId;
+    }
+    if (typeof quantifiedAssociations !== "undefined") {
+      apiPayload["quantified_associations"] = quantifiedAssociations;
+    }
+    if (typeof sku !== "undefined") {
+      apiPayload["sku"] = sku;
+    }
+    if (typeof taxClass !== "undefined") {
+      apiPayload["tax_class"] = taxClass;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+}
+
+exports.Products = Products;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=products.js.map