@revenexx/node 0.0.2 → 0.1.1

package/dist/services/products-data-model.js

@@ -0,0 +1,2080 @@
+'use strict';
+
+var client = require('../client');
+
+class ProductsDataModel {
+  constructor(client) {
+    this.client = client;
+  }
+  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],
+        id: rest[2],
+        code: rest[3],
+        labels: rest[4],
+        namingConvention: rest[5],
+        createdAt: rest[6],
+        updatedAt: rest[7]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const code = params.code;
+    const labels = params.labels;
+    const namingConvention = params.namingConvention;
+    const createdAt = params.createdAt;
+    const updatedAt = params.updatedAt;
+    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;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof namingConvention !== "undefined") {
+      apiPayload["naming_convention"] = namingConvention;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    if (typeof updatedAt !== "undefined") {
+      apiPayload["updated_at"] = updatedAt;
+    }
+    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.RevenexxException('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.RevenexxException('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.RevenexxException('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.RevenexxException('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
+    );
+  }
+  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],
+        id: rest[2],
+        code: rest[3],
+        isTwoWay: rest[4],
+        isQuantified: rest[5],
+        labels: rest[6],
+        createdAt: rest[7]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const code = params.code;
+    const isTwoWay = params.isTwoWay;
+    const isQuantified = params.isQuantified;
+    const labels = params.labels;
+    const createdAt = params.createdAt;
+    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;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof isTwoWay !== "undefined") {
+      apiPayload["is_two_way"] = isTwoWay;
+    }
+    if (typeof isQuantified !== "undefined") {
+      apiPayload["is_quantified"] = isQuantified;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    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.RevenexxException('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.RevenexxException('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.RevenexxException('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.RevenexxException('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
+    );
+  }
+  productsAttributeSchema(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        familyId: paramsOrFirst,
+        familyCode: rest[0],
+        entityType: rest[1],
+        entityRef: rest[2],
+        locale: rest[3],
+        channel: rest[4],
+        kind: rest[5]
+      };
+    }
+    const familyId = params.familyId;
+    const familyCode = params.familyCode;
+    const entityType = params.entityType;
+    const entityRef = params.entityRef;
+    const locale = params.locale;
+    const channel = params.channel;
+    const kind = params.kind;
+    const apiPath = "/v1/products/attribute-schema";
+    const apiPayload = {};
+    if (typeof familyId !== "undefined") {
+      apiPayload["family_id"] = familyId;
+    }
+    if (typeof familyCode !== "undefined") {
+      apiPayload["family_code"] = familyCode;
+    }
+    if (typeof entityType !== "undefined") {
+      apiPayload["entity_type"] = entityType;
+    }
+    if (typeof entityRef !== "undefined") {
+      apiPayload["entity_ref"] = entityRef;
+    }
+    if (typeof locale !== "undefined") {
+      apiPayload["locale"] = locale;
+    }
+    if (typeof channel !== "undefined") {
+      apiPayload["channel"] = channel;
+    }
+    if (typeof kind !== "undefined") {
+      apiPayload["kind"] = kind;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      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],
+        id: rest[2],
+        code: rest[3],
+        position: rest[4],
+        labels: rest[5],
+        createdAt: rest[6],
+        updatedAt: rest[7]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const code = params.code;
+    const position = params.position;
+    const labels = params.labels;
+    const createdAt = params.createdAt;
+    const updatedAt = params.updatedAt;
+    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;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    if (typeof updatedAt !== "undefined") {
+      apiPayload["updated_at"] = updatedAt;
+    }
+    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.RevenexxException('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.RevenexxException('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.RevenexxException('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.RevenexxException('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],
+        id: rest[2],
+        attributeId: rest[3],
+        code: rest[4],
+        position: rest[5],
+        swatch: rest[6],
+        labels: rest[7],
+        createdAt: rest[8]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const attributeId = params.attributeId;
+    const code = params.code;
+    const position = params.position;
+    const swatch = params.swatch;
+    const labels = params.labels;
+    const createdAt = params.createdAt;
+    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;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof attributeId !== "undefined") {
+      apiPayload["attribute_id"] = attributeId;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof swatch !== "undefined") {
+      apiPayload["swatch"] = swatch;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    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.RevenexxException('Missing required parameter: "attributeId"');
+    }
+    if (typeof code === "undefined") {
+      throw new client.RevenexxException('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.RevenexxException('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.RevenexxException('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.RevenexxException('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],
+        id: rest[2],
+        code: rest[3],
+        entityType: rest[4],
+        entityRef: rest[5],
+        type: rest[6],
+        groupId: rest[7],
+        localizable: rest[8],
+        scopable: rest[9],
+        isUnique: rest[10],
+        isFilterable: rest[11],
+        usableInGrid: rest[12],
+        validation: rest[13],
+        config: rest[14],
+        labels: rest[15],
+        position: rest[16],
+        createdAt: rest[17],
+        updatedAt: rest[18]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const code = params.code;
+    const entityType = params.entityType;
+    const entityRef = params.entityRef;
+    const type = params.type;
+    const groupId = params.groupId;
+    const localizable = params.localizable;
+    const scopable = params.scopable;
+    const isUnique = params.isUnique;
+    const isFilterable = params.isFilterable;
+    const usableInGrid = params.usableInGrid;
+    const validation = params.validation;
+    const config = params.config;
+    const labels = params.labels;
+    const position = params.position;
+    const createdAt = params.createdAt;
+    const updatedAt = params.updatedAt;
+    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;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof entityType !== "undefined") {
+      apiPayload["entity_type"] = entityType;
+    }
+    if (typeof entityRef !== "undefined") {
+      apiPayload["entity_ref"] = entityRef;
+    }
+    if (typeof type !== "undefined") {
+      apiPayload["type"] = type;
+    }
+    if (typeof groupId !== "undefined") {
+      apiPayload["group_id"] = groupId;
+    }
+    if (typeof localizable !== "undefined") {
+      apiPayload["localizable"] = localizable;
+    }
+    if (typeof scopable !== "undefined") {
+      apiPayload["scopable"] = scopable;
+    }
+    if (typeof isUnique !== "undefined") {
+      apiPayload["is_unique"] = isUnique;
+    }
+    if (typeof isFilterable !== "undefined") {
+      apiPayload["is_filterable"] = isFilterable;
+    }
+    if (typeof usableInGrid !== "undefined") {
+      apiPayload["usable_in_grid"] = usableInGrid;
+    }
+    if (typeof validation !== "undefined") {
+      apiPayload["validation"] = validation;
+    }
+    if (typeof config !== "undefined") {
+      apiPayload["config"] = config;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    if (typeof updatedAt !== "undefined") {
+      apiPayload["updated_at"] = updatedAt;
+    }
+    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.RevenexxException('Missing required parameter: "code"');
+    }
+    if (typeof type === "undefined") {
+      throw new client.RevenexxException('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.RevenexxException('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.RevenexxException('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.RevenexxException('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
+    );
+  }
+  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],
+        id: rest[2],
+        code: rest[3],
+        labelAttribute: rest[4],
+        imageAttribute: rest[5],
+        labels: rest[6],
+        createdAt: rest[7],
+        updatedAt: rest[8]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const code = params.code;
+    const labelAttribute = params.labelAttribute;
+    const imageAttribute = params.imageAttribute;
+    const labels = params.labels;
+    const createdAt = params.createdAt;
+    const updatedAt = params.updatedAt;
+    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;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labelAttribute !== "undefined") {
+      apiPayload["label_attribute"] = labelAttribute;
+    }
+    if (typeof imageAttribute !== "undefined") {
+      apiPayload["image_attribute"] = imageAttribute;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    if (typeof updatedAt !== "undefined") {
+      apiPayload["updated_at"] = updatedAt;
+    }
+    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.RevenexxException('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.RevenexxException('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.RevenexxException('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.RevenexxException('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],
+        id: rest[2],
+        familyId: rest[3],
+        attributeId: rest[4],
+        position: rest[5],
+        isRequired: rest[6],
+        requiredChannels: rest[7],
+        createdAt: rest[8]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const familyId = params.familyId;
+    const attributeId = params.attributeId;
+    const position = params.position;
+    const isRequired = params.isRequired;
+    const requiredChannels = params.requiredChannels;
+    const createdAt = params.createdAt;
+    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;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof familyId !== "undefined") {
+      apiPayload["family_id"] = familyId;
+    }
+    if (typeof attributeId !== "undefined") {
+      apiPayload["attribute_id"] = attributeId;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof isRequired !== "undefined") {
+      apiPayload["is_required"] = isRequired;
+    }
+    if (typeof requiredChannels !== "undefined") {
+      apiPayload["required_channels"] = requiredChannels;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    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.RevenexxException('Missing required parameter: "attributeId"');
+    }
+    if (typeof familyId === "undefined") {
+      throw new client.RevenexxException('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.RevenexxException('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.RevenexxException('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.RevenexxException('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],
+        id: rest[2],
+        familyId: rest[3],
+        code: rest[4],
+        labels: rest[5],
+        axes: rest[6],
+        createdAt: rest[7],
+        updatedAt: rest[8]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const familyId = params.familyId;
+    const code = params.code;
+    const labels = params.labels;
+    const axes = params.axes;
+    const createdAt = params.createdAt;
+    const updatedAt = params.updatedAt;
+    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;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof familyId !== "undefined") {
+      apiPayload["family_id"] = familyId;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof axes !== "undefined") {
+      apiPayload["axes"] = axes;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    if (typeof updatedAt !== "undefined") {
+      apiPayload["updated_at"] = updatedAt;
+    }
+    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.RevenexxException('Missing required parameter: "code"');
+    }
+    if (typeof familyId === "undefined") {
+      throw new client.RevenexxException('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.RevenexxException('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.RevenexxException('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.RevenexxException('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],
+        id: rest[2],
+        code: rest[3],
+        standardUnit: rest[4],
+        units: rest[5],
+        labels: rest[6],
+        createdAt: rest[7],
+        updatedAt: rest[8]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const code = params.code;
+    const standardUnit = params.standardUnit;
+    const units = params.units;
+    const labels = params.labels;
+    const createdAt = params.createdAt;
+    const updatedAt = params.updatedAt;
+    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;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof standardUnit !== "undefined") {
+      apiPayload["standard_unit"] = standardUnit;
+    }
+    if (typeof units !== "undefined") {
+      apiPayload["units"] = units;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    if (typeof updatedAt !== "undefined") {
+      apiPayload["updated_at"] = updatedAt;
+    }
+    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.RevenexxException('Missing required parameter: "code"');
+    }
+    if (typeof standardUnit === "undefined") {
+      throw new client.RevenexxException('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.RevenexxException('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.RevenexxException('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.RevenexxException('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
+    );
+  }
+}
+
+exports.ProductsDataModel = ProductsDataModel;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=products-data-model.js.map