@gofynd/fdk-client-javascript 1.0.0 → 1.0.2

package/sdk/platform/Theme/ThemePlatformApplicationClient.js

@@ -2,6 +2,8 @@ const Paginator = require("../../common/Paginator");
 const PlatformAPIClient = require("../PlatformAPIClient");
 const { FDKClientValidationError } = require("../../common/FDKError");
 const ThemeValidator = require("./ThemePlatformApplicationValidator");
+const ThemeModel = require("./ThemePlatformModel");
+const { Logger } = require("./../../common/Logger");
 
 class Theme {
   constructor(config, applicationId) {
@@ -12,10 +14,11 @@ class Theme {
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID of the theme to be retrieved
+   * @returns {Promise<AllAvailablePageSchema>} - Success response
    * @summary: Get all pages of a theme
    * @description: Use this API to retrieve all the available pages of a theme by its ID.
    */
-  getAllPages({ themeId } = {}) {
+  async getAllPages({ themeId } = {}) {
     const { error } = ThemeValidator.getAllPages().validate(
       {
         themeId,
@@ -26,25 +29,58 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.getAllPages().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAllPages",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/page`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ThemeModel.AllAvailablePageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAllPages",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID of the theme
    * @param {AvailablePageSchema} arg.body
+   * @returns {Promise<AvailablePageSchema>} - Success response
    * @summary: Create a page
    * @description: Use this API to create a page for a theme by its ID.
    */
-  createPage({ themeId, body } = {}) {
+  async createPage({ themeId, body } = {}) {
     const { error } = ThemeValidator.createPage().validate(
       {
         themeId,
@@ -56,25 +92,59 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.createPage().validate(
+      {
+        themeId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createPage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/page`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ThemeModel.AvailablePageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createPage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID of the theme to be retrieved
    * @param {AllAvailablePageSchema} arg.body
+   * @returns {Promise<AllAvailablePageSchema>} - Success response
    * @summary: Update multiple pages of a theme
    * @description: Use this API to update multiple pages of a theme by its ID.
    */
-  updateMultiplePages({ themeId, body } = {}) {
+  async updateMultiplePages({ themeId, body } = {}) {
     const { error } = ThemeValidator.updateMultiplePages().validate(
       {
         themeId,
@@ -86,25 +156,59 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.updateMultiplePages().validate(
+      {
+        themeId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateMultiplePages",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/page`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ThemeModel.AllAvailablePageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateMultiplePages",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID of the theme to be retrieved
    * @param {string} arg.pageValue - Value of the page to be retrieved
+   * @returns {Promise<AvailablePageSchema>} - Success response
    * @summary: Get page of a theme
    * @description: Use this API to retrieve a page of a theme.
    */
-  getPage({ themeId, pageValue } = {}) {
+  async getPage({ themeId, pageValue } = {}) {
     const { error } = ThemeValidator.getPage().validate(
       {
         themeId,
@@ -116,15 +220,48 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.getPage().validate(
+      {
+        themeId,
+        pageValue,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/${pageValue}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ThemeModel.AvailablePageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -132,10 +269,11 @@ class Theme {
    * @param {string} arg.themeId - ID of the theme
    * @param {string} arg.pageValue - Value of the page to be updated
    * @param {AvailablePageSchema} arg.body
+   * @returns {Promise<AvailablePageSchema>} - Success response
    * @summary: Updates a page
    * @description: Use this API to update a page for a theme by its ID.
    */
-  updatePage({ themeId, pageValue, body } = {}) {
+  async updatePage({ themeId, pageValue, body } = {}) {
     const { error } = ThemeValidator.updatePage().validate(
       {
         themeId,
@@ -148,25 +286,60 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.updatePage().validate(
+      {
+        themeId,
+        pageValue,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updatePage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/${pageValue}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ThemeModel.AvailablePageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updatePage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID of the theme
    * @param {string} arg.pageValue - Value of the page to be updated
+   * @returns {Promise<AvailablePageSchema>} - Success response
    * @summary: Deletes a page
    * @description: Use this API to delete a page for a theme by its ID and page_value.
    */
-  deletePage({ themeId, pageValue } = {}) {
+  async deletePage({ themeId, pageValue } = {}) {
     const { error } = ThemeValidator.deletePage().validate(
       {
         themeId,
@@ -178,15 +351,48 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.deletePage().validate(
+      {
+        themeId,
+        pageValue,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deletePage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/${pageValue}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ThemeModel.AvailablePageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deletePage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -195,10 +401,11 @@ class Theme {
    *   page. Default value is 10.
    * @param {number} [arg.pageNo] - The page number to navigate through the
    *   given set of results. Default value is 1.
+   * @returns {Promise<ThemesListingResponseSchema>} - Success response
    * @summary: Get a list of themes from the theme library
    * @description: Theme library is a personalized collection of themes that are chosen and added from the available themes. Use this API to fetch a list of themes from the library along with their configuration details.
    */
-  getThemeLibrary({ pageSize, pageNo } = {}) {
+  async getThemeLibrary({ pageSize, pageNo } = {}) {
     const { error } = ThemeValidator.getThemeLibrary().validate(
       {
         pageSize,
@@ -210,26 +417,60 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.getThemeLibrary().validate(
+      {
+        pageSize,
+        pageNo,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getThemeLibrary",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_size"] = pageSize;
     query_params["page_no"] = pageNo;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/library`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ThemeModel.ThemesListingResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getThemeLibrary",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {AddThemeRequestSchema} arg.body
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Add a theme to the theme library
    * @description: Theme library is a personalized collection of themes that are chosen and added from the available themes. Use this API to choose a theme and add it to the theme library.
    */
-  addToThemeLibrary({ body } = {}) {
+  async addToThemeLibrary({ body } = {}) {
     const { error } = ThemeValidator.addToThemeLibrary().validate(
       {
         body,
@@ -240,24 +481,55 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.addToThemeLibrary().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for addToThemeLibrary",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/library`,
       query_params,
       body
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for addToThemeLibrary",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {AddThemeRequestSchema} arg.body
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Apply a theme
    * @description: Use this API to apply a theme to the website.
    */
-  applyTheme({ body } = {}) {
+  async applyTheme({ body } = {}) {
     const { error } = ThemeValidator.applyTheme().validate(
       {
         body,
@@ -268,24 +540,55 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.applyTheme().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for applyTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/apply`,
       query_params,
       body
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for applyTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - Theme ID
+   * @returns {Promise<UpgradableThemeSchema>} - Success response
    * @summary: Checks if theme is upgradable
    * @description: There's always a possibility that new features get added to a theme. Use this API to check if the applied theme has an upgrade available.
    */
-  isUpgradable({ themeId } = {}) {
+  async isUpgradable({ themeId } = {}) {
     const { error } = ThemeValidator.isUpgradable().validate(
       {
         themeId,
@@ -296,24 +599,57 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.isUpgradable().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for isUpgradable",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/upgradable`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ThemeModel.UpgradableThemeSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for isUpgradable",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Upgrade a theme
    * @description: Use this API to upgrade the current theme to its latest version.
    */
-  upgradeTheme({ themeId } = {}) {
+  async upgradeTheme({ themeId } = {}) {
     const { error } = ThemeValidator.upgradeTheme().validate(
       {
         themeId,
@@ -324,15 +660,45 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.upgradeTheme().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for upgradeTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/upgrade`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for upgradeTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -341,10 +707,11 @@ class Theme {
    *   page. Default value is 10.
    * @param {number} [arg.pageNo] - The page number to navigate through the
    *   given set of results. Default value is 1.
+   * @returns {Promise<ThemesListingResponseSchema>} - Success response
    * @summary: Get all public themes
    * @description: Use this API to get a list of free themes that you can apply to your website.
    */
-  getPublicThemes({ pageSize, pageNo } = {}) {
+  async getPublicThemes({ pageSize, pageNo } = {}) {
     const { error } = ThemeValidator.getPublicThemes().validate(
       {
         pageSize,
@@ -356,26 +723,60 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.getPublicThemes().validate(
+      {
+        pageSize,
+        pageNo,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPublicThemes",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_size"] = pageSize;
     query_params["page_no"] = pageNo;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/list/public`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ThemeModel.ThemesListingResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPublicThemes",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {ThemesSchema} arg.body
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Create a new theme
    * @description: Themes improve the look and appearance of a website. Use this API to create a theme.
    */
-  createTheme({ body } = {}) {
+  async createTheme({ body } = {}) {
     const { error } = ThemeValidator.createTheme().validate(
       {
         body,
@@ -386,23 +787,54 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.createTheme().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/`,
       query_params,
       body
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Get the applied theme
    * @description: Use this API to retrieve the theme that is currently applied to the website along with its details.
    */
-  getAppliedTheme({} = {}) {
+  async getAppliedTheme({} = {}) {
     const { error } = ThemeValidator.getAppliedTheme().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -411,23 +843,52 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.getAppliedTheme().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppliedTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppliedTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<FontsSchema>} - Success response
    * @summary: Get all the supported fonts in a theme
    * @description: Font is a collection of characters with a similar design. Use this API to retrieve a list of website fonts.
    */
-  getFonts({} = {}) {
+  async getFonts({} = {}) {
     const { error } = ThemeValidator.getFonts().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -436,24 +897,53 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.getFonts().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getFonts",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/fonts`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.FontsSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getFonts",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Gets theme by id
    * @description: Use this API to retrieve the details of a specific theme by using its ID.
    */
-  getThemeById({ themeId } = {}) {
+  async getThemeById({ themeId } = {}) {
     const { error } = ThemeValidator.getThemeById().validate(
       {
         themeId,
@@ -464,25 +954,56 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.getThemeById().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getThemeById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getThemeById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
    * @param {ThemesSchema} arg.body
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Update a theme
    * @description: Use this API to edit an existing theme. You can customize the website font, sections, images, styles, and many more.
    */
-  updateTheme({ themeId, body } = {}) {
+  async updateTheme({ themeId, body } = {}) {
     const { error } = ThemeValidator.updateTheme().validate(
       {
         themeId,
@@ -494,24 +1015,56 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.updateTheme().validate(
+      {
+        themeId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}`,
       query_params,
       body
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Delete a theme
    * @description: Use this API to delete a theme from the theme library.
    */
-  deleteTheme({ themeId } = {}) {
+  async deleteTheme({ themeId } = {}) {
     const { error } = ThemeValidator.deleteTheme().validate(
       {
         themeId,
@@ -522,24 +1075,55 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.deleteTheme().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Get a theme preview
    * @description: A theme can be previewed before applying it. Use this API to retrieve the theme preview by using its ID.
    */
-  getThemeForPreview({ themeId } = {}) {
+  async getThemeForPreview({ themeId } = {}) {
     const { error } = ThemeValidator.getThemeForPreview().validate(
       {
         themeId,
@@ -550,24 +1134,55 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.getThemeForPreview().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getThemeForPreview",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/preview`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getThemeForPreview",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Publish a theme
    * @description: Use this API to publish a theme that is either newly created or edited.
    */
-  publishTheme({ themeId } = {}) {
+  async publishTheme({ themeId } = {}) {
     const { error } = ThemeValidator.publishTheme().validate(
       {
         themeId,
@@ -578,24 +1193,55 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.publishTheme().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for publishTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/publish`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for publishTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Unpublish a theme
    * @description: Use this API to remove an existing theme from the list of available themes.
    */
-  unpublishTheme({ themeId } = {}) {
+  async unpublishTheme({ themeId } = {}) {
     const { error } = ThemeValidator.unpublishTheme().validate(
       {
         themeId,
@@ -606,24 +1252,55 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.unpublishTheme().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for unpublishTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/unpublish`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for unpublishTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Archive a theme
    * @description: Use this API to store an existing theme but not delete it so that it can be used in future if required.
    */
-  archiveTheme({ themeId } = {}) {
+  async archiveTheme({ themeId } = {}) {
     const { error } = ThemeValidator.archiveTheme().validate(
       {
         themeId,
@@ -634,24 +1311,55 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.archiveTheme().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for archiveTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/archive`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for archiveTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
+   * @returns {Promise<ThemesSchema>} - Success response
    * @summary: Unarchive a theme
    * @description: Use this API to restore an archived theme and bring it back for editing or publishing.
    */
-  unarchiveTheme({ themeId } = {}) {
+  async unarchiveTheme({ themeId } = {}) {
     const { error } = ThemeValidator.unarchiveTheme().validate(
       {
         themeId,
@@ -662,24 +1370,55 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.unarchiveTheme().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for unarchiveTheme",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/unarchive`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ThemeModel.ThemesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for unarchiveTheme",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.themeId - ID allotted to the theme.
+   * @returns {Promise<any>} - Success response
    * @summary: Fetch last modified timestamp
    * @description: Use this API to fetch Last-Modified timestamp in header metadata.
    */
-  getThemeLastModified({ themeId } = {}) {
+  async getThemeLastModified({ themeId } = {}) {
     const { error } = ThemeValidator.getThemeLastModified().validate(
       {
         themeId,
@@ -690,15 +1429,44 @@ class Theme {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ThemeValidator.getThemeLastModified().validate(
+      {
+        themeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getThemeLastModified",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "head",
       `/service/platform/theme/v1.0/company/${this.config.companyId}/application/${this.applicationId}/${themeId}/polling`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = Joi.string()
+      .allow("")
+      .validate(response, { abortEarly: false, allowUnknown: false });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getThemeLastModified",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 }
 module.exports = Theme;