@gofynd/fdk-client-javascript 1.0.0 → 1.0.2

package/sdk/platform/Communication/CommunicationPlatformApplicationClient.js

@@ -2,6 +2,8 @@ const Paginator = require("../../common/Paginator");
 const PlatformAPIClient = require("../PlatformAPIClient");
 const { FDKClientValidationError } = require("../../common/FDKError");
 const CommunicationValidator = require("./CommunicationPlatformApplicationValidator");
+const CommunicationModel = require("./CommunicationPlatformModel");
+const { Logger } = require("./../../common/Logger");
 
 class Communication {
   constructor(config, applicationId) {
@@ -14,10 +16,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<Campaigns>} - Success response
    * @summary: Get campaigns
    * @description: Get campaigns
    */
-  getCampaigns({ pageNo, pageSize, sort } = {}) {
+  async getCampaigns({ pageNo, pageSize, sort } = {}) {
     const { error } = CommunicationValidator.getCampaigns().validate(
       {
         pageNo,
@@ -30,18 +33,52 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CommunicationValidator.getCampaigns().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getCampaigns",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/campaigns/campaigns`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.Campaigns().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getCampaigns",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -79,10 +116,11 @@ class Communication {
   /**
    * @param {Object} arg - Arg object.
    * @param {CampaignReq} arg.body
+   * @returns {Promise<Campaign>} - Success response
    * @summary: Create campaign
    * @description: Create campaign
    */
-  createCampaign({ body } = {}) {
+  async createCampaign({ body } = {}) {
     const { error } = CommunicationValidator.createCampaign().validate(
       {
         body,
@@ -93,24 +131,59 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.createCampaign().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createCampaign",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/campaigns/campaigns`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.Campaign().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createCampaign",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Campaign id
+   * @returns {Promise<Campaign>} - Success response
    * @summary: Get campaign by id
    * @description: Get campaign by id
    */
-  getCampaignById({ id } = {}) {
+  async getCampaignById({ id } = {}) {
     const { error } = CommunicationValidator.getCampaignById().validate(
       {
         id,
@@ -121,25 +194,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getCampaignById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getCampaignById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/campaigns/campaigns/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.Campaign().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getCampaignById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Campaign id
    * @param {CampaignReq} arg.body
+   * @returns {Promise<Campaign>} - Success response
    * @summary: Update campaign by id
    * @description: Update campaign by id
    */
-  updateCampaignById({ id, body } = {}) {
+  async updateCampaignById({ id, body } = {}) {
     const { error } = CommunicationValidator.updateCampaignById().validate(
       {
         id,
@@ -151,24 +259,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.updateCampaignById().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateCampaignById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/campaigns/campaigns/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.Campaign().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateCampaignById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Campaign id
+   * @returns {Promise<GetStats>} - Success response
    * @summary: Get stats of campaign by id
    * @description: Get stats of campaign by id
    */
-  getStatsOfCampaignById({ id } = {}) {
+  async getStatsOfCampaignById({ id } = {}) {
     const { error } = CommunicationValidator.getStatsOfCampaignById().validate(
       {
         id,
@@ -179,15 +323,49 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getStatsOfCampaignById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getStatsOfCampaignById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/campaigns/get-stats/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.GetStats().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getStatsOfCampaignById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -195,10 +373,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<Audiences>} - Success response
    * @summary: Get audiences
    * @description: Get audiences
    */
-  getAudiences({ pageNo, pageSize, sort } = {}) {
+  async getAudiences({ pageNo, pageSize, sort } = {}) {
     const { error } = CommunicationValidator.getAudiences().validate(
       {
         pageNo,
@@ -211,18 +390,52 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CommunicationValidator.getAudiences().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAudiences",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sources/datasources`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.Audiences().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAudiences",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -260,10 +473,11 @@ class Communication {
   /**
    * @param {Object} arg - Arg object.
    * @param {AudienceReq} arg.body
+   * @returns {Promise<Audience>} - Success response
    * @summary: Create audience
    * @description: Create audience
    */
-  createAudience({ body } = {}) {
+  async createAudience({ body } = {}) {
     const { error } = CommunicationValidator.createAudience().validate(
       {
         body,
@@ -274,24 +488,59 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.createAudience().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createAudience",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sources/datasources`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.Audience().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createAudience",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {BigqueryHeadersReq} arg.body
+   * @returns {Promise<BigqueryHeadersRes>} - Success response
    * @summary: Get bigquery headers
    * @description: Get bigquery headers
    */
-  getBigqueryHeaders({ body } = {}) {
+  async getBigqueryHeaders({ body } = {}) {
     const { error } = CommunicationValidator.getBigqueryHeaders().validate(
       {
         body,
@@ -302,24 +551,59 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getBigqueryHeaders().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getBigqueryHeaders",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sources/bigquery-headers`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.BigqueryHeadersRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getBigqueryHeaders",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Audience id
+   * @returns {Promise<Audience>} - Success response
    * @summary: Get audience by id
    * @description: Get audience by id
    */
-  getAudienceById({ id } = {}) {
+  async getAudienceById({ id } = {}) {
     const { error } = CommunicationValidator.getAudienceById().validate(
       {
         id,
@@ -330,25 +614,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getAudienceById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAudienceById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sources/datasources/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.Audience().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAudienceById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Audience id
    * @param {AudienceReq} arg.body
+   * @returns {Promise<Audience>} - Success response
    * @summary: Update audience by id
    * @description: Update audience by id
    */
-  updateAudienceById({ id, body } = {}) {
+  async updateAudienceById({ id, body } = {}) {
     const { error } = CommunicationValidator.updateAudienceById().validate(
       {
         id,
@@ -360,24 +679,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.updateAudienceById().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAudienceById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sources/datasources/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.Audience().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAudienceById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {GetNRecordsCsvReq} arg.body
+   * @returns {Promise<GetNRecordsCsvRes>} - Success response
    * @summary: Get n sample records from csv
    * @description: Get n sample records from csv
    */
-  getNSampleRecordsFromCsv({ body } = {}) {
+  async getNSampleRecordsFromCsv({ body } = {}) {
     const {
       error,
     } = CommunicationValidator.getNSampleRecordsFromCsv().validate(
@@ -390,15 +745,49 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getNSampleRecordsFromCsv().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getNSampleRecordsFromCsv",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sources/get-n-records`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.GetNRecordsCsvRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getNSampleRecordsFromCsv",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -406,10 +795,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<EmailProviders>} - Success response
    * @summary: Get email providers
    * @description: Get email providers
    */
-  getEmailProviders({ pageNo, pageSize, sort } = {}) {
+  async getEmailProviders({ pageNo, pageSize, sort } = {}) {
     const { error } = CommunicationValidator.getEmailProviders().validate(
       {
         pageNo,
@@ -422,18 +812,54 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getEmailProviders().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getEmailProviders",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/providers`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EmailProviders().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getEmailProviders",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -476,10 +902,11 @@ class Communication {
   /**
    * @param {Object} arg - Arg object.
    * @param {EmailProviderReq} arg.body
+   * @returns {Promise<EmailProvider>} - Success response
    * @summary: Create email provider
    * @description: Create email provider
    */
-  createEmailProvider({ body } = {}) {
+  async createEmailProvider({ body } = {}) {
     const { error } = CommunicationValidator.createEmailProvider().validate(
       {
         body,
@@ -490,24 +917,59 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.createEmailProvider().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createEmailProvider",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/providers`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EmailProvider().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createEmailProvider",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Email provider id
+   * @returns {Promise<EmailProvider>} - Success response
    * @summary: Get email provider by id
    * @description: Get email provider by id
    */
-  getEmailProviderById({ id } = {}) {
+  async getEmailProviderById({ id } = {}) {
     const { error } = CommunicationValidator.getEmailProviderById().validate(
       {
         id,
@@ -518,25 +980,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getEmailProviderById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getEmailProviderById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/providers/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EmailProvider().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getEmailProviderById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Email provider id
    * @param {EmailProviderReq} arg.body
+   * @returns {Promise<EmailProvider>} - Success response
    * @summary: Update email provider by id
    * @description: Update email provider by id
    */
-  updateEmailProviderById({ id, body } = {}) {
+  async updateEmailProviderById({ id, body } = {}) {
     const { error } = CommunicationValidator.updateEmailProviderById().validate(
       {
         id,
@@ -548,15 +1045,50 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.updateEmailProviderById().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateEmailProviderById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/providers/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EmailProvider().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateEmailProviderById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -564,10 +1096,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<EmailTemplates>} - Success response
    * @summary: Get email templates
    * @description: Get email templates
    */
-  getEmailTemplates({ pageNo, pageSize, sort } = {}) {
+  async getEmailTemplates({ pageNo, pageSize, sort } = {}) {
     const { error } = CommunicationValidator.getEmailTemplates().validate(
       {
         pageNo,
@@ -580,18 +1113,54 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getEmailTemplates().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getEmailTemplates",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/templates`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EmailTemplates().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getEmailTemplates",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -634,10 +1203,11 @@ class Communication {
   /**
    * @param {Object} arg - Arg object.
    * @param {EmailTemplateReq} arg.body
+   * @returns {Promise<EmailTemplateRes>} - Success response
    * @summary: Create email template
    * @description: Create email template
    */
-  createEmailTemplate({ body } = {}) {
+  async createEmailTemplate({ body } = {}) {
     const { error } = CommunicationValidator.createEmailTemplate().validate(
       {
         body,
@@ -648,15 +1218,49 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.createEmailTemplate().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createEmailTemplate",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/templates`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EmailTemplateRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createEmailTemplate",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -664,10 +1268,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<SystemEmailTemplates>} - Success response
    * @summary: Get system email templates
    * @description: Get system email templates
    */
-  getSystemEmailTemplates({ pageNo, pageSize, sort } = {}) {
+  async getSystemEmailTemplates({ pageNo, pageSize, sort } = {}) {
     const { error } = CommunicationValidator.getSystemEmailTemplates().validate(
       {
         pageNo,
@@ -680,18 +1285,54 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getSystemEmailTemplates().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSystemEmailTemplates",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/system-templates`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SystemEmailTemplates().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSystemEmailTemplates",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -734,10 +1375,11 @@ class Communication {
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Email template id
+   * @returns {Promise<EmailTemplate>} - Success response
    * @summary: Get email template by id
    * @description: Get email template by id
    */
-  getEmailTemplateById({ id } = {}) {
+  async getEmailTemplateById({ id } = {}) {
     const { error } = CommunicationValidator.getEmailTemplateById().validate(
       {
         id,
@@ -748,25 +1390,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getEmailTemplateById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getEmailTemplateById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/templates/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EmailTemplate().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getEmailTemplateById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Email template id
    * @param {EmailTemplateReq} arg.body
+   * @returns {Promise<EmailTemplateRes>} - Success response
    * @summary: Update email template by id
    * @description: Update email template by id
    */
-  updateEmailTemplateById({ id, body } = {}) {
+  async updateEmailTemplateById({ id, body } = {}) {
     const { error } = CommunicationValidator.updateEmailTemplateById().validate(
       {
         id,
@@ -778,24 +1455,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.updateEmailTemplateById().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateEmailTemplateById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/templates/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EmailTemplateRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateEmailTemplateById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Email template id
+   * @returns {Promise<EmailTemplateDeleteSuccessRes>} - Success response
    * @summary: Delete email template by id
    * @description: Delete email template by id
    */
-  deleteEmailTemplateById({ id } = {}) {
+  async deleteEmailTemplateById({ id } = {}) {
     const { error } = CommunicationValidator.deleteEmailTemplateById().validate(
       {
         id,
@@ -806,24 +1519,59 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.deleteEmailTemplateById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteEmailTemplateById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/email/templates/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EmailTemplateDeleteSuccessRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteEmailTemplateById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {EngineRequest} arg.body
+   * @returns {Promise<EngineResponse>} - Success response
    * @summary: Send email or sms synchronously
    * @description: Send email or sms synchronously
    */
-  sendCommunicationSynchronously({ body } = {}) {
+  async sendCommunicationSynchronously({ body } = {}) {
     const {
       error,
     } = CommunicationValidator.sendCommunicationSynchronously().validate(
@@ -836,24 +1584,61 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.sendCommunicationSynchronously().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for sendCommunicationSynchronously",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/engine/send-instant`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EngineResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for sendCommunicationSynchronously",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {EngineRequest} arg.body
+   * @returns {Promise<EngineResponse>} - Success response
    * @summary: Send email or sms asynchronously
    * @description: Send email or sms asynchronously
    */
-  sendCommunicationAsynchronously({ body } = {}) {
+  async sendCommunicationAsynchronously({ body } = {}) {
     const {
       error,
     } = CommunicationValidator.sendCommunicationAsynchronously().validate(
@@ -866,15 +1651,51 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.sendCommunicationAsynchronously().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for sendCommunicationAsynchronously",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/engine/send-async`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EngineResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for sendCommunicationAsynchronously",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -882,10 +1703,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {string} [arg.populate] - Populate fields
+   * @returns {Promise<EventSubscriptions>} - Success response
    * @summary: Get event subscriptions
    * @description: Get event subscriptions
    */
-  getEventSubscriptions({ pageNo, pageSize, populate } = {}) {
+  async getEventSubscriptions({ pageNo, pageSize, populate } = {}) {
     const { error } = CommunicationValidator.getEventSubscriptions().validate(
       {
         pageNo,
@@ -898,18 +1720,54 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getEventSubscriptions().validate(
+      {
+        pageNo,
+        pageSize,
+        populate,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getEventSubscriptions",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["populate"] = populate;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/event/event-subscriptions`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.EventSubscriptions().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getEventSubscriptions",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -954,10 +1812,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<Jobs>} - Success response
    * @summary: Get jobs
    * @description: Get jobs
    */
-  getJobs({ pageNo, pageSize, sort } = {}) {
+  async getJobs({ pageNo, pageSize, sort } = {}) {
     const { error } = CommunicationValidator.getJobs().validate(
       {
         pageNo,
@@ -970,18 +1829,50 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CommunicationValidator.getJobs().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getJobs",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/jobs/jobs`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = CommunicationModel.Jobs().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getJobs",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1019,10 +1910,11 @@ class Communication {
   /**
    * @param {Object} arg - Arg object.
    * @param {TriggerJobRequest} arg.body
+   * @returns {Promise<TriggerJobResponse>} - Success response
    * @summary: Trigger campaign job
    * @description: Trigger campaign job
    */
-  triggerCampaignJob({ body } = {}) {
+  async triggerCampaignJob({ body } = {}) {
     const { error } = CommunicationValidator.triggerCampaignJob().validate(
       {
         body,
@@ -1033,15 +1925,49 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.triggerCampaignJob().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for triggerCampaignJob",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/jobs/trigger-job`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.TriggerJobResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for triggerCampaignJob",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1049,10 +1975,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<JobLogs>} - Success response
    * @summary: Get job logs
    * @description: Get job logs
    */
-  getJobLogs({ pageNo, pageSize, sort } = {}) {
+  async getJobLogs({ pageNo, pageSize, sort } = {}) {
     const { error } = CommunicationValidator.getJobLogs().validate(
       {
         pageNo,
@@ -1065,18 +1992,50 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CommunicationValidator.getJobLogs().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getJobLogs",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/jobs/logs`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = CommunicationModel.JobLogs().validate(
+      response,
+      { abortEarly: false, allowUnknown: false }
+    );
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getJobLogs",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1117,10 +2076,11 @@ class Communication {
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on _id
    * @param {Object} [arg.query] -
+   * @returns {Promise<Logs>} - Success response
    * @summary: Get communication logs
    * @description: Get communication logs
    */
-  getCommunicationLogs({ pageId, pageSize, sort, query } = {}) {
+  async getCommunicationLogs({ pageId, pageSize, sort, query } = {}) {
     const { error } = CommunicationValidator.getCommunicationLogs().validate(
       {
         pageId,
@@ -1134,19 +2094,54 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getCommunicationLogs().validate(
+      {
+        pageId,
+        pageSize,
+        sort,
+        query,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getCommunicationLogs",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_id"] = pageId;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
     query_params["query"] = query;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/log`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = CommunicationModel.Logs().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getCommunicationLogs",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1192,10 +2187,11 @@ class Communication {
   /**
    * @param {Object} arg - Arg object.
    * @param {SendOtpCommsReq} arg.body
+   * @returns {Promise<SendOtpCommsRes>} - Success response
    * @summary: Send OTP using email and sms
    * @description: Send OTP Comms via email and sms
    */
-  sendOtp({ body } = {}) {
+  async sendOtp({ body } = {}) {
     const { error } = CommunicationValidator.sendOtp().validate(
       {
         body,
@@ -1206,24 +2202,57 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CommunicationValidator.sendOtp().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for sendOtp",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/otp/send-otp-comms`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SendOtpCommsRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for sendOtp",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {VerifyOtpCommsReq} arg.body
+   * @returns {Promise<VerifyOtpCommsSuccessRes>} - Success response
    * @summary: Verify OTP sent via email and sms
    * @description: Verify OTP sent via email and sms
    */
-  verfiyOtp({ body } = {}) {
+  async verfiyOtp({ body } = {}) {
     const { error } = CommunicationValidator.verfiyOtp().validate(
       {
         body,
@@ -1234,15 +2263,47 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = CommunicationValidator.verfiyOtp().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for verfiyOtp",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/otp/verify-otp-comms`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.VerifyOtpCommsSuccessRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for verfiyOtp",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1250,10 +2311,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<SmsProviders>} - Success response
    * @summary: Get sms providers
    * @description: Get sms providers
    */
-  getSmsProviders({ pageNo, pageSize, sort } = {}) {
+  async getSmsProviders({ pageNo, pageSize, sort } = {}) {
     const { error } = CommunicationValidator.getSmsProviders().validate(
       {
         pageNo,
@@ -1266,18 +2328,54 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getSmsProviders().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSmsProviders",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/providers`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SmsProviders().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSmsProviders",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1315,10 +2413,11 @@ class Communication {
   /**
    * @param {Object} arg - Arg object.
    * @param {SmsProviderReq} arg.body
+   * @returns {Promise<SmsProvider>} - Success response
    * @summary: Create sms provider
    * @description: Create sms provider
    */
-  createSmsProvider({ body } = {}) {
+  async createSmsProvider({ body } = {}) {
     const { error } = CommunicationValidator.createSmsProvider().validate(
       {
         body,
@@ -1329,24 +2428,59 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.createSmsProvider().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createSmsProvider",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/providers`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SmsProvider().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createSmsProvider",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Sms provider id
+   * @returns {Promise<SmsProvider>} - Success response
    * @summary: Get sms provider by id
    * @description: Get sms provider by id
    */
-  getSmsProviderById({ id } = {}) {
+  async getSmsProviderById({ id } = {}) {
     const { error } = CommunicationValidator.getSmsProviderById().validate(
       {
         id,
@@ -1357,25 +2491,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getSmsProviderById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSmsProviderById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/providers/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SmsProvider().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSmsProviderById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Sms provider id
    * @param {SmsProviderReq} arg.body
+   * @returns {Promise<SmsProvider>} - Success response
    * @summary: Update sms provider by id
    * @description: Update sms provider by id
    */
-  updateSmsProviderById({ id, body } = {}) {
+  async updateSmsProviderById({ id, body } = {}) {
     const { error } = CommunicationValidator.updateSmsProviderById().validate(
       {
         id,
@@ -1387,15 +2556,50 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.updateSmsProviderById().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateSmsProviderById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/providers/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SmsProvider().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateSmsProviderById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1403,10 +2607,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<SmsTemplates>} - Success response
    * @summary: Get sms templates
    * @description: Get sms templates
    */
-  getSmsTemplates({ pageNo, pageSize, sort } = {}) {
+  async getSmsTemplates({ pageNo, pageSize, sort } = {}) {
     const { error } = CommunicationValidator.getSmsTemplates().validate(
       {
         pageNo,
@@ -1419,18 +2624,54 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getSmsTemplates().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSmsTemplates",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/templates`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SmsTemplates().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSmsTemplates",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1468,10 +2709,11 @@ class Communication {
   /**
    * @param {Object} arg - Arg object.
    * @param {SmsTemplateReq} arg.body
+   * @returns {Promise<SmsTemplateRes>} - Success response
    * @summary: Create sms template
    * @description: Create sms template
    */
-  createSmsTemplate({ body } = {}) {
+  async createSmsTemplate({ body } = {}) {
     const { error } = CommunicationValidator.createSmsTemplate().validate(
       {
         body,
@@ -1482,24 +2724,59 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.createSmsTemplate().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createSmsTemplate",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/templates`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SmsTemplateRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createSmsTemplate",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Sms template id
+   * @returns {Promise<SmsTemplate>} - Success response
    * @summary: Get sms template by id
    * @description: Get sms template by id
    */
-  getSmsTemplateById({ id } = {}) {
+  async getSmsTemplateById({ id } = {}) {
     const { error } = CommunicationValidator.getSmsTemplateById().validate(
       {
         id,
@@ -1510,25 +2787,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getSmsTemplateById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSmsTemplateById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/templates/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SmsTemplate().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSmsTemplateById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Sms template id
    * @param {SmsTemplateReq} arg.body
+   * @returns {Promise<SmsTemplateRes>} - Success response
    * @summary: Update sms template by id
    * @description: Update sms template by id
    */
-  updateSmsTemplateById({ id, body } = {}) {
+  async updateSmsTemplateById({ id, body } = {}) {
     const { error } = CommunicationValidator.updateSmsTemplateById().validate(
       {
         id,
@@ -1540,24 +2852,60 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.updateSmsTemplateById().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateSmsTemplateById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/templates/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SmsTemplateRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateSmsTemplateById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - Sms template id
+   * @returns {Promise<SmsTemplateDeleteSuccessRes>} - Success response
    * @summary: Delete sms template by id
    * @description: Delete sms template by id
    */
-  deleteSmsTemplateById({ id } = {}) {
+  async deleteSmsTemplateById({ id } = {}) {
     const { error } = CommunicationValidator.deleteSmsTemplateById().validate(
       {
         id,
@@ -1568,15 +2916,49 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.deleteSmsTemplateById().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteSmsTemplateById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/templates/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SmsTemplateDeleteSuccessRes().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteSmsTemplateById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1584,10 +2966,11 @@ class Communication {
    * @param {number} [arg.pageNo] - Current page no
    * @param {number} [arg.pageSize] - Current request items count
    * @param {Object} [arg.sort] - To sort based on created_at
+   * @returns {Promise<SystemSmsTemplates>} - Success response
    * @summary: Get system sms templates
    * @description: Get system sms templates
    */
-  getSystemSystemTemplates({ pageNo, pageSize, sort } = {}) {
+  async getSystemSystemTemplates({ pageNo, pageSize, sort } = {}) {
     const {
       error,
     } = CommunicationValidator.getSystemSystemTemplates().validate(
@@ -1602,18 +2985,54 @@ class Communication {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = CommunicationValidator.getSystemSystemTemplates().validate(
+      {
+        pageNo,
+        pageSize,
+        sort,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSystemSystemTemplates",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
     query_params["sort"] = sort;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/communication/v1.0/company/${this.config.companyId}/application/${this.applicationId}/sms/system-templates`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = CommunicationModel.SystemSmsTemplates().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSystemSystemTemplates",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**