@gofynd/fdk-client-javascript 1.0.0 → 1.0.2

package/sdk/platform/Catalog/CatalogPlatformApplicationClient.js

@@ -2,6 +2,8 @@ const Paginator = require("../../common/Paginator");
 const PlatformAPIClient = require("../PlatformAPIClient");
 const { FDKClientValidationError } = require("../../common/FDKError");
 const CatalogValidator = require("./CatalogPlatformApplicationValidator");
+const CatalogModel = require("./CatalogPlatformModel");
+const { Logger } = require("./../../common/Logger");
 
 class Catalog {
   constructor(config, applicationId) {
@@ -12,16 +14,15 @@ class Catalog {
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - A `id` is a unique identifier for a particular
-   *   detail. Pass the `id` of the keywords which you want to delete.
-   * @param {CreateSearchKeyword} arg.body
-   * @summary: Update Search Keyword
-   * @description: Update Search Keyword by its id. On successful request, returns the updated collection
+   *   detail. Pass the `id` of the keywords which you want to retrieve.
+   * @returns {Promise<GetSearchWordsDetailResponse>} - Success response
+   * @summary: Get a Search Keywords Details
+   * @description: Get the details of a words by its `id`. If successful, returns a Collection resource in the response body specified in `GetSearchWordsDetailResponseSchema`
    */
-  updateSearchKeywords({ id, body } = {}) {
-    const { error } = CatalogValidator.updateSearchKeywords().validate(
+  async getSearchKeywords({ id } = {}) {
+    const { error } = CatalogValidator.getSearchKeywords().validate(
       {
         id,
-        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -29,28 +30,63 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getSearchKeywords().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSearchKeywords",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "put",
+      "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/keyword/${id}/`,
       query_params,
-      body
+      undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetSearchWordsDetailResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSearchKeywords",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - A `id` is a unique identifier for a particular
-   *   detail. Pass the `id` of the keywords which you want to retrieve.
-   * @summary: Get a Search Keywords Details
-   * @description: Get the details of a words by its `id`. If successful, returns a Collection resource in the response body specified in `GetSearchWordsDetailResponseSchema`
+   *   detail. Pass the `id` of the keywords which you want to delete.
+   * @param {CreateSearchKeyword} arg.body
+   * @returns {Promise<GetSearchWordsData>} - Success response
+   * @summary: Update Search Keyword
+   * @description: Update Search Keyword by its id. On successful request, returns the updated collection
    */
-  getSearchKeywords({ id } = {}) {
-    const { error } = CatalogValidator.getSearchKeywords().validate(
+  async updateSearchKeywords({ id, body } = {}) {
+    const { error } = CatalogValidator.updateSearchKeywords().validate(
       {
         id,
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -58,25 +94,61 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.updateSearchKeywords().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateSearchKeywords",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
+      "put",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/keyword/${id}/`,
       query_params,
-      undefined
+      body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetSearchWordsData().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateSearchKeywords",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - A `id` is a unique identifier for a particular
    *   detail. Pass the `id` of the keywords which you want to delete.
+   * @returns {Promise<DeleteResponse>} - Success response
    * @summary: Delete a Search Keywords
    * @description: Delete a keywords by it's id. Returns an object that tells whether the keywords was deleted successfully
    */
-  deleteSearchKeywords({ id } = {}) {
+  async deleteSearchKeywords({ id } = {}) {
     const { error } = CatalogValidator.deleteSearchKeywords().validate(
       {
         id,
@@ -87,23 +159,119 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.deleteSearchKeywords().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteSearchKeywords",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/keyword/${id}/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.DeleteResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteSearchKeywords",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {CreateSearchKeyword} arg.body
+   * @returns {Promise<GetSearchWordsData>} - Success response
+   * @summary: Add a Custom Search Keywords
+   * @description: Create a Custom Search Keywords. See `CreateSearchKeywordSchema` for the list of attributes needed to create a mapping and /collections/query-options for the available options to create a rule. On successful request, returns a paginated list of collections specified in `CreateSearchKeywordSchema`
+   */
+  async createCustomKeyword({ body } = {}) {
+    const { error } = CatalogValidator.createCustomKeyword().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.createCustomKeyword().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createCustomKeyword",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "post",
+      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/keyword/`,
+      query_params,
+      body
+    );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetSearchWordsData().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createCustomKeyword",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<GetSearchWordsResponse>} - Success response
    * @summary: List all Search Custom Keyword Listing
    * @description: Custom Search Keyword allows you to map conditions with keywords to give you the ultimate results
    */
-  getAllSearchKeyword({} = {}) {
+  async getAllSearchKeyword({} = {}) {
     const { error } = CatalogValidator.getAllSearchKeyword().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -112,27 +280,59 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getAllSearchKeyword().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAllSearchKeyword",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/keyword/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetSearchWordsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAllSearchKeyword",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {CreateSearchKeyword} arg.body
-   * @summary: Add a Custom Search Keywords
-   * @description: Create a Custom Search Keywords. See `CreateSearchKeywordSchema` for the list of attributes needed to create a mapping and /collections/query-options for the available options to create a rule. On successful request, returns a paginated list of collections specified in `CreateSearchKeywordSchema`
+   * @param {string} arg.id - A `id` is a unique identifier for a particular
+   *   detail. Pass the `id` of the keywords which you want to retrieve.
+   * @returns {Promise<GetAutocompleteWordsResponse>} - Success response
+   * @summary: Get a Autocomplete Keywords Details
+   * @description: Get the details of a words by its `id`. If successful, returns a keywords resource in the response body specified in `GetAutocompleteWordsResponseSchema`
    */
-  createCustomKeyword({ body } = {}) {
-    const { error } = CatalogValidator.createCustomKeyword().validate(
+  async getAutocompleteKeywordDetail({ id } = {}) {
+    const { error } = CatalogValidator.getAutocompleteKeywordDetail().validate(
       {
-        body,
+        id,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -140,15 +340,51 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getAutocompleteKeywordDetail().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getAutocompleteKeywordDetail",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "post",
-      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/keyword/`,
+      "get",
+      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/autocomplete/${id}/`,
       query_params,
-      body
+      undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetAutocompleteWordsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getAutocompleteKeywordDetail",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -156,10 +392,11 @@ class Catalog {
    * @param {string} arg.id - A `id` is a unique identifier for a particular
    *   detail. Pass the `id` of the keywords which you want to delete.
    * @param {CreateAutocompleteKeyword} arg.body
+   * @returns {Promise<GetAutocompleteWordsResponse>} - Success response
    * @summary: Create & Update Autocomplete Keyword
    * @description: Update a mapping by it's id. On successful request, returns the updated Keyword mapping
    */
-  updateAutocompleteKeyword({ id, body } = {}) {
+  async updateAutocompleteKeyword({ id, body } = {}) {
     const { error } = CatalogValidator.updateAutocompleteKeyword().validate(
       {
         id,
@@ -171,26 +408,62 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.updateAutocompleteKeyword().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAutocompleteKeyword",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/autocomplete/${id}/`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetAutocompleteWordsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAutocompleteKeyword",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - A `id` is a unique identifier for a particular
-   *   detail. Pass the `id` of the keywords which you want to retrieve.
-   * @summary: Get a Autocomplete Keywords Details
-   * @description: Get the details of a words by its `id`. If successful, returns a keywords resource in the response body specified in `GetAutocompleteWordsResponseSchema`
+   *   detail. Pass the `id` of the keywords which you want to delete.
+   * @returns {Promise<DeleteResponse>} - Success response
+   * @summary: Delete a Autocomplete Keywords
+   * @description: Delete a keywords by it's id. Returns an object that tells whether the keywords was deleted successfully
    */
-  getAutocompleteKeywordDetail({ id } = {}) {
-    const { error } = CatalogValidator.getAutocompleteKeywordDetail().validate(
+  async deleteAutocompleteKeyword({ id } = {}) {
+    const { error } = CatalogValidator.deleteAutocompleteKeyword().validate(
       {
         id,
       },
@@ -200,28 +473,62 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.deleteAutocompleteKeyword().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteAutocompleteKeyword",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
+      "delete",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/autocomplete/${id}/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.DeleteResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteAutocompleteKeyword",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.id - A `id` is a unique identifier for a particular
-   *   detail. Pass the `id` of the keywords which you want to delete.
-   * @summary: Delete a Autocomplete Keywords
-   * @description: Delete a keywords by it's id. Returns an object that tells whether the keywords was deleted successfully
+   * @param {CreateAutocompleteKeyword} arg.body
+   * @returns {Promise<CreateAutocompleteWordsResponse>} - Success response
+   * @summary: Add a Custom Autocomplete Keywords
+   * @description: Create a Custom Autocomplete Keywords. See `CreateAutocompleteKeywordSchema` for the list of attributes needed to create a mapping and /collections/query-options for the available options to create a rule. On successful request, returns a paginated list of collections specified in `CreateAutocompleteKeywordSchema`
    */
-  deleteAutocompleteKeyword({ id } = {}) {
-    const { error } = CatalogValidator.deleteAutocompleteKeyword().validate(
+  async createCustomAutocompleteRule({ body } = {}) {
+    const { error } = CatalogValidator.createCustomAutocompleteRule().validate(
       {
-        id,
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -229,23 +536,60 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.createCustomAutocompleteRule().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for createCustomAutocompleteRule",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "delete",
-      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/autocomplete/${id}/`,
+      "post",
+      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/autocomplete/`,
       query_params,
-      undefined
+      body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.CreateAutocompleteWordsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for createCustomAutocompleteRule",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<GetAutocompleteWordsResponse>} - Success response
    * @summary: List all Autocomplete Keyword Listing
    * @description: Custom Autocomplete Keyword allows you to map conditions with keywords to give you the ultimate results
    */
-  getAutocompleteConfig({} = {}) {
+  async getAutocompleteConfig({} = {}) {
     const { error } = CatalogValidator.getAutocompleteConfig().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -254,27 +598,60 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getAutocompleteConfig().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAutocompleteConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/autocomplete/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetAutocompleteWordsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAutocompleteConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {CreateAutocompleteKeyword} arg.body
-   * @summary: Add a Custom Autocomplete Keywords
-   * @description: Create a Custom Autocomplete Keywords. See `CreateAutocompleteKeywordSchema` for the list of attributes needed to create a mapping and /collections/query-options for the available options to create a rule. On successful request, returns a paginated list of collections specified in `CreateAutocompleteKeywordSchema`
+   * @param {string} arg.itemId - Product id for a particular product.
+   * @returns {Promise<OwnerAppItemResponse>} - Success response
+   * @summary: Get company application product data.
+   * @description: Products are the core resource of an application. If successful, returns a Company Application Product resource in the response body depending upon filter sent.
    */
-  createCustomAutocompleteRule({ body } = {}) {
-    const { error } = CatalogValidator.createCustomAutocompleteRule().validate(
+  async getAppProduct({ itemId } = {}) {
+    const { error } = CatalogValidator.getAppProduct().validate(
       {
-        body,
+        itemId,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -282,25 +659,58 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getAppProduct().validate(
+      {
+        itemId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppProduct",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "post",
-      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/search/autocomplete/`,
+      "get",
+      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product/${itemId}/`,
       query_params,
-      body
+      undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.OwnerAppItemResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppProduct",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.itemId - Product id for which the custom_meta is associated.
    * @param {ApplicationItemMeta} arg.body
+   * @returns {Promise<SuccessResponse1>} - Success response
    * @summary: Update a single custom meta.
    * @description: This API helps to update data associated to a item custom meta.
    */
-  updateAppProduct({ itemId, body } = {}) {
+  async updateAppProduct({ itemId, body } = {}) {
     const { error } = CatalogValidator.updateAppProduct().validate(
       {
         itemId,
@@ -312,27 +722,65 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.updateAppProduct().validate(
+      {
+        itemId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppProduct",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "patch",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product/${itemId}/`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.SuccessResponse1().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppProduct",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.itemId - Product id for a particular product.
-   * @summary: Get company application product data.
-   * @description: Products are the core resource of an application. If successful, returns a Company Application Product resource in the response body depending upon filter sent.
+   * @param {string} arg.configType - A `config_type` is an identifier that
+   *   defines a specific type of configuration.
+   * @param {string} [arg.templateSlug] - Get configuration list filtered by
+   *   `template_slug` string. This is for the details and comparision groups.
+   * @returns {Promise<GetConfigMetadataResponse>} - Success response
+   * @summary: Get configuration metadata details for catalog for admin panel
+   * @description: Get the configuraion metadata details for catalog.
    */
-  getAppProduct({ itemId } = {}) {
-    const { error } = CatalogValidator.getAppProduct().validate(
+  async getConfigurationMetadata({ configType, templateSlug } = {}) {
+    const { error } = CatalogValidator.getConfigurationMetadata().validate(
       {
-        itemId,
+        configType,
+        templateSlug,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -340,31 +788,67 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getConfigurationMetadata().validate(
+      {
+        configType,
+        templateSlug,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getConfigurationMetadata",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
+    query_params["template_slug"] = templateSlug;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
-      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product/${itemId}/`,
+      `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/metadata/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetConfigMetadataResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getConfigurationMetadata",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.configType - A `config_type` is an identifier that
-   *   defines a specific type of configuration.
-   * @param {string} [arg.templateSlug] - Get configuration list filtered by
-   *   `template_slug` string. This is for the details and comparision groups.
-   * @summary: Get configuration metadata details for catalog for admin panel
-   * @description: Get the configuraion metadata details for catalog.
+   * @param {string} arg.configType - A `config_type` is a unique identifier
+   *   for a particular group configuration type.
+   * @param {AppConfigurationDetail} arg.body
+   * @returns {Promise<AppConfigurationDetail>} - Success response
+   * @summary: Create configuration for Group config types.
+   * @description: Create configuration for Group config types.
    */
-  getConfigurationMetadata({ configType, templateSlug } = {}) {
-    const { error } = CatalogValidator.getConfigurationMetadata().validate(
+  async createGroupConfiguration({ configType, body } = {}) {
+    const { error } = CatalogValidator.createGroupConfiguration().validate(
       {
         configType,
-        templateSlug,
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -372,16 +856,50 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.createGroupConfiguration().validate(
+      {
+        configType,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createGroupConfiguration",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
-    query_params["template_slug"] = templateSlug;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
-      `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/metadata/`,
+      "post",
+      `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/groups`,
       query_params,
-      undefined
+      body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.AppConfigurationDetail().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createGroupConfiguration",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -395,10 +913,11 @@ class Catalog {
    * @param {string} [arg.search] - Get configuration list filtered by `search` string.
    * @param {string} [arg.templateSlug] - Get configuration list filtered by
    *   `template_slug` string. This is for the details and comparision groups.
+   * @returns {Promise<GetConfigResponse>} - Success response
    * @summary: Get the details of the application configured configurations of group config types.
    * @description: Get the details of the application configured configurations of group config types.
    */
-  getGroupConfigurations({
+  async getGroupConfigurations({
     configType,
     pageNo,
     pageSize,
@@ -419,50 +938,57 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
-    const query_params = {};
-    query_params["page_no"] = pageNo;
-    query_params["page_size"] = pageSize;
-    query_params["search"] = search;
-    query_params["template_slug"] = templateSlug;
-
-    return PlatformAPIClient.execute(
-      this.config,
-      "get",
-      `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/groups`,
-      query_params,
-      undefined
-    );
-  }
-
-  /**
-   * @param {Object} arg - Arg object.
-   * @param {string} arg.configType - A `config_type` is a unique identifier
-   *   for a particular group configuration type.
-   * @param {AppConfigurationDetail} arg.body
-   * @summary: Create configuration for Group config types.
-   * @description: Create configuration for Group config types.
-   */
-  createGroupConfiguration({ configType, body } = {}) {
-    const { error } = CatalogValidator.createGroupConfiguration().validate(
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getGroupConfigurations().validate(
       {
         configType,
-        body,
+        pageNo,
+        pageSize,
+        search,
+        templateSlug,
       },
-      { abortEarly: false, allowUnknown: true }
+      { abortEarly: false, allowUnknown: false }
     );
-    if (error) {
-      return Promise.reject(new FDKClientValidationError(error));
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getGroupConfigurations",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["page_no"] = pageNo;
+    query_params["page_size"] = pageSize;
+    query_params["search"] = search;
+    query_params["template_slug"] = templateSlug;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "post",
+      "get",
       `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/groups`,
       query_params,
-      body
+      undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetConfigResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getGroupConfigurations",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -472,10 +998,11 @@ class Catalog {
    * @param {string} arg.groupSlug - A `group_slug` is a unique identifier of
    *   a particular configuration.
    * @param {AppConfigurationDetail} arg.body
+   * @returns {Promise<AppConfigurationDetail>} - Success response
    * @summary: Update the group configurations for the application.
    * @description: Update the group configurations for the application.
    */
-  updateGroupConfiguration({ configType, groupSlug, body } = {}) {
+  async updateGroupConfiguration({ configType, groupSlug, body } = {}) {
     const { error } = CatalogValidator.updateGroupConfiguration().validate(
       {
         configType,
@@ -488,15 +1015,51 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.updateGroupConfiguration().validate(
+      {
+        configType,
+        groupSlug,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateGroupConfiguration",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/groups/${groupSlug}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.AppConfigurationDetail().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateGroupConfiguration",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -505,10 +1068,11 @@ class Catalog {
    *   for a particular group configuration type.
    * @param {string} arg.groupSlug - A `group_slug` is a unique identifier of
    *   a particular configuration.
+   * @returns {Promise<ConfigSuccessResponse>} - Success response
    * @summary: Delete configuration of the product config type of the application.
    * @description: Delete configuration of the product config type of the application.
    */
-  deleteGroupConfiguration({ configType, groupSlug } = {}) {
+  async deleteGroupConfiguration({ configType, groupSlug } = {}) {
     const { error } = CatalogValidator.deleteGroupConfiguration().validate(
       {
         configType,
@@ -520,15 +1084,118 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.deleteGroupConfiguration().validate(
+      {
+        configType,
+        groupSlug,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteGroupConfiguration",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/groups/${groupSlug}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.ConfigSuccessResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteGroupConfiguration",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {string} arg.configType - A `config_type` is a unique identifier
+   *   for a particular listing configuration type.
+   * @param {AppConfigurationsSort} arg.body
+   * @returns {Promise<AppConfigurationsSort>} - Success response
+   * @summary: Add configuration for listings
+   * @description: Add configuration for listing.
+   */
+  async createListingConfiguration({ configType, body } = {}) {
+    const { error } = CatalogValidator.createListingConfiguration().validate(
+      {
+        configType,
+        body,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.createListingConfiguration().validate(
+      {
+        configType,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for createListingConfiguration",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "post",
+      `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/`,
+      query_params,
+      body
+    );
+
+    const {
+      error: res_error,
+    } = CatalogModel.AppConfigurationsSort().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createListingConfiguration",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -540,10 +1207,16 @@ class Catalog {
    * @param {number} [arg.pageSize] - Number of items to retrieve in each
    *   page. Default is 12.
    * @param {string} [arg.search] - Get configuration list filtered by `search` string.
+   * @returns {Promise<GetConfigResponse>} - Success response
    * @summary: Get the details of the application configured configurations of listing config types.
    * @description: Get the details of the application configured configurations of listing config types.
    */
-  getListingConfigurations({ configType, pageNo, pageSize, search } = {}) {
+  async getListingConfigurations({
+    configType,
+    pageNo,
+    pageSize,
+    search,
+  } = {}) {
     const { error } = CatalogValidator.getListingConfigurations().validate(
       {
         configType,
@@ -557,49 +1230,55 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getListingConfigurations().validate(
+      {
+        configType,
+        pageNo,
+        pageSize,
+        search,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getListingConfigurations",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["search"] = search;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/`,
       query_params,
       undefined
     );
-  }
 
-  /**
-   * @param {Object} arg - Arg object.
-   * @param {string} arg.configType - A `config_type` is a unique identifier
-   *   for a particular listing configuration type.
-   * @param {AppConfigurationsSort} arg.body
-   * @summary: Add configuration for listings
-   * @description: Add configuration for listing.
-   */
-  createListingConfiguration({ configType, body } = {}) {
-    const { error } = CatalogValidator.createListingConfiguration().validate(
-      {
-        configType,
-        body,
-      },
-      { abortEarly: false, allowUnknown: true }
-    );
-    if (error) {
-      return Promise.reject(new FDKClientValidationError(error));
+    const {
+      error: res_error,
+    } = CatalogModel.GetConfigResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getListingConfigurations",
+      });
+      Logger({ level: "WARN", message: res_error });
     }
 
-    const query_params = {};
-
-    return PlatformAPIClient.execute(
-      this.config,
-      "post",
-      `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/`,
-      query_params,
-      body
-    );
+    return response;
   }
 
   /**
@@ -609,10 +1288,11 @@ class Catalog {
    * @param {string} arg.configId - A `config_id` is a unique identifier of a
    *   particular configuration.
    * @param {AppConfigurationsSort} arg.body
+   * @returns {Promise<AppConfigurationsSort>} - Success response
    * @summary: Update configuration for listings
    * @description: Update configuration for listing.
    */
-  updateListingConfiguration({ configType, configId, body } = {}) {
+  async updateListingConfiguration({ configType, configId, body } = {}) {
     const { error } = CatalogValidator.updateListingConfiguration().validate(
       {
         configType,
@@ -625,15 +1305,52 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.updateListingConfiguration().validate(
+      {
+        configType,
+        configId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for updateListingConfiguration",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/item/${configId}/`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.AppConfigurationsSort().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateListingConfiguration",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -642,10 +1359,11 @@ class Catalog {
    *   for a particular listing configuration type.
    * @param {string} arg.configId - A `config_id` is a unique identifier of a
    *   particular configuration.
+   * @returns {Promise<ConfigSuccessResponse>} - Success response
    * @summary: Delete configuration for listings
    * @description: Delete configuration for listing.
    */
-  deleteListingConfiguration({ configType, configId } = {}) {
+  async deleteListingConfiguration({ configType, configId } = {}) {
     const { error } = CatalogValidator.deleteListingConfiguration().validate(
       {
         configType,
@@ -657,24 +1375,61 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.deleteListingConfiguration().validate(
+      {
+        configType,
+        configId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for deleteListingConfiguration",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${configType}/item/${configId}/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.ConfigSuccessResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteListingConfiguration",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {AllowSingleRequest} arg.body
+   * @returns {Promise<ConfigSuccessResponse>} - Success response
    * @summary: Update allow single flag for filters of the application.
    * @description: Update allow single flag for filters of the application.
    */
-  updateAllowSingle({ body } = {}) {
+  async updateAllowSingle({ body } = {}) {
     const { error } = CatalogValidator.updateAllowSingle().validate(
       {
         body,
@@ -685,24 +1440,57 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.updateAllowSingle().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAllowSingle",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/filter/allow_single`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.ConfigSuccessResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAllowSingle",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {DefaultKeyRequest} arg.body
+   * @returns {Promise<ConfigSuccessResponse>} - Success response
    * @summary: Update the default sort key configuration for the application.
    * @description: Update the default sort key configuration for the application.
    */
-  updateDefaultSort({ body } = {}) {
+  async updateDefaultSort({ body } = {}) {
     const { error } = CatalogValidator.updateDefaultSort().validate(
       {
         body,
@@ -713,23 +1501,56 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.updateDefaultSort().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateDefaultSort",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/catalog/v2.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/sort/default_key`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.ConfigSuccessResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateDefaultSort",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<GetCatalogConfigurationMetaData>} - Success response
    * @summary: Get configuration meta  details for catalog for admin panel
    * @description: configuration meta  details for catalog.
    */
-  getCatalogConfiguration({} = {}) {
+  async getCatalogConfiguration({} = {}) {
     const { error } = CatalogValidator.getCatalogConfiguration().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -738,23 +1559,123 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getCatalogConfiguration().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getCatalogConfiguration",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/metadata/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetCatalogConfigurationMetaData().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getCatalogConfiguration",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {AppConfiguration} arg.body
+   * @returns {Promise<GetAppCatalogConfiguration>} - Success response
+   * @summary: Add configuration for products & listings
+   * @description: Add configuration for products & listing.
+   */
+  async createConfigurationProductListing({ body } = {}) {
+    const {
+      error,
+    } = CatalogValidator.createConfigurationProductListing().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.createConfigurationProductListing().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for createConfigurationProductListing",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "post",
+      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/`,
+      query_params,
+      body
+    );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetAppCatalogConfiguration().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for createConfigurationProductListing",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<GetAppCatalogConfiguration>} - Success response
    * @summary: Get configured details for catalog
    * @description: configured details for catalog.
    */
-  getConfigurations({} = {}) {
+  async getConfigurations({} = {}) {
     const { error } = CatalogValidator.getConfigurations().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -763,54 +1684,121 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getConfigurations().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getConfigurations",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetAppCatalogConfiguration().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getConfigurations",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @param {string} arg.type - Type can be brands, categories etc.
    * @param {AppConfiguration} arg.body
-   * @summary: Add configuration for products & listings
-   * @description: Add configuration for products & listing.
+   * @returns {Promise<GetAppCatalogConfiguration>} - Success response
+   * @summary: Add configuration for categories and brands
+   * @description: Add configuration for categories & brands.
    */
-  createConfigurationProductListing({ body } = {}) {
-    const {
-      error,
-    } = CatalogValidator.createConfigurationProductListing().validate(
+  async createConfigurationByType({ type, body } = {}) {
+    const { error } = CatalogValidator.createConfigurationByType().validate(
+      {
+        type,
+        body,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.createConfigurationByType().validate(
       {
+        type,
         body,
       },
-      { abortEarly: false, allowUnknown: true }
+      { abortEarly: false, allowUnknown: false }
     );
-    if (error) {
-      return Promise.reject(new FDKClientValidationError(error));
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createConfigurationByType",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
-      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/`,
+      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${type}/`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetAppCatalogConfiguration().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createConfigurationByType",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.type - Type can be brands, categories etc.
+   * @returns {Promise<GetAppCatalogEntityConfiguration>} - Success response
    * @summary: Get configured details for catalog
    * @description: configured details for catalog.
    */
-  getConfigurationByType({ type } = {}) {
+  async getConfigurationByType({ type } = {}) {
     const { error } = CatalogValidator.getConfigurationByType().validate(
       {
         type,
@@ -821,70 +1809,166 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getConfigurationByType().validate(
+      {
+        type,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getConfigurationByType",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${type}/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetAppCatalogEntityConfiguration().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getConfigurationByType",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.type - Type can be brands, categories etc.
-   * @param {AppConfiguration} arg.body
-   * @summary: Add configuration for categories and brands
-   * @description: Add configuration for categories & brands.
+   * @returns {Promise<GetCollectionQueryOptionResponse>} - Success response
+   * @summary: Get query filters to configure a collection
+   * @description: Get query filters to configure a collection
    */
-  createConfigurationByType({ type, body } = {}) {
-    const { error } = CatalogValidator.createConfigurationByType().validate(
-      {
-        type,
-        body,
-      },
+  async getQueryFilters({} = {}) {
+    const { error } = CatalogValidator.getQueryFilters().validate(
+      {},
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getQueryFilters().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getQueryFilters",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "post",
-      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/product-configuration/${type}/`,
+      "get",
+      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/query-options/`,
       query_params,
-      body
+      undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetCollectionQueryOptionResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getQueryFilters",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @summary: Get query filters to configure a collection
-   * @description: Get query filters to configure a collection
+   * @param {CreateCollection} arg.body
+   * @returns {Promise<CollectionCreateResponse>} - Success response
+   * @summary: Add a Collection
+   * @description: Create a collection. See `CreateCollectionRequestSchema` for the list of attributes needed to create a collection and collections/query-options for the available options to create a collection. On successful request, returns a paginated list of collections specified in `CollectionCreateResponse`
    */
-  getQueryFilters({} = {}) {
-    const { error } = CatalogValidator.getQueryFilters().validate(
-      {},
+  async createCollection({ body } = {}) {
+    const { error } = CatalogValidator.createCollection().validate(
+      {
+        body,
+      },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.createCollection().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createCollection",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
-      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/query-options/`,
+      "post",
+      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/`,
       query_params,
-      undefined
+      body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.CollectionCreateResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createCollection",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -900,10 +1984,11 @@ class Catalog {
    *   given set of results.
    * @param {number} [arg.pageSize] - Number of items to retrieve in each
    *   page. Default is 12.
+   * @returns {Promise<GetCollectionListingResponse>} - Success response
    * @summary: List all the collections
    * @description: A Collection allows you to organize your products into hierarchical groups. For example, a dress might be in the category _Clothing_, the individual product might also be in the collection _Summer_. On successful request, returns all the collections as specified in `CollectionListingSchema`
    */
-  getAllCollections({
+  async getAllCollections({
     q,
     scheduleStatus,
     type,
@@ -928,6 +2013,27 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getAllCollections().validate(
+      {
+        q,
+        scheduleStatus,
+        type,
+        tags,
+        isActive,
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAllCollections",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["q"] = q;
     query_params["schedule_status"] = scheduleStatus;
@@ -937,41 +2043,30 @@ class Catalog {
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/`,
       query_params,
       undefined
     );
-  }
 
-  /**
-   * @param {Object} arg - Arg object.
-   * @param {CreateCollection} arg.body
-   * @summary: Add a Collection
-   * @description: Create a collection. See `CreateCollectionRequestSchema` for the list of attributes needed to create a collection and collections/query-options for the available options to create a collection. On successful request, returns a paginated list of collections specified in `CollectionCreateResponse`
-   */
-  createCollection({ body } = {}) {
-    const { error } = CatalogValidator.createCollection().validate(
-      {
-        body,
-      },
-      { abortEarly: false, allowUnknown: true }
-    );
-    if (error) {
-      return Promise.reject(new FDKClientValidationError(error));
+    const {
+      error: res_error,
+    } = CatalogModel.GetCollectionListingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAllCollections",
+      });
+      Logger({ level: "WARN", message: res_error });
     }
 
-    const query_params = {};
-
-    return PlatformAPIClient.execute(
-      this.config,
-      "post",
-      `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/`,
-      query_params,
-      body
-    );
+    return response;
   }
 
   /**
@@ -979,10 +2074,11 @@ class Catalog {
    * @param {string} arg.slug - A `slug` is a human readable, URL friendly
    *   unique identifier of an object. Pass the `slug` of the collection which
    *   you want to retrieve.
+   * @returns {Promise<CollectionDetailResponse>} - Success response
    * @summary: Get a particular collection
    * @description: Get the details of a collection by its `slug`. If successful, returns a Collection resource in the response body specified in `CollectionDetailResponse`
    */
-  getCollectionDetail({ slug } = {}) {
+  async getCollectionDetail({ slug } = {}) {
     const { error } = CatalogValidator.getCollectionDetail().validate(
       {
         slug,
@@ -993,25 +2089,58 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getCollectionDetail().validate(
+      {
+        slug,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getCollectionDetail",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/${slug}/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.CollectionDetailResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getCollectionDetail",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - A `id` is a unique identifier of a collection.
    * @param {UpdateCollection} arg.body
+   * @returns {Promise<UpdateCollection>} - Success response
    * @summary: Update a collection
    * @description: Update a collection by it's id. On successful request, returns the updated collection
    */
-  updateCollection({ id, body } = {}) {
+  async updateCollection({ id, body } = {}) {
     const { error } = CatalogValidator.updateCollection().validate(
       {
         id,
@@ -1023,24 +2152,58 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.updateCollection().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateCollection",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/${id}/`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.UpdateCollection().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateCollection",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - A `id` is a unique identifier of a collection.
+   * @returns {Promise<DeleteResponse>} - Success response
    * @summary: Delete a Collection
    * @description: Delete a collection by it's id. Returns an object that tells whether the collection was deleted successfully
    */
-  deleteCollection({ id } = {}) {
+  async deleteCollection({ id } = {}) {
     const { error } = CatalogValidator.deleteCollection().validate(
       {
         id,
@@ -1051,36 +2214,62 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.deleteCollection().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteCollection",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/${id}/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.DeleteResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteCollection",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - A `id` is a unique identifier of a collection.
-   * @param {string} [arg.sortOn] - Each response will contain sort_on param,
-   *   which should be sent back to make pagination work.
-   * @param {string} [arg.pageId] - Each response will contain next_id param,
-   *   which should be sent back to make pagination work.
-   * @param {number} [arg.pageSize] - Number of items to retrieve in each
-   *   page. Default is 12.
-   * @summary: Get the items for a collection
-   * @description: Get items from a collection specified by its `id`.
+   * @param {CollectionItemUpdate} arg.body
+   * @returns {Promise<UpdatedResponse>} - Success response
+   * @summary: Add items to a collection
+   * @description: Adds items to a collection specified by its `id`. See `CollectionItemRequest` for the list of attributes needed to add items to an collection.
    */
-  getCollectionItems({ id, sortOn, pageId, pageSize } = {}) {
-    const { error } = CatalogValidator.getCollectionItems().validate(
+  async addCollectionItems({ id, body } = {}) {
+    const { error } = CatalogValidator.addCollectionItems().validate(
       {
         id,
-        sortOn,
-        pageId,
-        pageSize,
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1088,32 +2277,70 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.addCollectionItems().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for addCollectionItems",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
-    query_params["sort_on"] = sortOn;
-    query_params["page_id"] = pageId;
-    query_params["page_size"] = pageSize;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
+      "post",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/${id}/items/`,
       query_params,
-      undefined
+      body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.UpdatedResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for addCollectionItems",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - A `id` is a unique identifier of a collection.
-   * @param {CollectionItemRequest} arg.body
-   * @summary: Add items to a collection
-   * @description: Adds items to a collection specified by its `id`. See `CollectionItemRequest` for the list of attributes needed to add items to an collection.
+   * @param {string} [arg.sortOn] - Each response will contain sort_on param,
+   *   which should be sent back to make pagination work.
+   * @param {string} [arg.pageId] - Each response will contain next_id param,
+   *   which should be sent back to make pagination work.
+   * @param {number} [arg.pageSize] - Number of items to retrieve in each
+   *   page. Default is 12.
+   * @returns {Promise<GetCollectionItemsResponse>} - Success response
+   * @summary: Get the items for a collection
+   * @description: Get items from a collection specified by its `id`.
    */
-  addCollectionItems({ id, body } = {}) {
-    const { error } = CatalogValidator.addCollectionItems().validate(
+  async getCollectionItems({ id, sortOn, pageId, pageSize } = {}) {
+    const { error } = CatalogValidator.getCollectionItems().validate(
       {
         id,
-        body,
+        sortOn,
+        pageId,
+        pageSize,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1121,24 +2348,63 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getCollectionItems().validate(
+      {
+        id,
+        sortOn,
+        pageId,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getCollectionItems",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
+    query_params["sort_on"] = sortOn;
+    query_params["page_id"] = pageId;
+    query_params["page_size"] = pageSize;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "post",
+      "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/collections/${id}/items/`,
       query_params,
-      body
+      undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.GetCollectionItemsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getCollectionItems",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} [arg.brand] - Brand slug
+   * @returns {Promise<CatalogInsightResponse>} - Success response
    * @summary: Analytics data of catalog and inventory.
    * @description: Catalog Insights api returns the count of catalog related data like products, brands, departments and categories that have been made live as per configuration of the app.
    */
-  getCatalogInsights({ brand } = {}) {
+  async getCatalogInsights({ brand } = {}) {
     const { error } = CatalogValidator.getCatalogInsights().validate(
       {
         brand,
@@ -1149,16 +2415,48 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getCatalogInsights().validate(
+      {
+        brand,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getCatalogInsights",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["brand"] = brand;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/analytics/insights/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.CatalogInsightResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getCatalogInsights",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1172,10 +2470,11 @@ class Catalog {
    *   page. Default is 12.
    * @param {string} [arg.q] - Search with help of store code.
    * @param {number[]} [arg.locationIds] - Search by store ids.
+   * @returns {Promise<InventorySellerIdentifierResponsePaginated>} - Success response
    * @summary: Get Inventory for company
    * @description: This API allows get Inventory data for particular company grouped by size and store.
    */
-  getDiscountedInventoryBySizeIdentifier({
+  async getDiscountedInventoryBySizeIdentifier({
     itemId,
     sizeIdentifier,
     pageNo,
@@ -1184,7 +2483,25 @@ class Catalog {
     locationIds,
   } = {}) {
     const {
-      error,
+      error,
+    } = CatalogValidator.getDiscountedInventoryBySizeIdentifier().validate(
+      {
+        itemId,
+        sizeIdentifier,
+        pageNo,
+        pageSize,
+        q,
+        locationIds,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
     } = CatalogValidator.getDiscountedInventoryBySizeIdentifier().validate(
       {
         itemId,
@@ -1194,10 +2511,15 @@ class Catalog {
         q,
         locationIds,
       },
-      { abortEarly: false, allowUnknown: true }
+      { abortEarly: false, allowUnknown: false }
     );
-    if (error) {
-      return Promise.reject(new FDKClientValidationError(error));
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getDiscountedInventoryBySizeIdentifier",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
@@ -1206,13 +2528,31 @@ class Catalog {
     query_params["q"] = q;
     query_params["location_ids"] = locationIds;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/products/${itemId}/inventory/${sizeIdentifier}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.InventorySellerIdentifierResponsePaginated().validate(
+      response,
+      { abortEarly: false, allowUnknown: false }
+    );
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getDiscountedInventoryBySizeIdentifier",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1229,10 +2569,17 @@ class Catalog {
    *   to search brands by brand name.
    * @param {number[]} [arg.brandId] - Helps to sort the brands list on the
    *   basis of uid list.
+   * @returns {Promise<BrandListingResponse>} - Success response
    * @summary: List all the brands
    * @description: A brand is the name under which a product is being sold. Use this API to list all the brands. You can pass optionally filter the brands by the department. If successful, returns a paginated list of brands specified in `BrandListingResponse`
    */
-  getApplicationBrands({ department, pageNo, pageSize, q, brandId } = {}) {
+  async getApplicationBrands({
+    department,
+    pageNo,
+    pageSize,
+    q,
+    brandId,
+  } = {}) {
     const { error } = CatalogValidator.getApplicationBrands().validate(
       {
         department,
@@ -1247,6 +2594,27 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getApplicationBrands().validate(
+      {
+        department,
+        pageNo,
+        pageSize,
+        q,
+        brandId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getApplicationBrands",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["department"] = department;
     query_params["page_no"] = pageNo;
@@ -1254,13 +2622,30 @@ class Catalog {
     query_params["q"] = q;
     query_params["brand_id"] = brandId;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/brands`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.BrandListingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getApplicationBrands",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1316,10 +2701,11 @@ class Catalog {
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<DepartmentResponse>} - Success response
    * @summary: List all the departments
    * @description: Departments are a way to categorise similar products. A product can lie in multiple departments. For example, a skirt can below to the 'Women's Fashion' Department while a handbag can lie in 'Women's Accessories' Department. Use this API to list all the departments. If successful, returns the list of departments specified in `DepartmentResponse`
    */
-  getDepartments({} = {}) {
+  async getDepartments({} = {}) {
     const { error } = CatalogValidator.getDepartments().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -1328,15 +2714,45 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getDepartments().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getDepartments",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/departments`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.DepartmentResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getDepartments",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1345,10 +2761,11 @@ class Catalog {
    *   parameter to filter products by a particular department. See below the
    *   list of available departments. You can retrieve available departments
    *   from the **v1.0/departments/** API
+   * @returns {Promise<CategoryListingResponse>} - Success response
    * @summary: List all the categories
    * @description: List all the categories. You can optionally pass filter the brands by the department. If successful, returns a paginated list of brands specified in `CategoryListingResponse`
    */
-  getCategories({ department } = {}) {
+  async getCategories({ department } = {}) {
     const { error } = CatalogValidator.getCategories().validate(
       {
         department,
@@ -1359,16 +2776,48 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getCategories().validate(
+      {
+        department,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getCategories",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["department"] = department;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/categories`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.CategoryListingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getCategories",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1397,10 +2846,11 @@ class Catalog {
    * @param {string} [arg.pageType] - For pagination type should be cursor or
    *   number. Default is cursor.
    * @param {number[]} [arg.itemIds] - Item Ids of product
+   * @returns {Promise<ApplicationProductListingResponse>} - Success response
    * @summary: List the products
    * @description: List all the products associated with a brand, collection or category in a requested sort order. The API additionally supports arbitrary search queries that may refer the name of any product, brand, category or collection. If successful, returns a paginated list of products specified in `ApplicationProductListingResponse`
    */
-  getAppicationProducts({
+  async getAppicationProducts({
     q,
     f,
     c,
@@ -1431,6 +2881,32 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getAppicationProducts().validate(
+      {
+        q,
+        f,
+        c,
+        filters,
+        sortOn,
+        pageId,
+        pageSize,
+        pageNo,
+        pageType,
+        itemIds,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppicationProducts",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["q"] = q;
     query_params["f"] = f;
@@ -1443,13 +2919,30 @@ class Catalog {
     query_params["page_type"] = pageType;
     query_params["item_ids"] = itemIds;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/products`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.ApplicationProductListingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppicationProducts",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1524,10 +3017,11 @@ class Catalog {
    * @param {string} arg.slug - The unique identifier of a product. i.e;
    *   `slug` of a product. You can retrieve these from the APIs that list
    *   products like **v1.0/products/**
+   * @returns {Promise<ProductDetail>} - Success response
    * @summary: Get a product
    * @description: Products are the core resource of an application. Products can be associated by categories, collections, brands and more. This API retrieves the product specified by the given **slug**. If successful, returns a Product resource in the response body specified in `ProductDetail`
    */
-  getProductDetailBySlug({ slug } = {}) {
+  async getProductDetailBySlug({ slug } = {}) {
     const { error } = CatalogValidator.getProductDetailBySlug().validate(
       {
         slug,
@@ -1538,15 +3032,47 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getProductDetailBySlug().validate(
+      {
+        slug,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getProductDetailBySlug",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/products/${slug}`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = CatalogModel.ProductDetail().validate(
+      response,
+      { abortEarly: false, allowUnknown: false }
+    );
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getProductDetailBySlug",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1562,10 +3088,11 @@ class Catalog {
    * @param {number} [arg.pageSize] - Number of items to retrieve in each
    *   page. Default is 10.
    * @param {string} [arg.q] - Search with Item Code, Name, Slug or Identifier.
+   * @returns {Promise<ProductListingResponse>} - Success response
    * @summary: Get applicationwise products
    * @description: Products are the core resource of an application. Products can be associated by categories, collections, brands and more. If successful, returns a Product resource in the response body specified in `ApplicationProductListingResponseDatabasePowered`
    */
-  getAppProducts({
+  async getAppProducts({
     brandIds,
     categoryIds,
     departmentIds,
@@ -1590,6 +3117,27 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getAppProducts().validate(
+      {
+        brandIds,
+        categoryIds,
+        departmentIds,
+        tags,
+        pageNo,
+        pageSize,
+        q,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppProducts",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["brand_ids"] = brandIds;
     query_params["category_ids"] = categoryIds;
@@ -1599,13 +3147,30 @@ class Catalog {
     query_params["page_size"] = pageSize;
     query_params["q"] = q;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/raw-products/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.ProductListingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppProducts",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1618,10 +3183,11 @@ class Catalog {
    * @param {string} [arg.timestamp] - Timestamp in UTC format (2020-07-23T10:27:50Z)
    * @param {number} [arg.pageSize] - The number of items to retrieve in each page.
    * @param {string} [arg.pageId] - Page ID to retrieve next set of results.
+   * @returns {Promise<InventoryStockResponse>} - Success response
    * @summary: Get the stock of a product
    * @description: Retrieve the available Inventory of the products. Use this API to get the Inventory status of products with the filters of timestamp, store_ids, brand_ids, item_id - Items - Pagination
    */
-  getAppInventory({
+  async getAppInventory({
     itemIds,
     storeIds,
     brandIds,
@@ -1646,6 +3212,27 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getAppInventory().validate(
+      {
+        itemIds,
+        storeIds,
+        brandIds,
+        sellerIdentifiers,
+        timestamp,
+        pageSize,
+        pageId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppInventory",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["item_ids"] = itemIds;
     query_params["store_ids"] = storeIds;
@@ -1655,13 +3242,30 @@ class Catalog {
     query_params["page_size"] = pageSize;
     query_params["page_id"] = pageId;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/inventory/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.InventoryStockResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppInventory",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1677,10 +3281,11 @@ class Catalog {
    *   given set of results
    * @param {number} [arg.pageSize] - Number of items to retrieve in each
    *   page. Default is 20.
+   * @returns {Promise<LocationListSerializer>} - Success response
    * @summary: Get list of locations
    * @description: This API allows to view all the locations asscoiated to a application.
    */
-  getAppLocations({ storeType, uid, q, stage, pageNo, pageSize } = {}) {
+  async getAppLocations({ storeType, uid, q, stage, pageNo, pageSize } = {}) {
     const { error } = CatalogValidator.getAppLocations().validate(
       {
         storeType,
@@ -1696,6 +3301,26 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.getAppLocations().validate(
+      {
+        storeType,
+        uid,
+        q,
+        stage,
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppLocations",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["store_type"] = storeType;
     query_params["uid"] = uid;
@@ -1704,13 +3329,30 @@ class Catalog {
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/locations`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.LocationListSerializer().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppLocations",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1772,10 +3414,11 @@ class Catalog {
    *   page. Default is 12.
    * @param {string} [arg.q] - Search query with brand name.Use this parameter
    *   to search brands by brand name.
+   * @returns {Promise<BrandListingResponse>} - Success response
    * @summary: List all the brands for the application
    * @description: A brand is the name under which a product is being sold. Use this API to list all the brands. You can pass optionally filter the brands by the department. If successful, returns a paginated list of brands specified in `BrandListingResponse`
    */
-  getApplicationBrandListing({ pageNo, pageSize, q } = {}) {
+  async getApplicationBrandListing({ pageNo, pageSize, q } = {}) {
     const { error } = CatalogValidator.getApplicationBrandListing().validate(
       {
         pageNo,
@@ -1788,18 +3431,55 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getApplicationBrandListing().validate(
+      {
+        pageNo,
+        pageSize,
+        q,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getApplicationBrandListing",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["q"] = q;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/brand`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.BrandListingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getApplicationBrandListing",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1847,10 +3527,11 @@ class Catalog {
    * @param {Object} arg - Arg object.
    * @param {string} arg.brandUid - Brand id for which the custom_json is associated.
    * @param {ApplicationBrandJson} arg.body
+   * @returns {Promise<SuccessResponse1>} - Success response
    * @summary: Update a single custom json.
    * @description: This API helps to update data associated to a item custom meta.
    */
-  updateAppBrand({ brandUid, body } = {}) {
+  async updateAppBrand({ brandUid, body } = {}) {
     const { error } = CatalogValidator.updateAppBrand().validate(
       {
         brandUid,
@@ -1862,15 +3543,48 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.updateAppBrand().validate(
+      {
+        brandUid,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppBrand",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "patch",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/brand/${brandUid}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.SuccessResponse1().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppBrand",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1883,10 +3597,16 @@ class Catalog {
    *   page. Default is 12.
    * @param {string} [arg.q] - Search query with brand name.Use this parameter
    *   to search brands by brand name.
+   * @returns {Promise<BrandListingResponse>} - Success response
    * @summary: List all the brands for the application
    * @description: A brand is the name under which a product is being sold. Use this API to list all the brands. You can pass optionally filter the brands by the department. If successful, returns a paginated list of brands specified in `BrandListingResponse`
    */
-  getApplicationCategoryListing({ departmentId, pageNo, pageSize, q } = {}) {
+  async getApplicationCategoryListing({
+    departmentId,
+    pageNo,
+    pageSize,
+    q,
+  } = {}) {
     const { error } = CatalogValidator.getApplicationCategoryListing().validate(
       {
         departmentId,
@@ -1900,19 +3620,58 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getApplicationCategoryListing().validate(
+      {
+        departmentId,
+        pageNo,
+        pageSize,
+        q,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getApplicationCategoryListing",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["department_id"] = departmentId;
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["q"] = q;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/category`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.BrandListingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getApplicationCategoryListing",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1965,10 +3724,11 @@ class Catalog {
    * @param {string} arg.categoryUid - Category id for which the custom_json
    *   is associated.
    * @param {ApplicationCategoryJson} arg.body
+   * @returns {Promise<SuccessResponse1>} - Success response
    * @summary: Update a single custom json.
    * @description: This API helps to update data associated to a item custom meta.
    */
-  updateAppCategory({ categoryUid, body } = {}) {
+  async updateAppCategory({ categoryUid, body } = {}) {
     const { error } = CatalogValidator.updateAppCategory().validate(
       {
         categoryUid,
@@ -1980,15 +3740,48 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.updateAppCategory().validate(
+      {
+        categoryUid,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppCategory",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "patch",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/category/${categoryUid}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.SuccessResponse1().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppCategory",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1999,10 +3792,11 @@ class Catalog {
    *   page. Default is 12.
    * @param {string} [arg.q] - Search query with brand name.Use this parameter
    *   to search department by name.
+   * @returns {Promise<ApplicationDepartmentListingResponse>} - Success response
    * @summary: List all the departments for the application
    * @description: Departments are a way to categorise similar products. A product can lie in multiple departments. For example, a skirt can below to the 'Women's Fashion' Department while a handbag can lie in 'Women's Accessories' Department. Use this API to list all the application departments. If successful, returns the list of departments specified in `ApplicationDepartmentListingResponse`
    */
-  getApplicationDepartmentListing({ pageNo, pageSize, q } = {}) {
+  async getApplicationDepartmentListing({ pageNo, pageSize, q } = {}) {
     const {
       error,
     } = CatalogValidator.getApplicationDepartmentListing().validate(
@@ -2017,18 +3811,56 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CatalogValidator.getApplicationDepartmentListing().validate(
+      {
+        pageNo,
+        pageSize,
+        q,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getApplicationDepartmentListing",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["q"] = q;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/department`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.ApplicationDepartmentListingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getApplicationDepartmentListing",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -2077,10 +3909,11 @@ class Catalog {
    * @param {string} arg.departmentUid - Department id for which the
    *   custom_json is associated.
    * @param {ApplicationDepartmentJson} arg.body
+   * @returns {Promise<SuccessResponse1>} - Success response
    * @summary: Update a single custom json.
    * @description: This API helps to update data associated to a item custom meta.
    */
-  updateAppDepartment({ departmentUid, body } = {}) {
+  async updateAppDepartment({ departmentUid, body } = {}) {
     const { error } = CatalogValidator.updateAppDepartment().validate(
       {
         departmentUid,
@@ -2092,25 +3925,59 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.updateAppDepartment().validate(
+      {
+        departmentUid,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppDepartment",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "patch",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/department/${departmentUid}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.SuccessResponse1().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppDepartment",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.storeUid - Store id for which the custom_json is associated.
    * @param {ApplicationStoreJson} arg.body
+   * @returns {Promise<SuccessResponse1>} - Success response
    * @summary: Update a single custom json.
    * @description: This API helps to update data associated to a item custom meta.
    */
-  updateAppLocation({ storeUid, body } = {}) {
+  async updateAppLocation({ storeUid, body } = {}) {
     const { error } = CatalogValidator.updateAppLocation().validate(
       {
         storeUid,
@@ -2122,15 +3989,48 @@ class Catalog {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CatalogValidator.updateAppLocation().validate(
+      {
+        storeUid,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppLocation",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "patch",
       `/service/platform/catalog/v1.0/company/${this.config.companyId}/application/${this.applicationId}/store/${storeUid}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CatalogModel.SuccessResponse1().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppLocation",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 }
 module.exports = Catalog;