@gofynd/fdk-client-javascript 1.0.0 → 1.0.2

package/sdk/platform/Configuration/ConfigurationPlatformApplicationClient.js

@@ -2,6 +2,8 @@ const Paginator = require("../../common/Paginator");
 const PlatformAPIClient = require("../PlatformAPIClient");
 const { FDKClientValidationError } = require("../../common/FDKError");
 const ConfigurationValidator = require("./ConfigurationPlatformApplicationValidator");
+const ConfigurationModel = require("./ConfigurationPlatformModel");
+const { Logger } = require("./../../common/Logger");
 
 class Configuration {
   constructor(config, applicationId) {
@@ -12,10 +14,11 @@ class Configuration {
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.platformType - Current platform name
+   * @returns {Promise<MobileAppConfiguration>} - Success response
    * @summary: Get latest build config
    * @description: Get latest build config
    */
-  getBuildConfig({ platformType } = {}) {
+  async getBuildConfig({ platformType } = {}) {
     const { error } = ConfigurationValidator.getBuildConfig().validate(
       {
         platformType,
@@ -26,25 +29,60 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getBuildConfig().validate(
+      {
+        platformType,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getBuildConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/build/${platformType}/configuration`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.MobileAppConfiguration().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getBuildConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.platformType - Current platform name
    * @param {MobileAppConfigRequest} arg.body
+   * @returns {Promise<MobileAppConfiguration>} - Success response
    * @summary: Update build config for next build
    * @description: Update build config for next build
    */
-  updateBuildConfig({ platformType, body } = {}) {
+  async updateBuildConfig({ platformType, body } = {}) {
     const { error } = ConfigurationValidator.updateBuildConfig().validate(
       {
         platformType,
@@ -56,24 +94,60 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.updateBuildConfig().validate(
+      {
+        platformType,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateBuildConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/build/${platformType}/configuration`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.MobileAppConfiguration().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateBuildConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.platformType - Current platform name
+   * @returns {Promise<BuildVersionHistory>} - Success response
    * @summary: Get previous build versions
    * @description: Get previous build versions
    */
-  getPreviousVersions({ platformType } = {}) {
+  async getPreviousVersions({ platformType } = {}) {
     const { error } = ConfigurationValidator.getPreviousVersions().validate(
       {
         platformType,
@@ -84,23 +158,58 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getPreviousVersions().validate(
+      {
+        platformType,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPreviousVersions",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/build/${platformType}/versions`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.BuildVersionHistory().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPreviousVersions",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<AppFeatureResponse>} - Success response
    * @summary: Get features of application
    * @description: Get features of application
    */
-  getAppFeatures({} = {}) {
+  async getAppFeatures({} = {}) {
     const { error } = ConfigurationValidator.getAppFeatures().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -109,24 +218,57 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getAppFeatures().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppFeatures",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/feature`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.AppFeatureResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppFeatures",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {AppFeatureRequest} arg.body
+   * @returns {Promise<AppFeature>} - Success response
    * @summary: Update features of application
    * @description: Update features of application
    */
-  updateAppFeatures({ body } = {}) {
+  async updateAppFeatures({ body } = {}) {
     const { error } = ConfigurationValidator.updateAppFeatures().validate(
       {
         body,
@@ -137,23 +279,58 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.updateAppFeatures().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppFeatures",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/feature`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.AppFeature().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppFeatures",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<ApplicationDetail>} - Success response
    * @summary: Get basic application details
    * @description: Get basic application details like name
    */
-  getAppBasicDetails({} = {}) {
+  async getAppBasicDetails({} = {}) {
     const { error } = ConfigurationValidator.getAppBasicDetails().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -162,24 +339,57 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getAppBasicDetails().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppBasicDetails",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/detail`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.ApplicationDetail().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppBasicDetails",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {ApplicationDetail} arg.body
+   * @returns {Promise<ApplicationDetail>} - Success response
    * @summary: Add or update application's basic details
    * @description: Add or update application's basic details
    */
-  updateAppBasicDetails({ body } = {}) {
+  async updateAppBasicDetails({ body } = {}) {
     const { error } = ConfigurationValidator.updateAppBasicDetails().validate(
       {
         body,
@@ -190,23 +400,58 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.updateAppBasicDetails().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppBasicDetails",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/detail`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.ApplicationDetail().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppBasicDetails",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<ApplicationInformation>} - Success response
    * @summary: Get application information
    * @description: Get Application Current Information. This includes information about social links, address and contact information of company/seller/brand of the application.
    */
-  getAppContactInfo({} = {}) {
+  async getAppContactInfo({} = {}) {
     const { error } = ConfigurationValidator.getAppContactInfo().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -215,24 +460,57 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getAppContactInfo().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppContactInfo",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/information`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.ApplicationInformation().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppContactInfo",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {ApplicationInformation} arg.body
+   * @returns {Promise<ApplicationInformation>} - Success response
    * @summary: Get application information
    * @description: Save Application Current Information. This includes information about social links, address and contact information of an application.
    */
-  updateAppContactInfo({ body } = {}) {
+  async updateAppContactInfo({ body } = {}) {
     const { error } = ConfigurationValidator.updateAppContactInfo().validate(
       {
         body,
@@ -243,23 +521,58 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.updateAppContactInfo().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppContactInfo",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/information`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.ApplicationInformation().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppContactInfo",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<TokenResponse>} - Success response
    * @summary: Get social tokens
    * @description: Get social tokens.
    */
-  getAppApiTokens({} = {}) {
+  async getAppApiTokens({} = {}) {
     const { error } = ConfigurationValidator.getAppApiTokens().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -268,24 +581,57 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getAppApiTokens().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppApiTokens",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/token`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.TokenResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppApiTokens",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {TokenResponse} arg.body
+   * @returns {Promise<TokenResponse>} - Success response
    * @summary: Add social tokens
    * @description: Add social tokens.
    */
-  updateAppApiTokens({ body } = {}) {
+  async updateAppApiTokens({ body } = {}) {
     const { error } = ConfigurationValidator.updateAppApiTokens().validate(
       {
         body,
@@ -296,15 +642,49 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.updateAppApiTokens().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppApiTokens",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/token`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.TokenResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppApiTokens",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -312,10 +692,11 @@ class Configuration {
    * @param {number} [arg.uid] - Uid of companies to be fetched
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
+   * @returns {Promise<CompaniesResponse>} - Success response
    * @summary: Application inventory enabled companies
    * @description: Application inventory enabled companies.
    */
-  getAppCompanies({ uid, pageNo, pageSize } = {}) {
+  async getAppCompanies({ uid, pageNo, pageSize } = {}) {
     const { error } = ConfigurationValidator.getAppCompanies().validate(
       {
         uid,
@@ -328,18 +709,54 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getAppCompanies().validate(
+      {
+        uid,
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppCompanies",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["uid"] = uid;
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/companies`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.CompaniesResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppCompanies",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -378,10 +795,11 @@ class Configuration {
    * @param {Object} arg - Arg object.
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
+   * @returns {Promise<StoresResponse>} - Success response
    * @summary: Application inventory enabled stores
    * @description: Application inventory enabled stores.
    */
-  getAppStores({ pageNo, pageSize } = {}) {
+  async getAppStores({ pageNo, pageSize } = {}) {
     const { error } = ConfigurationValidator.getAppStores().validate(
       {
         pageNo,
@@ -393,17 +811,50 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ConfigurationValidator.getAppStores().validate(
+      {
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppStores",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/stores`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.StoresResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppStores",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -438,10 +889,11 @@ class Configuration {
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<ApplicationInventory>} - Success response
    * @summary: Get application configuration
    * @description: Get application configuration for various features and data
    */
-  getInventoryConfig({} = {}) {
+  async getInventoryConfig({} = {}) {
     const { error } = ConfigurationValidator.getInventoryConfig().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -450,24 +902,57 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getInventoryConfig().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getInventoryConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/configuration`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.ApplicationInventory().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getInventoryConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {ApplicationInventory} arg.body
+   * @returns {Promise<ApplicationInventory>} - Success response
    * @summary: Update application configuration
    * @description: Update application configuration for various features and data
    */
-  updateInventoryConfig({ body } = {}) {
+  async updateInventoryConfig({ body } = {}) {
     const { error } = ConfigurationValidator.updateInventoryConfig().validate(
       {
         body,
@@ -478,24 +963,59 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.updateInventoryConfig().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateInventoryConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/configuration`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.ApplicationInventory().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateInventoryConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {AppInventoryPartialUpdate} arg.body
+   * @returns {Promise<ApplicationInventory>} - Success response
    * @summary: Partially update application configuration
    * @description: Partially update application configuration for various features and data
    */
-  partiallyUpdateInventoryConfig({ body } = {}) {
+  async partiallyUpdateInventoryConfig({ body } = {}) {
     const {
       error,
     } = ConfigurationValidator.partiallyUpdateInventoryConfig().validate(
@@ -508,23 +1028,60 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.partiallyUpdateInventoryConfig().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for partiallyUpdateInventoryConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "patch",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/configuration`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.ApplicationInventory().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for partiallyUpdateInventoryConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<AppSupportedCurrency>} - Success response
    * @summary: Get application enabled currency list
    * @description: Get application enabled currency list
    */
-  getAppCurrencyConfig({} = {}) {
+  async getAppCurrencyConfig({} = {}) {
     const { error } = ConfigurationValidator.getAppCurrencyConfig().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -533,24 +1090,57 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getAppCurrencyConfig().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppCurrencyConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/currency`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.AppSupportedCurrency().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppCurrencyConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {AppSupportedCurrency} arg.body
+   * @returns {Promise<AppSupportedCurrency>} - Success response
    * @summary: Add initial application supported currency
    * @description: Add initial application supported currency for various features and data. Default INR will be enabled.
    */
-  updateAppCurrencyConfig({ body } = {}) {
+  async updateAppCurrencyConfig({ body } = {}) {
     const { error } = ConfigurationValidator.updateAppCurrencyConfig().validate(
       {
         body,
@@ -561,23 +1151,58 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.updateAppCurrencyConfig().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAppCurrencyConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/currency`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.AppSupportedCurrency().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAppCurrencyConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<AppCurrencyResponse>} - Success response
    * @summary: Get currencies enabled in the application
    * @description: Use this API to get a list of currencies allowed in the current application. Moreover, get the name, code, symbol, and the decimal digits of the currencies.
    */
-  getAppSupportedCurrency({} = {}) {
+  async getAppSupportedCurrency({} = {}) {
     const { error } = ConfigurationValidator.getAppSupportedCurrency().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -586,15 +1211,47 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getAppSupportedCurrency().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAppSupportedCurrency",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/currency/supported`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.AppCurrencyResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAppSupportedCurrency",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -602,10 +1259,11 @@ class Configuration {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {FilterOrderingStoreRequest} arg.body
+   * @returns {Promise<OrderingStores>} - Success response
    * @summary: Get ordering store by filter
    * @description: Get ordering store by filter
    */
-  getOrderingStoresByFilter({ body, pageNo, pageSize } = {}) {
+  async getOrderingStoresByFilter({ body, pageNo, pageSize } = {}) {
     const {
       error,
     } = ConfigurationValidator.getOrderingStoresByFilter().validate(
@@ -620,17 +1278,53 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getOrderingStoresByFilter().validate(
+      {
+        body,
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getOrderingStoresByFilter",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/ordering-store/stores/filter`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.OrderingStores().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getOrderingStoresByFilter",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -673,10 +1367,11 @@ class Configuration {
   /**
    * @param {Object} arg - Arg object.
    * @param {OrderingStoreConfig} arg.body
+   * @returns {Promise<DeploymentMeta>} - Success response
    * @summary: Add/Update ordering store config
    * @description: Add/Update ordering store config.
    */
-  updateOrderingStoreConfig({ body } = {}) {
+  async updateOrderingStoreConfig({ body } = {}) {
     const {
       error,
     } = ConfigurationValidator.updateOrderingStoreConfig().validate(
@@ -689,15 +1384,49 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.updateOrderingStoreConfig().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateOrderingStoreConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/ordering-store`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.DeploymentMeta().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateOrderingStoreConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -707,10 +1436,11 @@ class Configuration {
    * @param {number} [arg.pageSize] - The number of items to retrieve in each
    *   page. Default value is 10.
    * @param {string} [arg.q] - Store code or name of the ordering store.
+   * @returns {Promise<OrderingStoresResponse>} - Success response
    * @summary: Get deployment stores
    * @description: Use this API to retrieve the details of all stores access given to the staff member (the selling locations where the application will be utilized for placing orders).
    */
-  getStaffOrderingStores({ pageNo, pageSize, q } = {}) {
+  async getStaffOrderingStores({ pageNo, pageSize, q } = {}) {
     const { error } = ConfigurationValidator.getStaffOrderingStores().validate(
       {
         pageNo,
@@ -723,18 +1453,54 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getStaffOrderingStores().validate(
+      {
+        pageNo,
+        pageSize,
+        q,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getStaffOrderingStores",
+      });
+      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/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/ordering-store/staff-stores`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.OrderingStoresResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getStaffOrderingStores",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -777,10 +1543,11 @@ class Configuration {
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<DomainsResponse>} - Success response
    * @summary: Get attached domain list
    * @description: Get attached domain list.
    */
-  getDomains({} = {}) {
+  async getDomains({} = {}) {
     const { error } = ConfigurationValidator.getDomains().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -789,24 +1556,55 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ConfigurationValidator.getDomains().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getDomains",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/domain`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.DomainsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getDomains",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {DomainAddRequest} arg.body
+   * @returns {Promise<Domain>} - Success response
    * @summary: Add new domain to application
    * @description: Add new domain to application.
    */
-  addDomain({ body } = {}) {
+  async addDomain({ body } = {}) {
     const { error } = ConfigurationValidator.addDomain().validate(
       {
         body,
@@ -817,24 +1615,55 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ConfigurationValidator.addDomain().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for addDomain",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/domain`,
       query_params,
       body
     );
+
+    const { error: res_error } = ConfigurationModel.Domain().validate(
+      response,
+      { abortEarly: false, allowUnknown: false }
+    );
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for addDomain",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Domain _id
+   * @returns {Promise<SuccessMessageResponse>} - Success response
    * @summary: Remove attached domain
    * @description: Remove attached domain.
    */
-  removeDomainById({ id } = {}) {
+  async removeDomainById({ id } = {}) {
     const { error } = ConfigurationValidator.removeDomainById().validate(
       {
         id,
@@ -845,24 +1674,59 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.removeDomainById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for removeDomainById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/domain/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.SuccessMessageResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for removeDomainById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {UpdateDomainTypeRequest} arg.body
+   * @returns {Promise<DomainsResponse>} - Success response
    * @summary: Change domain type
    * @description: Change a domain to Primary or Shortlink domain
    */
-  changeDomainType({ body } = {}) {
+  async changeDomainType({ body } = {}) {
     const { error } = ConfigurationValidator.changeDomainType().validate(
       {
         body,
@@ -873,24 +1737,59 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.changeDomainType().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for changeDomainType",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/domain/set-domain`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.DomainsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for changeDomainType",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {DomainStatusRequest} arg.body
+   * @returns {Promise<DomainStatusResponse>} - Success response
    * @summary: Get domain connected status.
    * @description: Get domain connected status. Check if domain is live and mapped to appropriate IP to fynd servers.
    */
-  getDomainStatus({ body } = {}) {
+  async getDomainStatus({ body } = {}) {
     const { error } = ConfigurationValidator.getDomainStatus().validate(
       {
         body,
@@ -901,23 +1800,58 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getDomainStatus().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getDomainStatus",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}/domain/domain-status`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.DomainStatusResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getDomainStatus",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<Application>} - Success response
    * @summary: Get application data from id
    * @description: Get application data from id
    */
-  getApplicationById({} = {}) {
+  async getApplicationById({} = {}) {
     const { error } = ConfigurationValidator.getApplicationById().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -926,15 +1860,47 @@ class Configuration {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ConfigurationValidator.getApplicationById().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getApplicationById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/configuration/v1.0/company/${this.config.companyId}/application/${this.applicationId}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ConfigurationModel.Application().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getApplicationById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 }
 module.exports = Configuration;