@gofynd/fdk-client-javascript 1.0.0 → 1.0.2

package/sdk/platform/Content/ContentPlatformApplicationClient.js

@@ -2,6 +2,8 @@ const Paginator = require("../../common/Paginator");
 const PlatformAPIClient = require("../PlatformAPIClient");
 const { FDKClientValidationError } = require("../../common/FDKError");
 const ContentValidator = require("./ContentPlatformApplicationValidator");
+const ContentModel = require("./ContentPlatformModel");
+const { Logger } = require("./../../common/Logger");
 
 class Content {
   constructor(config, applicationId) {
@@ -15,10 +17,11 @@ class Content {
    *   given set of results. Default value is 1.
    * @param {number} [arg.pageSize] - The number of items to retrieve in each
    *   page. Default value is 10.
+   * @returns {Promise<GetAnnouncementListSchema>} - Success response
    * @summary: Get a list of announcements
    * @description: Announcements are useful to highlight a message or information on top of a webpage. Use this API to retrieve a list of announcements.
    */
-  getAnnouncementsList({ pageNo, pageSize } = {}) {
+  async getAnnouncementsList({ pageNo, pageSize } = {}) {
     const { error } = ContentValidator.getAnnouncementsList().validate(
       {
         pageNo,
@@ -30,17 +33,52 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.getAnnouncementsList().validate(
+      {
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAnnouncementsList",
+      });
+      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/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/announcements`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.GetAnnouncementListSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAnnouncementsList",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -79,10 +117,11 @@ class Content {
   /**
    * @param {Object} arg - Arg object.
    * @param {AdminAnnouncementSchema} arg.body
+   * @returns {Promise<CreateAnnouncementSchema>} - Success response
    * @summary: Create an announcement
    * @description: Announcements are useful to highlight a message or information on top of a webpage. Use this API to create an announcement.
    */
-  createAnnouncement({ body } = {}) {
+  async createAnnouncement({ body } = {}) {
     const { error } = ContentValidator.createAnnouncement().validate(
       {
         body,
@@ -93,24 +132,57 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.createAnnouncement().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createAnnouncement",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/announcements`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateAnnouncementSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createAnnouncement",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.announcementId - ID allotted to the announcement.
+   * @returns {Promise<AdminAnnouncementSchema>} - Success response
    * @summary: Get announcement by ID
    * @description: Use this API to retrieve an announcement and its details such as the target platform and pages on which it's applicable
    */
-  getAnnouncementById({ announcementId } = {}) {
+  async getAnnouncementById({ announcementId } = {}) {
     const { error } = ContentValidator.getAnnouncementById().validate(
       {
         announcementId,
@@ -121,25 +193,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getAnnouncementById().validate(
+      {
+        announcementId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAnnouncementById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/announcements/${announcementId}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.AdminAnnouncementSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAnnouncementById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.announcementId - ID allotted to the announcement.
    * @param {AdminAnnouncementSchema} arg.body
+   * @returns {Promise<CreateAnnouncementSchema>} - Success response
    * @summary: Update an announcement
    * @description: Use this API to edit an existing announcement and its details such as the target platform and pages on which it's applicable
    */
-  updateAnnouncement({ announcementId, body } = {}) {
+  async updateAnnouncement({ announcementId, body } = {}) {
     const { error } = ContentValidator.updateAnnouncement().validate(
       {
         announcementId,
@@ -151,25 +256,59 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updateAnnouncement().validate(
+      {
+        announcementId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateAnnouncement",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/announcements/${announcementId}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateAnnouncementSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAnnouncement",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.announcementId - ID allotted to the announcement.
    * @param {ScheduleSchema} arg.body
+   * @returns {Promise<CreateAnnouncementSchema>} - Success response
    * @summary: Update the schedule and the publish status of an announcement
    * @description: Use this API to edit the duration, i.e. start date-time and end date-time of an announcement. Moreover, you can enable/disable an announcement using this API.
    */
-  updateAnnouncementSchedule({ announcementId, body } = {}) {
+  async updateAnnouncementSchedule({ announcementId, body } = {}) {
     const { error } = ContentValidator.updateAnnouncementSchedule().validate(
       {
         announcementId,
@@ -181,24 +320,61 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.updateAnnouncementSchedule().validate(
+      {
+        announcementId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for updateAnnouncementSchedule",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "patch",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/announcements/${announcementId}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateAnnouncementSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateAnnouncementSchedule",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.announcementId - ID allotted to the announcement.
+   * @returns {Promise<CreateAnnouncementSchema>} - Success response
    * @summary: Delete announcement by id
    * @description: Use this API to delete an existing announcement.
    */
-  deleteAnnouncement({ announcementId } = {}) {
+  async deleteAnnouncement({ announcementId } = {}) {
     const { error } = ContentValidator.deleteAnnouncement().validate(
       {
         announcementId,
@@ -209,24 +385,57 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.deleteAnnouncement().validate(
+      {
+        announcementId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteAnnouncement",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/announcements/${announcementId}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateAnnouncementSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteAnnouncement",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {BlogRequest} arg.body
+   * @returns {Promise<BlogSchema>} - Success response
    * @summary: Create a blog
    * @description: Use this API to create a blog.
    */
-  createBlog({ body } = {}) {
+  async createBlog({ body } = {}) {
     const { error } = ContentValidator.createBlog().validate(
       {
         body,
@@ -237,15 +446,45 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.createBlog().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createBlog",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/blogs/`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.BlogSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createBlog",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -254,10 +493,11 @@ class Content {
    *   given set of results. Default value is 1.
    * @param {number} [arg.pageSize] - The number of items to retrieve in each
    *   page. Default value is 10.
+   * @returns {Promise<BlogGetResponse>} - Success response
    * @summary: Get blogs
    * @description: Use this API to get a list of blogs along with their details, such as the title, reading time, publish status, feature image, tags, author, etc.
    */
-  getBlogs({ pageNo, pageSize } = {}) {
+  async getBlogs({ pageNo, pageSize } = {}) {
     const { error } = ContentValidator.getBlogs().validate(
       {
         pageNo,
@@ -269,17 +509,50 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getBlogs().validate(
+      {
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getBlogs",
+      });
+      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/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/blogs/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.BlogGetResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getBlogs",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -319,10 +592,11 @@ class Content {
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to the blog.
    * @param {BlogRequest} arg.body
+   * @returns {Promise<BlogSchema>} - Success response
    * @summary: Update a blog
    * @description: Use this API to update the details of an existing blog which includes title, feature image, content, SEO details, expiry, etc.
    */
-  updateBlog({ id, body } = {}) {
+  async updateBlog({ id, body } = {}) {
     const { error } = ContentValidator.updateBlog().validate(
       {
         id,
@@ -334,24 +608,56 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updateBlog().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateBlog",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/blogs/${id}`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.BlogSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateBlog",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to the blog.
+   * @returns {Promise<BlogSchema>} - Success response
    * @summary: Delete blogs
    * @description: Use this API to delete a blog.
    */
-  deleteBlog({ id } = {}) {
+  async deleteBlog({ id } = {}) {
     const { error } = ContentValidator.deleteBlog().validate(
       {
         id,
@@ -362,25 +668,56 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.deleteBlog().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteBlog",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/blogs/${id}`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.BlogSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteBlog",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.slug - A short, human-readable, URL-friendly
    *   identifier of a blog page. You can get slug value of a blog from `getBlogs` API.
+   * @returns {Promise<BlogSchema>} - Success response
    * @summary: Get components of a blog
    * @description: Use this API to retrieve the components of a blog, such as title, slug, feature image, content, schedule, publish status, author, etc.
    */
-  getComponentById({ slug } = {}) {
+  async getComponentById({ slug } = {}) {
     const { error } = ContentValidator.getComponentById().validate(
       {
         slug,
@@ -391,24 +728,55 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getComponentById().validate(
+      {
+        slug,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getComponentById",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/blogs/${slug}`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.BlogSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getComponentById",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {DataLoaderSchema} arg.body
+   * @returns {Promise<DataLoaderResponseSchema>} - Success response
    * @summary: Adds a data loader
    * @description: Use this API to add data loader. This includes the data loader name, operationId, service name and its type (url/function) with corresponding value.
    */
-  addDataLoader({ body } = {}) {
+  async addDataLoader({ body } = {}) {
     const { error } = ContentValidator.addDataLoader().validate(
       {
         body,
@@ -419,23 +787,56 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.addDataLoader().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for addDataLoader",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/data-loader`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.DataLoaderResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for addDataLoader",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<DataLoadersSchema>} - Success response
    * @summary: Get all the data loaders in an application
    * @description: Use this to get all data loaders of an application
    */
-  getDataLoaders({} = {}) {
+  async getDataLoaders({} = {}) {
     const { error } = ContentValidator.getDataLoaders().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -444,24 +845,55 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getDataLoaders().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getDataLoaders",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/data-loader`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.DataLoadersSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getDataLoaders",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.dataLoaderId - ID allotted to the data loader.
+   * @returns {Promise<DataLoaderResponseSchema>} - Success response
    * @summary: Delete data loader in application
    * @description: Use this API to delete data loader.
    */
-  deleteDataLoader({ dataLoaderId } = {}) {
+  async deleteDataLoader({ dataLoaderId } = {}) {
     const { error } = ContentValidator.deleteDataLoader().validate(
       {
         dataLoaderId,
@@ -472,25 +904,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.deleteDataLoader().validate(
+      {
+        dataLoaderId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteDataLoader",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/data-loader/${dataLoaderId}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.DataLoaderResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteDataLoader",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.dataLoaderId - ID allotted to the data loader.
    * @param {DataLoaderSchema} arg.body
+   * @returns {Promise<DataLoaderResponseSchema>} - Success response
    * @summary: Edit a data loader by id
    * @description: Use this API to edit the details of an existing data loader by its ID.
    */
-  editDataLoader({ dataLoaderId, body } = {}) {
+  async editDataLoader({ dataLoaderId, body } = {}) {
     const { error } = ContentValidator.editDataLoader().validate(
       {
         dataLoaderId,
@@ -502,24 +967,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.editDataLoader().validate(
+      {
+        dataLoaderId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for editDataLoader",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/data-loader/${dataLoaderId}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.DataLoaderResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for editDataLoader",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.dataLoaderId - ID allotted to the data loader.
+   * @returns {Promise<DataLoaderResponseSchema>} - Success response
    * @summary: Select a data loader by id
    * @description: Use this API to select a data loader to be used in applications.
    */
-  selectDataLoader({ dataLoaderId } = {}) {
+  async selectDataLoader({ dataLoaderId } = {}) {
     const { error } = ContentValidator.selectDataLoader().validate(
       {
         dataLoaderId,
@@ -530,25 +1029,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.selectDataLoader().validate(
+      {
+        dataLoaderId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for selectDataLoader",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/data-loader/${dataLoaderId}/select`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.DataLoaderResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for selectDataLoader",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.service - Name of service.
    * @param {string} arg.operationId - Name of operation id of the service.
+   * @returns {Promise<DataLoaderResetResponseSchema>} - Success response
    * @summary: Reset a data loader by serive name and operation Id
    * @description: Use this API to reselect a data loader.
    */
-  resetDataLoader({ service, operationId } = {}) {
+  async resetDataLoader({ service, operationId } = {}) {
     const { error } = ContentValidator.resetDataLoader().validate(
       {
         service,
@@ -560,23 +1092,57 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.resetDataLoader().validate(
+      {
+        service,
+        operationId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for resetDataLoader",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/data-loader/${service}/${operationId}/reset`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.DataLoaderResetResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for resetDataLoader",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<GetFaqCategoriesSchema>} - Success response
    * @summary: Get a list of FAQ categories
    * @description: FAQs can be divided into categories. Use this API to get a list of FAQ categories.
    */
-  getFaqCategories({} = {}) {
+  async getFaqCategories({} = {}) {
     const { error } = ContentValidator.getFaqCategories().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -585,15 +1151,45 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getFaqCategories().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getFaqCategories",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/categories`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.GetFaqCategoriesSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getFaqCategories",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -602,10 +1198,11 @@ class Content {
    *   category. Slug is a short, human-readable, URL-friendly identifier of
    *   an object. You can get slug value of an FAQ category from
    *   `getFaqCategories` API.
+   * @returns {Promise<GetFaqCategoryBySlugSchema>} - Success response
    * @summary: Get an FAQ category by slug or id
    * @description: FAQs can be divided into categories. Use this API to get an FAQ categories using its slug or ID.
    */
-  getFaqCategoryBySlugOrId({ idOrSlug } = {}) {
+  async getFaqCategoryBySlugOrId({ idOrSlug } = {}) {
     const { error } = ContentValidator.getFaqCategoryBySlugOrId().validate(
       {
         idOrSlug,
@@ -616,24 +1213,59 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.getFaqCategoryBySlugOrId().validate(
+      {
+        idOrSlug,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getFaqCategoryBySlugOrId",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/category/${idOrSlug}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.GetFaqCategoryBySlugSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getFaqCategoryBySlugOrId",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {CreateFaqCategoryRequestSchema} arg.body
+   * @returns {Promise<CreateFaqCategorySchema>} - Success response
    * @summary: Create an FAQ category
    * @description: FAQs help users to solve an issue or know more about a process. FAQs can be categorized separately, for e.g. some questions can be related to payment, some could be related to purchase, shipping, navigating, etc. Use this API to create an FAQ category.
    */
-  createFaqCategory({ body } = {}) {
+  async createFaqCategory({ body } = {}) {
     const { error } = ContentValidator.createFaqCategory().validate(
       {
         body,
@@ -644,25 +1276,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.createFaqCategory().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createFaqCategory",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/category`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateFaqCategorySchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createFaqCategory",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to an FAQ category.
    * @param {UpdateFaqCategoryRequestSchema} arg.body
+   * @returns {Promise<CreateFaqCategorySchema>} - Success response
    * @summary: Update an FAQ category
    * @description: Use this API to edit an existing FAQ category.
    */
-  updateFaqCategory({ id, body } = {}) {
+  async updateFaqCategory({ id, body } = {}) {
     const { error } = ContentValidator.updateFaqCategory().validate(
       {
         id,
@@ -674,24 +1339,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updateFaqCategory().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateFaqCategory",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/category/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateFaqCategorySchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateFaqCategory",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to an FAQ category.
+   * @returns {Promise<FaqSchema>} - Success response
    * @summary: Delete an FAQ category
    * @description: Use this API to delete an FAQ category.
    */
-  deleteFaqCategory({ id } = {}) {
+  async deleteFaqCategory({ id } = {}) {
     const { error } = ContentValidator.deleteFaqCategory().validate(
       {
         id,
@@ -702,15 +1401,45 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.deleteFaqCategory().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteFaqCategory",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/category/${id}`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.FaqSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteFaqCategory",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -719,10 +1448,11 @@ class Content {
    *   category. Slug is a short, human-readable, URL-friendly identifier of
    *   an object. You can get slug value of an FAQ category from
    *   `getFaqCategories` API.
+   * @returns {Promise<GetFaqSchema>} - Success response
    * @summary: Get question and answers within an FAQ category
    * @description: Use this API to retrieve all the commonly asked question and answers belonging to an FAQ category.
    */
-  getFaqsByCategoryIdOrSlug({ idOrSlug } = {}) {
+  async getFaqsByCategoryIdOrSlug({ idOrSlug } = {}) {
     const { error } = ContentValidator.getFaqsByCategoryIdOrSlug().validate(
       {
         idOrSlug,
@@ -733,25 +1463,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.getFaqsByCategoryIdOrSlug().validate(
+      {
+        idOrSlug,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getFaqsByCategoryIdOrSlug",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/category/${idOrSlug}/faqs`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.GetFaqSchema().validate(
+      response,
+      { abortEarly: false, allowUnknown: false }
+    );
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getFaqsByCategoryIdOrSlug",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.categoryId - ID allotted to an FAQ category.
    * @param {CreateFaqSchema} arg.body
+   * @returns {Promise<CreateFaqResponseSchema>} - Success response
    * @summary: Create an FAQ
    * @description: FAQs help users to solve an issue or know more about a process. Use this API to create an FAQ for a given FAQ category.
    */
-  addFaq({ categoryId, body } = {}) {
+  async addFaq({ categoryId, body } = {}) {
     const { error } = ContentValidator.addFaq().validate(
       {
         categoryId,
@@ -763,15 +1526,48 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.addFaq().validate(
+      {
+        categoryId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for addFaq",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/category/${categoryId}/faqs`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateFaqResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for addFaq",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -779,10 +1575,11 @@ class Content {
    * @param {string} arg.categoryId - ID allotted to an FAQ category.
    * @param {string} arg.faqId - ID allotted to an FAQ.
    * @param {CreateFaqSchema} arg.body
+   * @returns {Promise<CreateFaqResponseSchema>} - Success response
    * @summary: Update an FAQ
    * @description: Use this API to edit an existing FAQ.
    */
-  updateFaq({ categoryId, faqId, body } = {}) {
+  async updateFaq({ categoryId, faqId, body } = {}) {
     const { error } = ContentValidator.updateFaq().validate(
       {
         categoryId,
@@ -795,25 +1592,60 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updateFaq().validate(
+      {
+        categoryId,
+        faqId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateFaq",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/category/${categoryId}/faq/${faqId}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateFaqResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateFaq",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.categoryId - ID allotted to an FAQ category.
    * @param {string} arg.faqId - ID allotted to an FAQ.
+   * @returns {Promise<CreateFaqResponseSchema>} - Success response
    * @summary: Delete an FAQ
    * @description: Use this API to delete an existing FAQ.
    */
-  deleteFaq({ categoryId, faqId } = {}) {
+  async deleteFaq({ categoryId, faqId } = {}) {
     const { error } = ContentValidator.deleteFaq().validate(
       {
         categoryId,
@@ -825,15 +1657,48 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.deleteFaq().validate(
+      {
+        categoryId,
+        faqId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteFaq",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/category/${categoryId}/faq/${faqId}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateFaqResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteFaq",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -842,13 +1707,78 @@ class Content {
    *   category. Slug is a short, human-readable, URL-friendly identifier of
    *   an object. You can get slug value of an FAQ category from
    *   `getFaqCategories` API.
+   * @returns {Promise<CreateFaqResponseSchema>} - Success response
    * @summary: Get an FAQ
    * @description: Use this API to retrieve a specific FAQ. You will get the question and answer of that FAQ.
    */
-  getFaqByIdOrSlug({ idOrSlug } = {}) {
+  async getFaqByIdOrSlug({ idOrSlug } = {}) {
     const { error } = ContentValidator.getFaqByIdOrSlug().validate(
       {
-        idOrSlug,
+        idOrSlug,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getFaqByIdOrSlug().validate(
+      {
+        idOrSlug,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getFaqByIdOrSlug",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/${idOrSlug}`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = ContentModel.CreateFaqResponseSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getFaqByIdOrSlug",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {GenerationEntityType} arg.type - String representing the type of
+   *   SEO content to be generated. Possible values are: title, description
+   * @param {GenerateSEOContent} arg.body
+   * @returns {Promise<GeneratedSEOContent>} - Success response
+   * @summary: Get SEO meta tag title for content
+   * @description: Use this API to get GPT3 generated SEO meta tag title for content
+   */
+  async generateSEOTitle({ type, body } = {}) {
+    const { error } = ContentValidator.generateSEOTitle().validate(
+      {
+        type,
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -856,15 +1786,48 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.generateSEOTitle().validate(
+      {
+        type,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for generateSEOTitle",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
-      `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/faq/${idOrSlug}`,
+      "post",
+      `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/generate-seo/${type}`,
       query_params,
-      undefined
+      body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.GeneratedSEOContent().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for generateSEOTitle",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -873,10 +1836,11 @@ class Content {
    *   given set of results. Default value is 1.
    * @param {number} [arg.pageSize] - The number of items to retrieve in each
    *   page. Default value is 10.
+   * @returns {Promise<LandingPageGetResponse>} - Success response
    * @summary: Get landing pages
    * @description: Landing page is the first page that a prospect lands upon while visiting a website. Use this API to fetch a list of landing pages.
    */
-  getLandingPages({ pageNo, pageSize } = {}) {
+  async getLandingPages({ pageNo, pageSize } = {}) {
     const { error } = ContentValidator.getLandingPages().validate(
       {
         pageNo,
@@ -888,17 +1852,50 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getLandingPages().validate(
+      {
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getLandingPages",
+      });
+      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/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/landing-page/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.LandingPageGetResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getLandingPages",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -937,10 +1934,11 @@ class Content {
   /**
    * @param {Object} arg - Arg object.
    * @param {LandingPageSchema} arg.body
+   * @returns {Promise<LandingPageSchema>} - Success response
    * @summary: Create a landing page
    * @description: Landing page is the first page that a prospect lands upon while visiting a website. Use this API to create a landing page.
    */
-  createLandingPage({ body } = {}) {
+  async createLandingPage({ body } = {}) {
     const { error } = ContentValidator.createLandingPage().validate(
       {
         body,
@@ -951,25 +1949,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.createLandingPage().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createLandingPage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/landing-page/`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.LandingPageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createLandingPage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to a landing page.
    * @param {LandingPageSchema} arg.body
+   * @returns {Promise<LandingPageSchema>} - Success response
    * @summary: Update a landing page
    * @description: Use this API to edit the details of an existing landing page.
    */
-  updateLandingPage({ id, body } = {}) {
+  async updateLandingPage({ id, body } = {}) {
     const { error } = ContentValidator.updateLandingPage().validate(
       {
         id,
@@ -981,24 +2012,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updateLandingPage().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateLandingPage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/landing-page/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.LandingPageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateLandingPage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to a landing page.
+   * @returns {Promise<LandingPageSchema>} - Success response
    * @summary: Delete a landing page
    * @description: Use this API to delete an existing landing page.
    */
-  deleteLandingPage({ id } = {}) {
+  async deleteLandingPage({ id } = {}) {
     const { error } = ContentValidator.deleteLandingPage().validate(
       {
         id,
@@ -1009,23 +2074,56 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.deleteLandingPage().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteLandingPage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/landing-page/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.LandingPageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteLandingPage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<ApplicationLegal>} - Success response
    * @summary: Get legal information
    * @description: Use this API to get the legal information of an application, which includes Policy, Terms and Conditions, Shipping Policy and FAQ regarding the application.
    */
-  getLegalInformation({} = {}) {
+  async getLegalInformation({} = {}) {
     const { error } = ContentValidator.getLegalInformation().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -1034,24 +2132,55 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getLegalInformation().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getLegalInformation",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/legal`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.ApplicationLegal().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getLegalInformation",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {ApplicationLegal} arg.body
+   * @returns {Promise<ApplicationLegal>} - Success response
    * @summary: Save legal information
    * @description: Use this API to edit, update and save the legal information of an application, which includes Policy, Terms and Conditions, Shipping Policy and FAQ regarding the application.
    */
-  updateLegalInformation({ body } = {}) {
+  async updateLegalInformation({ body } = {}) {
     const { error } = ContentValidator.updateLegalInformation().validate(
       {
         body,
@@ -1062,15 +2191,49 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.updateLegalInformation().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateLegalInformation",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/legal`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.ApplicationLegal().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateLegalInformation",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1081,10 +2244,11 @@ class Content {
    *   given set of results. Default value is 1.
    * @param {number} [arg.pageSize] - The number of items to retrieve in each
    *   page. Default value is 10.
+   * @returns {Promise<NavigationGetResponse>} - Success response
    * @summary: Get navigations
    * @description: Use this API to fetch the navigations details which includes the items of the navigation pane. It also shows the orientation, links, sub-navigations, etc.
    */
-  getNavigations({ devicePlatform, pageNo, pageSize } = {}) {
+  async getNavigations({ devicePlatform, pageNo, pageSize } = {}) {
     const { error } = ContentValidator.getNavigations().validate(
       {
         devicePlatform,
@@ -1097,18 +2261,52 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getNavigations().validate(
+      {
+        devicePlatform,
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getNavigations",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["device_platform"] = devicePlatform;
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/navigations/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.NavigationGetResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getNavigations",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1155,10 +2353,11 @@ class Content {
   /**
    * @param {Object} arg - Arg object.
    * @param {NavigationRequest} arg.body
+   * @returns {Promise<NavigationSchema>} - Success response
    * @summary: Create a navigation
    * @description: Navigation is the arrangement of navigational items to ease the accessibility of resources for users on a website. Use this API to create a navigation.
    */
-  createNavigation({ body } = {}) {
+  async createNavigation({ body } = {}) {
     const { error } = ContentValidator.createNavigation().validate(
       {
         body,
@@ -1169,23 +2368,56 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.createNavigation().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createNavigation",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/navigations/`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.NavigationSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createNavigation",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<DefaultNavigationResponse>} - Success response
    * @summary: Get default navigations
    * @description: On any website (application), there are navigations that are present by default. Use this API to retrieve those default navigations.
    */
-  getDefaultNavigations({} = {}) {
+  async getDefaultNavigations({} = {}) {
     const { error } = ContentValidator.getDefaultNavigations().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -1194,15 +2426,47 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.getDefaultNavigations().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getDefaultNavigations",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/navigations/default`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.DefaultNavigationResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getDefaultNavigations",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1212,10 +2476,11 @@ class Content {
    *   `getNavigations` API.
    * @param {string} arg.devicePlatform - Filter navigations by platform.
    *   Acceptable values are: web, android, ios, all
+   * @returns {Promise<NavigationSchema>} - Success response
    * @summary: Get a navigation by slug
    * @description: Use this API to retrieve a navigation by its slug.
    */
-  getNavigationBySlug({ slug, devicePlatform } = {}) {
+  async getNavigationBySlug({ slug, devicePlatform } = {}) {
     const { error } = ContentValidator.getNavigationBySlug().validate(
       {
         slug,
@@ -1227,26 +2492,60 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getNavigationBySlug().validate(
+      {
+        slug,
+        devicePlatform,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getNavigationBySlug",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["device_platform"] = devicePlatform;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/navigations/${slug}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.NavigationSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getNavigationBySlug",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to the navigation.
    * @param {NavigationRequest} arg.body
+   * @returns {Promise<NavigationSchema>} - Success response
    * @summary: Update a navigation
    * @description: Use this API to edit the details of an existing navigation.
    */
-  updateNavigation({ id, body } = {}) {
+  async updateNavigation({ id, body } = {}) {
     const { error } = ContentValidator.updateNavigation().validate(
       {
         id,
@@ -1258,24 +2557,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updateNavigation().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateNavigation",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/navigations/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.NavigationSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateNavigation",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to the navigation.
+   * @returns {Promise<NavigationSchema>} - Success response
    * @summary: Delete a navigation
    * @description: Use this API to delete an existing navigation.
    */
-  deleteNavigation({ id } = {}) {
+  async deleteNavigation({ id } = {}) {
     const { error } = ContentValidator.deleteNavigation().validate(
       {
         id,
@@ -1286,23 +2619,56 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.deleteNavigation().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteNavigation",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/navigations/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.NavigationSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteNavigation",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<PageMetaSchema>} - Success response
    * @summary: Get page meta
    * @description: Use this API to get the meta of custom pages (blog, page) and default system pages (e.g. home/brand/category/collection).
    */
-  getPageMeta({} = {}) {
+  async getPageMeta({} = {}) {
     const { error } = ContentValidator.getPageMeta().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -1311,23 +2677,54 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getPageMeta().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPageMeta",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/pages/meta`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.PageMetaSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPageMeta",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<PageSpec>} - Success response
    * @summary: Get page spec
    * @description: Use this API to get the specifications of a page, such as page type, display name, params and query.
    */
-  getPageSpec({} = {}) {
+  async getPageSpec({} = {}) {
     const { error } = ContentValidator.getPageSpec().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -1336,24 +2733,53 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getPageSpec().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPageSpec",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/pages/spec`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.PageSpec().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPageSpec",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {PageRequest} arg.body
+   * @returns {Promise<PageSchema>} - Success response
    * @summary: Create a page preview
    * @description: Use this API to create a page preview to check the appearance of a custom page.
    */
-  createPagePreview({ body } = {}) {
+  async createPagePreview({ body } = {}) {
     const { error } = ContentValidator.createPagePreview().validate(
       {
         body,
@@ -1364,15 +2790,45 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.createPagePreview().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createPagePreview",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/pages/preview/`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.PageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createPagePreview",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1380,10 +2836,11 @@ class Content {
    * @param {string} arg.slug - A short, human-readable, URL-friendly
    *   identifier of a page. You can get slug value of a page from `getPages` API.
    * @param {PagePublishRequest} arg.body
+   * @returns {Promise<PageSchema>} - Success response
    * @summary: Change the publish status of a page
    * @description: Use this API to change the publish status of an existing page. Allows you to publish and unpublish the page.
    */
-  updatePagePreview({ slug, body } = {}) {
+  async updatePagePreview({ slug, body } = {}) {
     const { error } = ContentValidator.updatePagePreview().validate(
       {
         slug,
@@ -1395,24 +2852,56 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updatePagePreview().validate(
+      {
+        slug,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updatePagePreview",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/pages/publish/${slug}`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.PageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updatePagePreview",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to the page.
+   * @returns {Promise<PageSchema>} - Success response
    * @summary: Delete a page
    * @description: Use this API to delete an existing page.
    */
-  deletePage({ id } = {}) {
+  async deletePage({ id } = {}) {
     const { error } = ContentValidator.deletePage().validate(
       {
         id,
@@ -1423,24 +2912,55 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.deletePage().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deletePage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/pages/${id}`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.PageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deletePage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {PathMappingSchema} arg.body
+   * @returns {Promise<PathMappingSchema>} - Success response
    * @summary: Save path based redirection rules
    * @description: Use this API to add redirection rules
    */
-  addPathRedirectionRules({ body } = {}) {
+  async addPathRedirectionRules({ body } = {}) {
     const { error } = ContentValidator.addPathRedirectionRules().validate(
       {
         body,
@@ -1451,15 +2971,49 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.addPathRedirectionRules().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for addPathRedirectionRules",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/path-mappings`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.PathMappingSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for addPathRedirectionRules",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1468,10 +3022,11 @@ class Content {
    *   page. Default value is 5.
    * @param {number} [arg.pageNo] - The page number to navigate through the
    *   given set of results. Default value is 1.
+   * @returns {Promise<PathMappingSchema>} - Success response
    * @summary: Get path based redirection rules
    * @description: Use this API to get path based redirection rules.
    */
-  getPathRedirectionRules({ pageSize, pageNo } = {}) {
+  async getPathRedirectionRules({ pageSize, pageNo } = {}) {
     const { error } = ContentValidator.getPathRedirectionRules().validate(
       {
         pageSize,
@@ -1483,26 +3038,62 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.getPathRedirectionRules().validate(
+      {
+        pageSize,
+        pageNo,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPathRedirectionRules",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["page_size"] = pageSize;
     query_params["page_no"] = pageNo;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/path-mappings`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.PathMappingSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPathRedirectionRules",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.pathId - ID allotted to the path redirection rule.
+   * @returns {Promise<PathMappingSchema>} - Success response
    * @summary: Get path based redirection rule
    * @description: Use this API to get path based redirection rule.
    */
-  getPathRedirectionRule({ pathId } = {}) {
+  async getPathRedirectionRule({ pathId } = {}) {
     const { error } = ContentValidator.getPathRedirectionRule().validate(
       {
         pathId,
@@ -1513,25 +3104,60 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.getPathRedirectionRule().validate(
+      {
+        pathId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPathRedirectionRule",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/path-mappings/${pathId}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.PathMappingSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPathRedirectionRule",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.pathId - ID allotted to the path redirection rule.
    * @param {PathMappingSchema} arg.body
+   * @returns {Promise<PathMappingSchema>} - Success response
    * @summary: Update path based redirection rules
    * @description: Use this API to update redirection rules
    */
-  updatePathRedirectionRules({ pathId, body } = {}) {
+  async updatePathRedirectionRules({ pathId, body } = {}) {
     const { error } = ContentValidator.updatePathRedirectionRules().validate(
       {
         pathId,
@@ -1543,24 +3169,61 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.updatePathRedirectionRules().validate(
+      {
+        pathId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for updatePathRedirectionRules",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/path-mappings/${pathId}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.PathMappingSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updatePathRedirectionRules",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.pathId - ID allotted to the path redirection rule.
+   * @returns {Promise<Object>} - Success response
    * @summary: Delete path based redirection rules
    * @description: Use this API to delete redirection rules
    */
-  deletePathRedirectionRules({ pathId } = {}) {
+  async deletePathRedirectionRules({ pathId } = {}) {
     const { error } = ContentValidator.deletePathRedirectionRules().validate(
       {
         pathId,
@@ -1571,23 +3234,57 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.deletePathRedirectionRules().validate(
+      {
+        pathId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for deletePathRedirectionRules",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/path-mappings/${pathId}`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = Joi.any().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deletePathRedirectionRules",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<SeoComponent>} - Success response
    * @summary: Get SEO configuration of an application
    * @description: Use this API to know how the SEO is configured in the application. This includes the sitemap, robot.txt, custom meta tags, etc.
    */
-  getSEOConfiguration({} = {}) {
+  async getSEOConfiguration({} = {}) {
     const { error } = ContentValidator.getSEOConfiguration().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -1596,24 +3293,53 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getSEOConfiguration().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSEOConfiguration",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/seo`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.SeoComponent().validate(
+      response,
+      { abortEarly: false, allowUnknown: false }
+    );
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSEOConfiguration",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {SeoComponent} arg.body
+   * @returns {Promise<SeoSchema>} - Success response
    * @summary: Update SEO of application
    * @description: Use this API to edit the SEO details of an application. This includes the sitemap, robot.txt, custom meta tags, etc.
    */
-  updateSEOConfiguration({ body } = {}) {
+  async updateSEOConfiguration({ body } = {}) {
     const { error } = ContentValidator.updateSEOConfiguration().validate(
       {
         body,
@@ -1624,15 +3350,47 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.updateSEOConfiguration().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateSEOConfiguration",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/seo`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.SeoSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateSEOConfiguration",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1643,10 +3401,11 @@ class Content {
    *   given set of results. Default value is 1.
    * @param {number} [arg.pageSize] - The number of items to retrieve in each
    *   page. Default value is 10.
+   * @returns {Promise<SlideshowGetResponse>} - Success response
    * @summary: Get slideshows
    * @description: A slideshow is a group of images, videos or a combination of both that are shown on the website in the form of slides. Use this API to fetch a list of slideshows.
    */
-  getSlideshows({ devicePlatform, pageNo, pageSize } = {}) {
+  async getSlideshows({ devicePlatform, pageNo, pageSize } = {}) {
     const { error } = ContentValidator.getSlideshows().validate(
       {
         devicePlatform,
@@ -1659,18 +3418,52 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getSlideshows().validate(
+      {
+        devicePlatform,
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSlideshows",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["device_platform"] = devicePlatform;
     query_params["page_no"] = pageNo;
     query_params["page_size"] = pageSize;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/slideshows/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.SlideshowGetResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSlideshows",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1717,10 +3510,11 @@ class Content {
   /**
    * @param {Object} arg - Arg object.
    * @param {SlideshowRequest} arg.body
+   * @returns {Promise<SlideshowSchema>} - Success response
    * @summary: Create a slideshow
    * @description: A slideshow is a group of images, videos or a combination of both that are shown on the website in the form of slides. Use this API to create a slideshow.
    */
-  createSlideshow({ body } = {}) {
+  async createSlideshow({ body } = {}) {
     const { error } = ContentValidator.createSlideshow().validate(
       {
         body,
@@ -1731,15 +3525,47 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.createSlideshow().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createSlideshow",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/slideshows/`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.SlideshowSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createSlideshow",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -1749,10 +3575,11 @@ class Content {
    *   `getSlideshows` API.
    * @param {string} arg.devicePlatform - Filter slideshows by platform.
    *   Acceptable values are: web, android, ios and all
+   * @returns {Promise<SlideshowSchema>} - Success response
    * @summary: Get slideshow by slug
    * @description: Use this API to retrieve the details of a slideshow by its slug.
    */
-  getSlideshowBySlug({ slug, devicePlatform } = {}) {
+  async getSlideshowBySlug({ slug, devicePlatform } = {}) {
     const { error } = ContentValidator.getSlideshowBySlug().validate(
       {
         slug,
@@ -1764,26 +3591,60 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getSlideshowBySlug().validate(
+      {
+        slug,
+        devicePlatform,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSlideshowBySlug",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["device_platform"] = devicePlatform;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/slideshows/${slug}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.SlideshowSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSlideshowBySlug",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to the slideshow.
    * @param {SlideshowRequest} arg.body
+   * @returns {Promise<SlideshowSchema>} - Success response
    * @summary: Update a slideshow
    * @description: Use this API to edit the details of an existing slideshow.
    */
-  updateSlideshow({ id, body } = {}) {
+  async updateSlideshow({ id, body } = {}) {
     const { error } = ContentValidator.updateSlideshow().validate(
       {
         id,
@@ -1795,24 +3656,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updateSlideshow().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateSlideshow",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/slideshows/${id}`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.SlideshowSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateSlideshow",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to the slideshow.
+   * @returns {Promise<SlideshowSchema>} - Success response
    * @summary: Delete a slideshow
    * @description: Use this API to delete an existing slideshow.
    */
-  deleteSlideshow({ id } = {}) {
+  async deleteSlideshow({ id } = {}) {
     const { error } = ContentValidator.deleteSlideshow().validate(
       {
         id,
@@ -1823,23 +3718,56 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.deleteSlideshow().validate(
+      {
+        id,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteSlideshow",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/slideshows/${id}`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.SlideshowSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteSlideshow",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<Support>} - Success response
    * @summary: Get support information
    * @description: Use this API to get the contact details for customer support, including emails and phone numbers.
    */
-  getSupportInformation({} = {}) {
+  async getSupportInformation({} = {}) {
     const { error } = ContentValidator.getSupportInformation().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -1848,24 +3776,55 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.getSupportInformation().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getSupportInformation",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/support`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.Support().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getSupportInformation",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {Support} arg.body
+   * @returns {Promise<Support>} - Success response
    * @summary: Update the support data of an application
    * @description: Use this API to edit the existing contact details for customer support, including emails and phone numbers.
    */
-  updateSupportInformation({ body } = {}) {
+  async updateSupportInformation({ body } = {}) {
     const { error } = ContentValidator.updateSupportInformation().validate(
       {
         body,
@@ -1876,24 +3835,57 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.updateSupportInformation().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateSupportInformation",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/support`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.Support().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateSupportInformation",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {CreateTagRequestSchema} arg.body
+   * @returns {Promise<TagsSchema>} - Success response
    * @summary: Update a tag
    * @description: Use this API to edit the details of an existing tag. This includes the tag name, tag type (css/js), url and position of the tag.
    */
-  updateInjectableTag({ body } = {}) {
+  async updateInjectableTag({ body } = {}) {
     const { error } = ContentValidator.updateInjectableTag().validate(
       {
         body,
@@ -1904,23 +3896,54 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updateInjectableTag().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateInjectableTag",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/tags`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.TagsSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateInjectableTag",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<TagsSchema>} - Success response
    * @summary: Delete tags in application
    * @description: Use this API to delete all the existing tags at once.
    */
-  deleteAllInjectableTags({} = {}) {
+  async deleteAllInjectableTags({} = {}) {
     const { error } = ContentValidator.deleteAllInjectableTags().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -1929,23 +3952,54 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = ContentValidator.deleteAllInjectableTags().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteAllInjectableTags",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "delete",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/tags`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.TagsSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteAllInjectableTags",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<TagsSchema>} - Success response
    * @summary: Get all the tags in an application
    * @description: Use this API to get all the CSS and JS injected in the application in the form of tags.
    */
-  getInjectableTags({} = {}) {
+  async getInjectableTags({} = {}) {
     const { error } = ContentValidator.getInjectableTags().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -1954,24 +4008,53 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getInjectableTags().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getInjectableTags",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/tags`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.TagsSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getInjectableTags",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {CreateTagRequestSchema} arg.body
+   * @returns {Promise<TagsSchema>} - Success response
    * @summary: Add a tag
    * @description: CSS and JS can be injected in the application (website) with the help of tags. Use this API to create such tags by entering the tag name, tag type (css/js), url and position of the tag.
    */
-  addInjectableTag({ body } = {}) {
+  async addInjectableTag({ body } = {}) {
     const { error } = ContentValidator.addInjectableTag().validate(
       {
         body,
@@ -1982,24 +4065,55 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.addInjectableTag().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for addInjectableTag",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/tags/add`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.TagsSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for addInjectableTag",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {RemoveHandpickedSchema} arg.body
+   * @returns {Promise<TagDeleteSuccessResponse>} - Success response
    * @summary: Remove a tag
    * @description: Use this API to delete an existing tag.
    */
-  removeInjectableTag({ body } = {}) {
+  async removeInjectableTag({ body } = {}) {
     const { error } = ContentValidator.removeInjectableTag().validate(
       {
         body,
@@ -2010,25 +4124,58 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.removeInjectableTag().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for removeInjectableTag",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/tags/remove/handpicked`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.TagDeleteSuccessResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for removeInjectableTag",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.tagId - ID allotted to the tag.
    * @param {UpdateHandpickedSchema} arg.body
+   * @returns {Promise<TagsSchema>} - Success response
    * @summary: Edit a tag by id
    * @description: Use this API to edit the details of an existing tag by its ID.
    */
-  editInjectableTag({ tagId, body } = {}) {
+  async editInjectableTag({ tagId, body } = {}) {
     const { error } = ContentValidator.editInjectableTag().validate(
       {
         tagId,
@@ -2040,24 +4187,56 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.editInjectableTag().validate(
+      {
+        tagId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for editInjectableTag",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v1.0/company/${this.config.companyId}/application/${this.applicationId}/tags/edit/handpicked/${tagId}`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.TagsSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for editInjectableTag",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {PageRequest} arg.body
+   * @returns {Promise<PageSchema>} - Success response
    * @summary: Create a page
    * @description: Use this API to create a custom page using a title, seo, publish status, feature image, tags, meta, etc.
    */
-  createPage({ body } = {}) {
+  async createPage({ body } = {}) {
     const { error } = ContentValidator.createPage().validate(
       {
         body,
@@ -2068,15 +4247,45 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.createPage().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createPage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/content/v2.0/company/${this.config.companyId}/application/${this.applicationId}/pages/`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.PageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createPage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -2085,10 +4294,11 @@ class Content {
    *   given set of results. Default value is 1.
    * @param {number} [arg.pageSize] - The number of items to retrieve in each
    *   page. Default value is 10.
+   * @returns {Promise<PageGetResponse>} - Success response
    * @summary: Get a list of pages
    * @description: Use this API to retrieve a list of pages.
    */
-  getPages({ pageNo, pageSize } = {}) {
+  async getPages({ pageNo, pageSize } = {}) {
     const { error } = ContentValidator.getPages().validate(
       {
         pageNo,
@@ -2100,17 +4310,50 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getPages().validate(
+      {
+        pageNo,
+        pageSize,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPages",
+      });
+      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/content/v2.0/company/${this.config.companyId}/application/${this.applicationId}/pages/`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = ContentModel.PageGetResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPages",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
@@ -2150,10 +4393,11 @@ class Content {
    * @param {Object} arg - Arg object.
    * @param {string} arg.id - ID allotted to the page.
    * @param {PageSchema} arg.body
+   * @returns {Promise<PageSchema>} - Success response
    * @summary: Update a page
    * @description: Use this API to edit the details of an existing page, such as its title, seo, publish status, feature image, tags, schedule, etc.
    */
-  updatePage({ id, body } = {}) {
+  async updatePage({ id, body } = {}) {
     const { error } = ContentValidator.updatePage().validate(
       {
         id,
@@ -2165,25 +4409,57 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.updatePage().validate(
+      {
+        id,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updatePage",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/content/v2.0/company/${this.config.companyId}/application/${this.applicationId}/pages/${id}`,
       query_params,
       body
     );
+
+    const { error: res_error } = ContentModel.PageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updatePage",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.slug - A short, human-readable, URL-friendly
    *   identifier of a page. You can get slug value of a page from `getPages` API.
+   * @returns {Promise<PageSchema>} - Success response
    * @summary: Get pages by component Id
    * @description: Use this API to retrieve the components of a page, such as its title, seo, publish status, feature image, tags, schedule, etc.
    */
-  getPageBySlug({ slug } = {}) {
+  async getPageBySlug({ slug } = {}) {
     const { error } = ContentValidator.getPageBySlug().validate(
       {
         slug,
@@ -2194,15 +4470,45 @@ class Content {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = ContentValidator.getPageBySlug().validate(
+      {
+        slug,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPageBySlug",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/content/v2.0/company/${this.config.companyId}/application/${this.applicationId}/pages/${slug}`,
       query_params,
       undefined
     );
+
+    const { error: res_error } = ContentModel.PageSchema().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPageBySlug",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 }
 module.exports = Content;