boldsign 1.0.3 → 2.0.0

package/tests/integration/TemplateApiTest.spec.ts

@@ -0,0 +1,1420 @@
+import { TemplateApi } from '../../api/templateApi';
+import { BrandingApi } from '../../api/brandingApi'; 
+import { CreateTemplateRequest, DocumentCC, EditTemplateRequest, EmbeddedCreateTemplateRequest, EmbeddedSendTemplateFormRequest, EmbeddedTemplateEditRequest, FormField, ImageInfo, MergeAndSendForSignForm, PhoneNumber, Rectangle, ReminderSettings, Role, SendForSignFromTemplateForm, TemplateRole, TemplateTag, EmbeddedMergeTemplateFormRequest, AuthenticationSettings } from '../../model';
+import * as fs from 'fs';
+import config from '../config';
+
+describe('Template API Test suite', () => {
+  let brandingApi;
+  let templateApi;
+  let brandId;
+  let createdTemplateId;
+  let createdTemplateId1;
+  let createdTemplateId2;
+  let createdTemplateId3;
+  let createdTemplateId4;
+
+  beforeAll(() => {
+    brandId = null;
+    createdTemplateId = null;
+    createdTemplateId1 = null;
+    createdTemplateId2 = null;
+    createdTemplateId3 = null;
+    createdTemplateId4 =null;
+    const apiKey = config.apiKey;
+    const baseUrl = config.baseUrl;
+    if (!baseUrl || !apiKey) {
+      throw new Error("Environment variables 'HOST_URL' or 'API_KEY' are not set.");
+    }
+    templateApi = new TemplateApi(baseUrl);
+    templateApi.setApiKey(apiKey);
+    brandingApi = new BrandingApi(baseUrl);
+    brandingApi.setApiKey(apiKey);
+  });
+  test('Test1:should create a brand successfully', async () => {
+    const brandName = "NodeSDK";
+    const brandLogo = fs.createReadStream("tests/documents/logo.jpg");
+    try {
+      const createBrandApiResponse = await brandingApi.createBrand(brandName, brandLogo);
+      console.log("Brand created successfully:", createBrandApiResponse.brandId);
+      brandId = createBrandApiResponse.brandId;
+      expect(createBrandApiResponse).toBeDefined();
+    } catch (error) {
+      console.log("Error occurred while creating the brand:", error);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+test('Test2: should create a template successfully with signer and signer email', async () => {
+  const signatureField = new FormField();
+  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
+  signatureField.pageNumber = 1;
+  const bounds = new Rectangle();
+  bounds.x = 50;
+  bounds.y = 100;
+  bounds.width = 150;
+  bounds.height = 50;
+  signatureField.bounds = bounds;
+  const role = new TemplateRole();
+  role.index = 1;
+  role.name = "Signer";
+  role.defaultSignerName = "John Doe";
+  role.defaultSignerEmail = "johndoe@example.com";
+  role.signerOrder = 1;
+  role.signerType = TemplateRole.SignerTypeEnum.Signer;
+  role.formFields = [signatureField];
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.title = "Testing node sdk";
+  createTemplateRequest.description = "Testing integration test case";
+  createTemplateRequest.documentTitle = "Node sdk test case";
+  createTemplateRequest.documentMessage = "Please check and sign";
+  createTemplateRequest.roles = [role];
+  createTemplateRequest.enableReassign = true;
+  createTemplateRequest.enableSigningOrder = true;
+  createTemplateRequest.allowNewRoles = true;
+  createTemplateRequest.allowMessageEditing = true;
+  createTemplateRequest.allowNewFiles = true;
+  const documentFile = fs.createReadStream("tests/documents/agreement.pdf");
+  createTemplateRequest.files = [documentFile];
+  try {
+    const response = await templateApi.createTemplate(createTemplateRequest);
+    console.log("Template created successfully:", response);
+    createdTemplateId = response.templateId;
+    console.log("Created Template ID: ", createdTemplateId);
+  } catch (error:any) {
+    console.log("Error occurred while calling the API:", error.message);
+    expect(error.message).toBeUndefined();
+  }
+}, 20000);
+test('Test3:Create template with existing brand ID', async () => {
+  const signatureField = new FormField();
+  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
+  signatureField.pageNumber = 1;
+  signatureField.bounds = { x: 50, y: 100, width: 150, height: 50 };
+  const role = new TemplateRole();
+  role.index = 1;
+  role.name = "Signer";
+  role.defaultSignerName = "John Doe";
+  role.defaultSignerEmail = "johndoe@example.com";
+  role.signerOrder = 1;
+  role.signerType = TemplateRole.SignerTypeEnum.Signer;
+  role.formFields = [signatureField];
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.title = "Template with Brand";
+  createTemplateRequest.description = "Created with brand ID";
+  createTemplateRequest.documentTitle = "Brand Template";
+  createTemplateRequest.documentMessage = "Please sign this";
+  createTemplateRequest.roles = [role];
+  createTemplateRequest.enableReassign = true;
+  createTemplateRequest.enableSigningOrder = true;
+  createTemplateRequest.allowNewRoles = true;
+  createTemplateRequest.allowMessageEditing = true;
+  createTemplateRequest.allowNewFiles = true;
+  createTemplateRequest.brandId = brandId;
+  createTemplateRequest.files = [fs.createReadStream("tests/documents/agreement.pdf")];
+  try {
+    const response = await templateApi.createTemplate(createTemplateRequest);
+    console.log("Template created:", response.templateId);
+  } catch (error: any) {
+    console.error("Error creating template:", error);
+    expect(error).toBeUndefined();
+  }
+}, 20000);
+test('Test4: should create a template with form field', async () => {
+  const signatureField = new FormField();
+  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
+  signatureField.pageNumber = 1;
+  const bounds = new Rectangle();
+  bounds.x = 50;
+  bounds.y = 100;
+  bounds.width = 100;
+  bounds.height = 60;
+  signatureField.bounds = bounds;
+  const formFields = [signatureField];
+  const templateRole = new TemplateRole();
+  templateRole.index = 1;
+  templateRole.name = "Hr";
+  templateRole.defaultSignerName = "Divya";  
+  templateRole.defaultSignerEmail = "divya.boopathy+8@syncfusion.com"; 
+  templateRole.signerOrder = 1;
+  templateRole.signerType = TemplateRole.SignerTypeEnum.Signer;
+  templateRole.locale = TemplateRole.LocaleEnum.En;
+  templateRole.formFields = formFields;
+  templateRole.allowRoleEdit = true;
+  templateRole.allowRoleDelete = true;
+  const roles = [templateRole];
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.enableReassign = true;
+  createTemplateRequest.allowNewRoles = true;
+  createTemplateRequest.enablePrintAndSign = false;
+  createTemplateRequest.documentMessage = "document message for signers";
+  createTemplateRequest.enableSigningOrder = false;
+  createTemplateRequest.useTextTags = false;
+  createTemplateRequest.title = "title of the template";
+  createTemplateRequest.allowMessageEditing = true;
+  createTemplateRequest.description = "testingDescription";
+  createTemplateRequest.documentTitle = "title of the document";
+  createTemplateRequest.allowNewFiles = true;
+  createTemplateRequest.roles = roles;
+  const documentFile = fs.createReadStream("tests/documents/agreement.pdf");
+  createTemplateRequest.files = [documentFile];
+  try {
+      const response = await templateApi.createTemplate(createTemplateRequest);
+      console.log("Template created successfully:", response);
+      createdTemplateId1 = response.templateId;
+      console.log("Created Template ID:", createdTemplateId1);
+      expect(response).toBeDefined();
+  } catch (error:any) {
+      console.error("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+  }
+}, 20000);
+test('Test5: should create a template with multiple roles successfully', async () => {
+  const signatureField = new FormField();
+  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
+  signatureField.pageNumber = 1;
+  const bounds = new Rectangle();
+  bounds.x = 50;
+  bounds.y = 100;
+  bounds.width = 100;
+  bounds.height = 60;
+  signatureField.bounds = bounds;
+  const formFields = [signatureField];
+  const roles: TemplateRole[] = [];
+  for (let i = 1; i <= 15; i++) {
+    const templateRole = new TemplateRole();
+    templateRole.index = i;
+    templateRole.name = `Role ${i}`;
+    templateRole.signerOrder = i;
+    templateRole.signerType = TemplateRole.SignerTypeEnum.Signer;
+    templateRole.locale = TemplateRole.LocaleEnum.En;
+    templateRole.formFields = formFields;
+    templateRole.allowRoleEdit = true;
+    templateRole.allowRoleDelete = true;
+    roles.push(templateRole);
+  }
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.enableReassign = true;
+  createTemplateRequest.allowNewRoles = true;
+  createTemplateRequest.enablePrintAndSign = false;
+  createTemplateRequest.documentMessage = "document message for signers";
+  createTemplateRequest.enableSigningOrder = true;
+  createTemplateRequest.useTextTags = false;
+  createTemplateRequest.title = "Template with 15 Roles";
+  createTemplateRequest.allowMessageEditing = true;
+  createTemplateRequest.description = "This is a template with 15 roles.";
+  createTemplateRequest.documentTitle = "Multi-role template";
+  createTemplateRequest.allowNewFiles = true;
+  createTemplateRequest.roles = roles;
+  const documentFile = fs.createReadStream("tests/documents/agreement.pdf");
+  createTemplateRequest.files = [documentFile];
+  try {
+    const response = await templateApi.createTemplate(createTemplateRequest);
+    console.log("Template created successfully:", response);
+    createdTemplateId2 = response.templateId;
+    console.log("Created Template ID:", createdTemplateId2);
+    expect(response).toBeDefined();
+  } catch (error:any) {
+    console.error("Error occurred while calling the API:", error.message);
+    expect(error.message).toBeUndefined();
+  } 
+}, 20000);
+test('Test6: should create a template with multiple files successfully', async () => {
+  const signatureField = new FormField();
+  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
+  signatureField.pageNumber = 1;
+  const bounds = new Rectangle();
+  bounds.x = 50;
+  bounds.y = 100;
+  bounds.width = 100;
+  bounds.height = 60;
+  signatureField.bounds = bounds;
+  const formFields = [signatureField];
+  const templateRole = new TemplateRole();
+  templateRole.index = 1;
+  templateRole.name = "Hr";
+  templateRole.defaultSignerName = "Divya";
+  templateRole.defaultSignerEmail = "divya.boopathy+25@syncfusion.com";
+  templateRole.signerOrder = 1;
+  templateRole.signerType = TemplateRole.SignerTypeEnum.Signer;
+  templateRole.locale = TemplateRole.LocaleEnum.En;
+  templateRole.formFields = formFields;
+  templateRole.allowRoleEdit = true;
+  templateRole.allowRoleDelete = true;
+  const roles = [templateRole];
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.enableReassign = true;
+  createTemplateRequest.allowNewRoles = true;
+  createTemplateRequest.enablePrintAndSign = false;
+  createTemplateRequest.documentMessage = "document message for signers";
+  createTemplateRequest.enableSigningOrder = false;
+  createTemplateRequest.useTextTags = false;
+  createTemplateRequest.title = "title of the template";
+  createTemplateRequest.allowMessageEditing = true;
+  createTemplateRequest.description = "testingDescription";
+  createTemplateRequest.documentTitle = "title of the document";
+  createTemplateRequest.allowNewFiles = true;
+  createTemplateRequest.roles = roles;
+  const files = [
+    fs.createReadStream("tests/documents/agreement.pdf"),
+    fs.createReadStream("tests/documents/agreement.pdf"),
+    fs.createReadStream("tests/documents/agreement.pdf")
+  ];
+  createTemplateRequest.files = files;
+  try {
+    const response = await templateApi.createTemplate(createTemplateRequest);
+    console.log("Template created successfully:", response);
+    createdTemplateId3 = response.templateId;
+    console.log("Created Template ID:", createdTemplateId3);
+    expect(response).toBeDefined();
+  } catch (error:any) {
+    console.log("Error occurred while calling the API:", error.message);
+    expect(error.message).toBeUndefined();
+  }
+}, 20000); 
+test('Test7: should create a template with image form field successfully', async () => {
+  const imageField = new FormField();
+  imageField.name = "image";
+  imageField.id = "Image1";
+  imageField.fieldType = FormField.FieldTypeEnum.Image;
+  imageField.font = FormField.FontEnum.Helvetica;
+  imageField.pageNumber = 1;
+  imageField.isRequired = true;
+  imageField.imageInfo = new ImageInfo();
+  imageField.imageInfo.title = "Image Test";
+  imageField.imageInfo.allowedFileExtensions = ".png";
+  imageField.imageInfo.description = "Image for testing";
+  const bounds = new Rectangle();
+  bounds.x = 50;
+  bounds.y = 50;
+  bounds.width = 100;
+  bounds.height = 150;
+  imageField.bounds = bounds;
+  const role = new TemplateRole();
+  role.index = 1;
+  role.name = "Signer";
+  role.signerType = TemplateRole.SignerTypeEnum.Signer;
+  role.defaultSignerEmail = "john.doe@example.com";
+  role.defaultSignerName = "John Doe";
+  role.signerOrder = 1;
+  role.formFields = [imageField];
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.title = "New Template";
+  createTemplateRequest.documentTitle = "node_test_template_with_image_field";
+  createTemplateRequest.description = "This is a new template.";
+  createTemplateRequest.files = [fs.createReadStream("tests/documents/agreement.pdf")];
+  createTemplateRequest.roles = [role];
+  createTemplateRequest.allowMessageEditing = true;
+  createTemplateRequest.allowNewRoles = true;
+  createTemplateRequest.allowNewFiles = true;
+  createTemplateRequest.enableReassign = true;
+  createTemplateRequest.enablePrintAndSign = false;
+  createTemplateRequest.enableSigningOrder = true;
+  try {
+    const response = await templateApi.createTemplate(createTemplateRequest);
+    console.log("Template with image field created successfully:", response);
+    createdTemplateId4 = response.templateId;
+    console.log("Created Template ID (Image Field):", createdTemplateId4);
+  } catch (error: any) {
+    console.error("Error occurred while creating template with image field:", error);
+    expect(error).toBeUndefined();
+  }
+}, 20000);
+test('Test8: should fail to create a template with duplicate role index', async () => {
+  const role1 = new TemplateRole();
+  role1.index = 1;
+  role1.name = "Signer1";
+  role1.signerType = TemplateRole.SignerTypeEnum.Signer;
+  role1.signerOrder = 1;
+  role1.locale = TemplateRole.LocaleEnum.En;
+  role1.imposeAuthentication = TemplateRole.ImposeAuthenticationEnum.EmailOtp;
+  role1.deliveryMode = TemplateRole.DeliveryModeEnum.Email;
+  role1.allowFieldConfiguration = true;
+  role1.allowRoleEdit = true;
+  role1.allowRoleDelete = true;
+  const role2 = new TemplateRole();
+  role2.index = 2;
+  role2.name = "Reviewer1";
+  role2.signerType = TemplateRole.SignerTypeEnum.Reviewer;
+  role2.signerOrder = 2;
+  role2.locale = TemplateRole.LocaleEnum.En;
+  role2.imposeAuthentication = TemplateRole.ImposeAuthenticationEnum.None;
+  role2.deliveryMode = TemplateRole.DeliveryModeEnum.Email;
+  role2.allowFieldConfiguration = false;
+  role2.allowRoleEdit = true;
+  role2.allowRoleDelete = true;
+  const role3 = new TemplateRole();
+  role3.index = 2;
+  role3.name = "InPersonSigner1";
+  role3.signerType = TemplateRole.SignerTypeEnum.Reviewer;
+  role3.signerOrder = 3;
+  role3.locale = TemplateRole.LocaleEnum.En;
+  role3.imposeAuthentication = TemplateRole.ImposeAuthenticationEnum.AccessCode;
+  role3.deliveryMode = TemplateRole.DeliveryModeEnum.Email;
+  role3.allowFieldConfiguration = false;
+  role3.allowRoleEdit = true;
+  role3.allowRoleDelete = true;
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.title = "Duplicate Role Index Test";
+  createTemplateRequest.documentTitle = "node_test_template_duplicate_index";
+  createTemplateRequest.description = "Template with duplicate role index.";
+  createTemplateRequest.files = [
+    fs.createReadStream("tests/documents/agreement.pdf"),
+    fs.createReadStream("tests/documents/agreement.pdf")
+  ];
+  createTemplateRequest.roles = [role1, role2, role3];
+  createTemplateRequest.allowMessageEditing = true;
+  createTemplateRequest.allowNewRoles = true;
+  createTemplateRequest.allowNewFiles = true;
+  createTemplateRequest.enableReassign = true;
+  createTemplateRequest.enablePrintAndSign = false;
+  createTemplateRequest.enableSigningOrder = true;
+  try {
+    const response = await templateApi.createTemplate(createTemplateRequest);
+    console.error("Unexpected success, test should have failed due to duplicate role index.", response.body);
+    throw new Error("Test failed: Expected error due to duplicate role index.");
+  } catch (error: any) {
+    console.log("Expected error occurred due to duplicate role index:", error.response?.data || error.message);
+    expect(error.response?.status).toBe(400);
+    expect(error.response?.statusText).toBe("Bad Request");
+  }
+}, 20000);
+test('Test9: should fail to create template due to missing document title', async () => {
+  const signatureField = new FormField();
+  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
+  signatureField.pageNumber = 1;
+  signatureField.bounds = { x: 50, y: 100, width: 150, height: 50 };
+  const role = new TemplateRole();
+  role.index = 1;
+  role.name = "Signer";
+  role.defaultSignerName = "John Doe";
+  role.defaultSignerEmail = "johndoe@example.com";
+  role.signerOrder = 1;
+  role.signerType = TemplateRole.SignerTypeEnum.Signer;
+  role.formFields = [signatureField];
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.title = "Missing Document Title Test";
+  createTemplateRequest.description = "Should fail due to missing document title";
+  createTemplateRequest.documentMessage = "Please check and sign";
+  createTemplateRequest.roles = [role];
+  createTemplateRequest.files = [fs.createReadStream("tests/documents/agreement.pdf")];
+  try {
+    await templateApi.createTemplate(createTemplateRequest);
+    throw new Error("Test failed: API should have thrown an error due to missing document title.");
+  } catch (error: any) {
+    console.log("Expected error received:", error.response?.data || error.message);
+    expect(error.response).toBeDefined();
+    expect(error.response?.status).toBe(400);
+    expect(error.response.statusText).toBe("Bad Request");
+  }
+}, 20000);
+test('Test10: should fail to create template due to empty roles array', async () => {
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.title = "Template without roles";
+  createTemplateRequest.description = "This template should fail due to no roles";
+  createTemplateRequest.documentTitle = "Missing roles test case";
+  createTemplateRequest.documentMessage = "Please check and sign";
+  createTemplateRequest.roles = [];
+  const documentFile = fs.createReadStream("tests/documents/agreement.pdf");
+  createTemplateRequest.files = [documentFile];
+  try {
+    await templateApi.createTemplate(createTemplateRequest);
+    throw new Error("Test failed: API should have thrown an error due to empty roles.");
+  } catch (error: any) {
+    console.log("Expected error for empty roles array:", error.response?.data || error.message);
+    expect(error.response).toBeDefined();
+    expect(error.response?.status).toBe(400);
+    expect(error.response.statusText).toBe("Bad Request");
+  }
+}, 20000);
+test('Test11: should fail to create a template with empty title', async () => {
+  const signatureField = new FormField();
+  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
+  signatureField.pageNumber = 1;
+  const bounds = new Rectangle();
+  bounds.x = 50;
+  bounds.y = 100;
+  bounds.width = 150;
+  bounds.height = 50;
+  signatureField.bounds = bounds;
+  const role = new TemplateRole();
+  role.index = 1;
+  role.name = "Signer";
+  role.defaultSignerName = "John Doe";
+  role.defaultSignerEmail = "johndoe@example.com";
+  role.signerOrder = 1;
+  role.signerType = TemplateRole.SignerTypeEnum.Signer;
+  role.formFields = [signatureField];
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.title = "";
+  createTemplateRequest.description = "Testing integration test case";
+  createTemplateRequest.documentTitle = "Node sdk test case";
+  createTemplateRequest.documentMessage = "Please check and sign";
+  createTemplateRequest.roles = [role];
+  createTemplateRequest.enableReassign = true;
+  createTemplateRequest.enableSigningOrder = true;
+  createTemplateRequest.allowNewRoles = true;
+  createTemplateRequest.allowMessageEditing = true;
+  createTemplateRequest.allowNewFiles = true;
+  const documentFile = fs.createReadStream("tests/documents/agreement.pdf");
+  createTemplateRequest.files = [documentFile];
+  try {
+    await templateApi.createTemplate(createTemplateRequest);
+    throw new Error("Test failed: API should have thrown an error due to empty title.");
+  } catch (error: any) {
+    console.log("Expected error for empty title:", error.response?.data || error.message);
+    expect(error.response).toBeDefined();
+    expect(error.response?.status).toBe(400);
+    expect(error.response.statusText).toBe("Bad Request");
+  }
+}, 20000);
+test('Test12: should fail to create a template with form field invalid signer email', async () => {
+  const signatureField = new FormField();
+  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
+  signatureField.pageNumber = 1;
+  const bounds = new Rectangle();
+  bounds.x = 50;
+  bounds.y = 100;
+  bounds.width = 100;
+  bounds.height = 60;
+  signatureField.bounds = bounds;
+  const formFields = [signatureField];
+  const templateRole = new TemplateRole();
+  templateRole.index = 1;
+  templateRole.name = "Hr";
+  templateRole.defaultSignerName = "Divya";
+  templateRole.defaultSignerEmail = "invalid-email";
+  templateRole.signerOrder = 1;
+  templateRole.signerType = TemplateRole.SignerTypeEnum.Signer;
+  templateRole.locale = TemplateRole.LocaleEnum.En;
+  templateRole.formFields = formFields;
+  templateRole.allowRoleEdit = true;
+  templateRole.allowRoleDelete = true;
+  const roles = [templateRole];
+  const createTemplateRequest = new CreateTemplateRequest();
+  createTemplateRequest.enableReassign = true;
+  createTemplateRequest.allowNewRoles = true;
+  createTemplateRequest.enablePrintAndSign = false;
+  createTemplateRequest.documentMessage = "document message for signers";
+  createTemplateRequest.enableSigningOrder = false;
+  createTemplateRequest.useTextTags = false;
+  createTemplateRequest.title = "title of the template";
+  createTemplateRequest.allowMessageEditing = true;
+  createTemplateRequest.description = "testingDescription";
+  createTemplateRequest.documentTitle = "title of the document";
+  createTemplateRequest.allowNewFiles = true;
+  createTemplateRequest.roles = roles;
+  const documentFile = fs.createReadStream("tests/documents/agreement.pdf");
+  createTemplateRequest.files = [documentFile];
+  try {
+    const response = await templateApi.createTemplate(createTemplateRequest);
+    console.error("Unexpected success:", response);
+    throw new Error("Template creation should have failed due to invalid email");
+  } catch (error: any) {
+    console.log("Expected error for invalid email:", error.response?.data || error.message);
+    expect(error.response).toBeDefined();
+    expect(error.response.status).toBe(400);
+    expect(error.response.statusText).toBe("Bad Request");
+  }
+}, 20000);
+  test('Test13:should edit a template successfully', async () => {
+    const editTemplateRequest = new EditTemplateRequest();
+    editTemplateRequest.title = "Updated NodesdkTesting";
+    editTemplateRequest.description = "Updated description for the template";
+    editTemplateRequest.documentMessage = "Updated document message for signers";
+    editTemplateRequest.enableReassign = true;
+    try {
+      const response = await templateApi.editTemplate(createdTemplateId, editTemplateRequest);
+      console.log("Template edited successfully:", response);
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+    }
+  }, 20000);
+  test('Test14:should fail to edit a template with invalid template ID', async () => {
+    const editTemplateRequest = new EditTemplateRequest();
+    editTemplateRequest.title = "Updated NodesdkTesting";
+    editTemplateRequest.description = "Updated description for the template";
+    editTemplateRequest.documentMessage = "Updated document message for signers";
+    editTemplateRequest.enableReassign = true;
+    const invalidTemplateId = "invalid-template-id";
+    try {
+      const response = await templateApi.editTemplate(invalidTemplateId, editTemplateRequest);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, template edit should not succeed with invalid template ID");
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error.message);
+    }
+  }, 20000);
+  test('Test15: should fail to edit a template with empty title', async () => {
+    const editTemplateRequest = new EditTemplateRequest();
+    editTemplateRequest.title = "";
+    editTemplateRequest.description = "Updated description for the template";
+    editTemplateRequest.documentMessage = "Updated document message for signers";
+    editTemplateRequest.enableReassign = true;
+    const validTemplateId = "valid-template-id";
+    try {
+      const response = await templateApi.editTemplate(validTemplateId, editTemplateRequest);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, template edit should not succeed with empty title");
+    } catch (error: any) {
+      console.log("Expected error occurred for empty title:", error.response?.data || error.message);
+      expect(error.response).toBeDefined();
+      expect(error.response.status).toBe(403);
+      expect(error.response.statusText).toBe("Forbidden");
+    }
+  }, 20000);
+  test('Test16:should add tag to template successfully', async () => {
+    const addTag = new TemplateTag();
+    addTag.templateId = createdTemplateId;  
+    addTag.documentLabels = ["test", "api"];
+    addTag.templateLabels = ["test", "api"];
+    try {
+      const response = await templateApi.addTag(addTag);
+      console.log("Tag added successfully:", response);
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+    }
+  },20000);
+  test('Test17: should fail to add tag to template with invalid template ID', async () => {
+    const addTag = new TemplateTag();
+    addTag.templateId = "INVALID_TEMPLATE_ID";
+    addTag.documentLabels = ["test", "api"];
+    addTag.templateLabels = ["test", "api"];
+    try {
+      const response = await templateApi.addTag(addTag);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, tag should not have been added with invalid template ID");
+    } catch (error: any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeDefined();
+    }
+  },20000);
+  test('Test18: should fail to add tag to template with empty document labels and template labels', async () => {
+    const addTag = new TemplateTag();
+    addTag.templateId = createdTemplateId;
+    addTag.documentLabels = [];
+    addTag.templateLabels = [];
+    try {
+      const response = await templateApi.addTag(addTag);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, tag should not have been added with empty document labels and template labels");
+    } catch (error: any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeDefined();
+    }
+  },20000);
+  test('Test19: should delete tag from template successfully', async () => {
+    const deleteTag = new TemplateTag();
+    deleteTag.templateId = createdTemplateId;
+    deleteTag.documentLabels = ["test", "api"];
+    deleteTag.templateLabels = ["test", "api"];
+    try {
+      const response = await templateApi.deleteTag(deleteTag);
+      console.log("Tag deleted successfully:", response);
+    } catch (error:any) {
+      console.error("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+    }
+  },20000);
+  test('Test20: should fail to delete tag from template with invalid template ID', async () => {
+    const deleteTag = new TemplateTag();
+    deleteTag.templateId = "INVALID_TEMPLATE_ID";
+    deleteTag.documentLabels = ["test", "api"];
+    deleteTag.templateLabels = ["test", "api"];
+    try {
+      const response = await templateApi.deleteTag(deleteTag);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, tag should not have been deleted with invalid template ID");
+    } catch (error: any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeDefined();
+    }
+  },20000);
+  test('Test21: should fail to delete tag from template with valid template ID and empty labels', async () => {
+    const deleteTag = new TemplateTag();
+    deleteTag.templateId = createdTemplateId;
+    deleteTag.documentLabels = [];
+    deleteTag.templateLabels = [];
+    try {
+      const response = await templateApi.deleteTag(deleteTag);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, tag should not have been deleted with empty labels");
+    } catch (error: any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeDefined();
+    }
+  },20000);
+  test('Test22: should retrieve template properties successfully', async () => {
+    try {
+      const response = await templateApi.getProperties(createdTemplateId);
+      console.log("Template Properties:", response);
+      expect(response).toBeDefined();
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+    }
+  },20000);
+  test('Test23: should fail to retrieve template properties with invalid template ID', async () => {
+    const invalidTemplateId = "INVALID_TEMPLATE_ID";
+    try {
+      const response = await templateApi.getProperties(invalidTemplateId);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, API should have thrown an error for invalid template ID");
+    } catch (error: any) {
+      console.log("Error occurred while calling the API:", error.message);
+    }
+  },20000);
+  test('Test24: should fail to retrieve template properties with empty template', async () => {
+    const templateId = "";
+    try {
+      const response = await templateApi.getProperties(templateId);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, API should have thrown an error for invalid template ID");
+    } catch (error: any) {
+      console.log("Error occurred while calling the API:", error);
+      expect(error.response.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  },20000);
+  test('Test25:should download template successfully', async () => {
+    try {
+      console.log("Created Template ID:", createdTemplateId1);
+      const response = await templateApi.download(createdTemplateId);
+      console.log("Template downloaded successfully:", response);
+      expect(response).toBeDefined();
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+    }
+  }, 20000); 
+  test('Test26:should fail to download template with invalid template ID', async () => {
+    const invalidTemplateId = "invalid-template-id";  
+    try {
+      const response = await templateApi.download(invalidTemplateId);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, template download should not succeed with an invalid template ID");
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeDefined();
+    }
+  }, 20000);
+  test('Test27: should send document for signing using template', async () => {
+    const formField = new FormField();
+    formField.fieldType = FormField.FieldTypeEnum.Signature;
+    formField.pageNumber = 1;
+    const bounds = new Rectangle();
+    bounds.x = 100;
+    bounds.y = 50;
+    bounds.width = 100;
+    bounds.height = 100;
+    formField.bounds = bounds;
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+20@syncfusion.com";
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.authenticationType = Role.AuthenticationTypeEnum.AccessCode;
+    role.authenticationCode = '123456';
+    role.authenticationSettings = {
+            authenticationFrequency: AuthenticationSettings.AuthenticationFrequencyEnum.EveryAccess
+        };
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.formFields = [formField];
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate(createdTemplateId, sendForSignFromTemplate);
+      console.log("Document sent for signing using template successfully:", response);
+      expect(response).toBeDefined();
+    } catch (error:any) {
+      console.error("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+    }
+  }, 20000);
+  test('Test28:should send document for signing using template with multiple CCs', async () => {
+    const formField = new FormField();
+    formField.fieldType = FormField.FieldTypeEnum.Signature;
+    formField.pageNumber = 1;
+    const bounds = new Rectangle();
+    bounds.x = 100;
+    bounds.y = 100;
+    bounds.width = 100;
+    bounds.height = 50;
+    formField.bounds = bounds;
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+23@syncfusion.com";
+    role.signerOrder = 1;
+    role.privateMessage = "Please check and sign the document.";
+    role.authenticationCode = "123456";
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.signerRole = "Hr";
+    role.formFields = [formField];
+    role.locale = Role.LocaleEnum.En;
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf"); 
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = true;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = false;
+    sendForSignFromTemplate.labels = ["Invitation"];
+    const ccEmails: DocumentCC[] = [
+      { emailAddress: "divya.boopathy+5@syncfusion.com" },
+      { emailAddress: "divya.boopathy+8@syncfusion.com" },
+      { emailAddress: "divya.boopathy+9@syncfusion.com" }
+    ];
+    sendForSignFromTemplate.cc = ccEmails;
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryDays = 180;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    sendForSignFromTemplate.roleRemovalIndices = [1, 2];
+    try {
+      const response = await templateApi.sendUsingTemplate(createdTemplateId, sendForSignFromTemplate);
+      console.log("Document sent for signing using template successfully:", response);
+      expect(response).toBeDefined();
+    } catch (error:any) {
+      console.error("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+    }
+  }, 20000);
+  test('Test29: should send document from template with file path', async () => {
+    const formField = new FormField();
+    formField.fieldType = FormField.FieldTypeEnum.Signature;
+    formField.pageNumber = 1;
+    const bounds = new Rectangle();
+    bounds.x = 100;
+    bounds.y = 50;
+    bounds.width = 100;
+    bounds.height = 100;
+    formField.bounds = bounds;
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+20@syncfusion.com";
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.formFields = [formField];
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const fileStream = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [fileStream];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate(createdTemplateId, sendForSignFromTemplate);
+      console.log("Document sent for signing using template successfully:", response);
+      expect(response).toBeDefined();
+    } catch (error) {
+      console.error("Error occurred while calling the API:", error);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+  test('Test30: should fail to send document for signing using invalid template ID with valid fields', async () => {
+    const templateId = "INVALID_TEMPLATE_ID";  
+    const formField = new FormField();
+    formField.fieldType = FormField.FieldTypeEnum.Signature;
+    formField.pageNumber = 1;
+    const bounds = new Rectangle();
+    bounds.x = 100;
+    bounds.y = 50;
+    bounds.width = 100;
+    bounds.height = 100;
+    formField.bounds = bounds;
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+20@syncfusion.com";
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.formFields = [formField];
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate(templateId, sendForSignFromTemplate);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, document should not have been sent with invalid template ID.");
+    } catch (error: any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeDefined();
+    }
+  }, 20000);
+  test('Test31: should send document for signing using template with email and SMS', async () => {
+    const formField = new FormField();
+    formField.fieldType = FormField.FieldTypeEnum.Signature;
+    formField.pageNumber = 1;
+    const bounds = new Rectangle();
+    bounds.x = 100;
+    bounds.y = 50;
+    bounds.width = 100;
+    bounds.height = 100;
+    formField.bounds = bounds;
+    const phoneNumber = new PhoneNumber();
+    phoneNumber.countryCode = "+91";
+    phoneNumber.number = "6381261236";
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+20@syncfusion.com";
+    role.phoneNumber = phoneNumber;
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.formFields = [formField];
+    role.deliveryMode = Role.DeliveryModeEnum.EmailAndSms;
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate(createdTemplateId, sendForSignFromTemplate);
+      console.log("Document sent for signing using template with email and SMS successfully:", response);
+      expect(response).toBeDefined();
+    } catch (error) {
+      console.error("Error occurred while calling the API:", error);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+  test('Test32: should fail with invalid email and empty phone number', async () => {
+    const formField = new FormField();
+    formField.fieldType = FormField.FieldTypeEnum.Signature;
+    formField.pageNumber = 1;
+    const bounds = new Rectangle();
+    bounds.x = 100;
+    bounds.y = 50;
+    bounds.width = 100;
+    bounds.height = 100;
+    formField.bounds = bounds;
+    const phoneNumber = new PhoneNumber();
+    phoneNumber.countryCode = "";
+    phoneNumber.number = "";
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "invalid-email";
+    role.phoneNumber = phoneNumber;
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.formFields = [formField];
+    role.deliveryMode = Role.DeliveryModeEnum.EmailAndSms;
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate(createdTemplateId, sendForSignFromTemplate);
+      console.error("Expected failure, but API call succeeded:", response);
+      fail("Expected API to fail due to invalid email and empty phone number");
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error);
+      expect(error).toBeDefined();
+      expect(error.response.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  }, 20000);
+  test('Test33: should send document using template with existing form fields', async () => {
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+20@syncfusion.com";
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.existingFormFields = [
+      {
+        id: "State",
+        value: "North Carolina"
+      }
+    ];
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate(createdTemplateId1, sendForSignFromTemplate);
+      console.log("Document sent using template with pre-filled fields successfully:", response);
+      expect(response).toBeDefined();
+    } catch (error) {
+      console.error("Error occurred while calling the API:", error);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+  test('Test34: should fail to send document using template with empty existing form field', async () => {
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+20@syncfusion.com";
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.existingFormFields = [
+      {
+        id: "",
+        value: "North Carolina"
+      }
+    ];
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate(createdTemplateId, sendForSignFromTemplate);
+    } catch (error:any) {
+      expect(error).toBeDefined();
+      expect(error.response.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  }, 20000);
+  test('Test35: should send document using template with existing image field', async () => {
+    const imagePath = "tests/documents/logo.jpg";
+    const imageBuffer = fs.readFileSync(imagePath);
+    const base64Image = imageBuffer.toString("base64");
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+20@syncfusion.com";
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.existingFormFields = [
+      {
+        id: "Image1",
+        value: base64Image
+      }
+    ];
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate(createdTemplateId4, sendForSignFromTemplate);
+      console.log("Document sent using template with pre-filled image field successfully:", response);
+      expect(response).toBeDefined();
+      expect(response.response.status).toBe(201);
+      expect(response.response.statusText).toBe("Created");
+    } catch (error) {
+      console.error("Error occurred while calling the API:", error);
+    }
+  }, 20000);
+  test('Test36: should fail to send document using template due to invalid existing image field ID', async () => {
+    const imagePath = "tests/documents/logo.jpg";
+    const imageBuffer = fs.readFileSync(imagePath);
+    const base64Image = imageBuffer.toString("base64");
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+20@syncfusion.com";
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.existingFormFields = [
+      {
+        id: "",
+        value: ""
+      }
+    ];
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate("invalid-document-id", sendForSignFromTemplate);
+      console.error("Document was sent unexpectedly:", response);
+    } catch (error: any) {
+      expect(error).toBeDefined();
+      expect(error.response.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  }, 20000);
+  
+  test('Test37:should return the embedded template edit URL', async () => {
+    const embeddedEditTemplateRequest = new EmbeddedTemplateEditRequest();
+    embeddedEditTemplateRequest.showToolbar = true;
+    embeddedEditTemplateRequest.showNavigationButtons = false;
+    embeddedEditTemplateRequest.showPreviewButton = true;
+    embeddedEditTemplateRequest.showSaveButton = false;
+    embeddedEditTemplateRequest.showCreateButton = false;
+    embeddedEditTemplateRequest.showTooltip = false;
+    try {
+      const response = await templateApi.getEmbeddedTemplateEditUrl(createdTemplateId, embeddedEditTemplateRequest);
+      console.log("Template Edit URL:", response);
+      expect(response).toBeDefined();
+    } catch (error:any) {
+      console.log('Error occurred while calling the API:', error.message);
+      expect(error.message).toBeUndefined();
+    }
+  },20000);
+  test('Test38:should fail to get embedded template edit URL with invalid template ID', async () => {
+    const embeddedEditTemplateRequest = new EmbeddedTemplateEditRequest();
+    embeddedEditTemplateRequest.showToolbar = true;
+    embeddedEditTemplateRequest.showNavigationButtons = false;
+    embeddedEditTemplateRequest.showPreviewButton = true;
+    embeddedEditTemplateRequest.showSaveButton = false;
+    embeddedEditTemplateRequest.showCreateButton = false;
+    embeddedEditTemplateRequest.showTooltip = false;
+    const invalidTemplateId = "INVALID_TEMPLATE_ID";  
+    try {
+      const response = await templateApi.getEmbeddedTemplateEditUrl(invalidTemplateId, embeddedEditTemplateRequest);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, template edit URL should not have been retrieved with invalid template ID.");
+    } catch (error: any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeDefined();
+    }
+  },20000);
+  test('Test39:should create embedded template request URL with valid fields', async () => {
+    const role = new Role();
+    role.roleIndex = 1;
+    role.signerName = "Manager";
+    const embeddedSendTemplateFormRequest = new EmbeddedSendTemplateFormRequest();
+    embeddedSendTemplateFormRequest.title = "Api template";
+    embeddedSendTemplateFormRequest.roles = [role];
+    embeddedSendTemplateFormRequest.showToolbar = true;
+    embeddedSendTemplateFormRequest.showNavigationButtons = true;
+    embeddedSendTemplateFormRequest.showPreviewButton = true;
+    embeddedSendTemplateFormRequest.showSaveButton = true;
+    embeddedSendTemplateFormRequest.locale = EmbeddedCreateTemplateRequest.LocaleEnum.En;
+    embeddedSendTemplateFormRequest.showTooltip = false;
+    embeddedSendTemplateFormRequest.sendViewOption = EmbeddedSendTemplateFormRequest.SendViewOptionEnum.FillingPage;
+    const files = fs.createReadStream("tests/documents/agreement.pdf");  
+    embeddedSendTemplateFormRequest.files = [files];
+    try {
+      const response = await templateApi.createEmbeddedRequestUrlTemplate(createdTemplateId, embeddedSendTemplateFormRequest);
+      console.log("Embedded Template URL:", response);
+      expect(response).toBeDefined();
+    } catch (error:any) {
+      console.log('Error occurred while calling the API:', error.message);
+      expect(error.message).toBeUndefined();
+    }
+  },20000);
+  test('Test40:should list templates successfully', async () => {
+    const page = 1;
+    const pageSize = 10;
+    try {
+      const response = await templateApi.listTemplates(page, "all", pageSize);
+      console.log("Templates listed successfully:", response);
+      expect(response).toBeDefined();
+    } catch (error:any) {
+      console.error("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined;
+    }
+  },20000);
+  test('Test41:should fail to list templates with invalid page and pageSize', async () => {
+    const invalidPage = -1;
+    const invalidPageSize = 1000;
+    try {
+      const listTemplateResponse = await templateApi.listTemplates(invalidPage, "all", invalidPageSize);
+      console.error("Unexpected success response:", listTemplateResponse);
+      throw new Error("Test failed, API call should not have succeeded with invalid page and pageSize.");
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeDefined(); 
+    }
+  },20000);
+  test('Test42: should send document for signing using multiple templates', async () => {
+    console.log(createdTemplateId1, createdTemplateId2, createdTemplateId3);
+    const formField = new FormField();
+    formField.fieldType = FormField.FieldTypeEnum.Signature;
+    formField.pageNumber = 1;
+    const bounds = new Rectangle();
+    bounds.x = 100;
+    bounds.y = 50;
+    bounds.width = 100;
+    bounds.height = 100;
+    formField.bounds = bounds;
+    const role = new Role();
+    role.roleIndex = 2;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+9989@syncfusion.com";
+    role.signerOrder = 1;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.authenticationType = Role.AuthenticationTypeEnum.AccessCode;
+    role.authenticationCode = '123456';
+    role.authenticationSettings = {
+            authenticationFrequency: AuthenticationSettings.AuthenticationFrequencyEnum.OncePerDocument
+        };
+    role.signerRole = "Manager";
+    role.formFields = [formField];  
+    const mergeAndSendForsign = new MergeAndSendForSignForm();
+    mergeAndSendForsign.title = "Invitation form";
+    mergeAndSendForsign.message = "Kindly review and sign this.";
+    mergeAndSendForsign.roles = [role];  
+    mergeAndSendForsign.templateIds = [createdTemplateId,createdTemplateId1];  
+    try {createdTemplateId2
+        const response = await templateApi.mergeAndSend(mergeAndSendForsign);
+        console.log("Document sent for signing using multiple templates successfully", response.body);
+        expect(response).toBeDefined();
+    } catch (error:any) {
+        console.error('Error occurred while calling the API:', error.message);
+        expect(error.message).toBeUndefined();
+    }
+}, 20000);
+test('Test43:should create embedded request URL from merged templates', async () => {
+    const role1 = new Role();
+    role1.signerEmail = 'sivaramani.sivaraj@syncfusion.com';
+    role1.signerName = 'sivaramani';
+    role1.signerType = Role.SignerTypeEnum.Signer;
+    role1.authenticationType = Role.AuthenticationTypeEnum.AccessCode;
+    role1.authenticationCode = '123456';
+    role1.authenticationSettings = {
+            authenticationFrequency: AuthenticationSettings.AuthenticationFrequencyEnum.EveryAccess
+        };
+    role1.signerRole = 'Manager';
+    role1.signerOrder = 1;
+    role1.roleIndex = 1;
+    const role2 = new Role();
+    role2.signerEmail = 'david@gmail.com';
+    role2.signerName = 'david';
+    role2.signerType = Role.SignerTypeEnum.Signer;
+    role2.signerRole = 'Team Lead';
+    role2.signerOrder = 2;
+    role2.roleIndex = 2;
+    const fileStream = fs.createReadStream('tests/documents/agreement.pdf');
+    const request = new EmbeddedMergeTemplateFormRequest();
+    request.files = [fileStream];
+    request.title = 'Merged Template Embedded Request';
+    request.roles = [role1, role2];
+    request.templateIds = [createdTemplateId, createdTemplateId1];
+    try {
+      const response = await templateApi.mergeCreateEmbeddedRequestUrlTemplate(request);
+      expect(response).toBeDefined();
+      expect(response.sendUrl).toBeDefined();
+      console.log('Generated Embedded Send URL:', response.sendUrl);
+    } catch (error: any) {
+      console.error('API Exception occurred:', error.message || error);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+  test('Test44: should fail to create embedded request URL from merged templates with invalid template IDs', async () => {
+  const role1 = new Role();
+  role1.signerEmail = 'sivaramani.sivaraj@syncfusion.com';
+  role1.signerName = 'sivaramani';
+  role1.signerType = Role.SignerTypeEnum.Signer;
+  role1.signerRole = 'Manager';
+  role1.signerOrder = 1;
+  role1.roleIndex = 1;
+  const role2 = new Role();
+  role2.signerEmail = 'david@gmail.com';
+  role2.signerName = 'david';
+  role2.signerType = Role.SignerTypeEnum.Signer;
+  role2.signerRole = 'Team Lead';
+  role2.signerOrder = 2;
+  role2.roleIndex = 2;
+  const fileStream = fs.createReadStream('tests/documents/agreement.pdf');
+  const request = new EmbeddedMergeTemplateFormRequest();
+  request.files = [fileStream];
+  request.title = 'Negative Test Case - Invalid Template IDs';
+  request.roles = [role1, role2];
+  request.templateIds = ['invalid-template-id-1', 'invalid-template-id-2'];
+  try {
+    const response = await templateApi.mergeCreateEmbeddedRequestUrlTemplate(request);
+    console.error('Expected API to throw an error, but got response:', response);
+    expect(true).toBe(false);
+  } catch (error: any) {
+    expect(error).toBeUndefined();
+    expect(error.status).toBe(400);
+  }
+}, 20000);
+  test('Test45:should delete template successfully', async () => {
+    try { 
+      const response = await templateApi.deleteTemplate(createdTemplateId);
+      console.log("Template deleted successfully:", response);
+      expect(response).toBeDefined(); 
+    } catch (error:any) {
+      console.error("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+    }
+  },20000);
+  test('Test46:should fail to delete template with invalid template ID', async () => {
+    try {
+      const invalidTemplateId = "INVALID_TEMPLATE_ID";
+      const response = await templateApi.deleteTemplate(invalidTemplateId);
+      console.error("Unexpected success response:", response);
+      throw new Error("Test failed, template should not have been deleted with invalid template ID.");
+    } catch (error:any) {
+      console.error("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeDefined();
+    }
+  },20000);
+});