```diff
--- test_files/490-original.txt	2025-03-07 19:07:03
+++ test_files/490-modified.txt	2025-03-07 19:07:03
@@ -1,97 +1,158 @@
-import { describe, it, expect, beforeAll } from "@jest/globals";
+import { beforeAll, describe, expect, it } from "@jest/globals";
 import { getBackendClient } from "../testUtils/getBackendClient";
 
-import { Triggers } from "./triggers";
-import { ConnectedAccounts } from "./connectedAccounts";
+import { ComposioError } from "../utils/errors/src/composioError";
 import { Entity } from "./Entity";
+import { Actions } from "./actions";
+import { ConnectedAccounts } from "./connectedAccounts";
+import { Triggers } from "./triggers";
 
 describe("Apps class tests", () => {
-    let backendClient;
-    let triggers: Triggers;
-    let connectedAccounts: ConnectedAccounts;
-    let entity: Entity;
+  let backendClient;
+  let triggers: Triggers;
+  let _connectedAccounts: ConnectedAccounts;
+  let _entity: Entity;
+  let _actions: Actions;
 
-    let triggerId: string;
+  beforeAll(() => {
+    backendClient = getBackendClient();
+    triggers = new Triggers(backendClient);
+    _connectedAccounts = new ConnectedAccounts(backendClient);
+    _entity = new Entity(backendClient, "default");
+    _connectedAccounts = new ConnectedAccounts(backendClient);
+    _actions = new Actions(backendClient);
+  });
 
-    beforeAll(() => {
-        backendClient = getBackendClient();
-        triggers = new Triggers(backendClient);
-        connectedAccounts = new ConnectedAccounts(backendClient);
-        entity = new Entity(backendClient, "default");
-    });
+  it("should create an Apps instance and retrieve apps list", async () => {
+    const triggerList = await triggers.list();
+    expect(triggerList.length).toBeGreaterThan(0);
+  });
 
-    it("should create an Apps instance and retrieve apps list", async () => {
-        const triggerList = await triggers.list();
-        expect(triggerList.length).toBeGreaterThan(0);
+  it("should retrieve a list of triggers for a specific app", async () => {
+    const triggerList = await triggers.list({
+      appNames: ["github"],
     });
-
-    it("should retrieve a list of triggers for a specific app", async () => {
-        const triggerList = await triggers.list({
-            appNames: "github"
-        });
-        // this is breaking for now
-        expect(triggerList.length).toBeGreaterThan(0);
-        expect(triggerList[0].appName).toBe("github");
-    });
-
-
+    // this is breaking for now
+    expect(triggerList.length).toBeGreaterThan(0);
+    expect(triggerList[0].appName).toBe("github");
+  });
 });
 
-
 describe("Apps class tests subscribe", () => {
-    let backendClient;
-    let triggers: Triggers;
-    let connectedAccounts: ConnectedAccounts;
-    let entity: Entity;
+  let backendClient;
+  let triggers: Triggers;
+  let connectedAccounts: ConnectedAccounts;
+  let _actions: Actions;
+  let _entity: Entity;
 
-    let triggerId: string;
+  let triggerId: string;
 
-    beforeAll(() => {
-        backendClient = getBackendClient();
-        triggers = new Triggers(backendClient);
-        connectedAccounts = new ConnectedAccounts(backendClient);
-        entity = new Entity(backendClient, "default");
+  beforeAll(() => {
+    backendClient = getBackendClient();
+    triggers = new Triggers(backendClient);
+    connectedAccounts = new ConnectedAccounts(backendClient);
+    _entity = new Entity(backendClient, "default");
+    _actions = new Actions(backendClient);
+  });
+
+  it("should create a new trigger for gmail", async () => {
+    const connectedAccount = await connectedAccounts.list({
+      user_uuid: "default",
     });
 
+    const connectedAccountId = connectedAccount.items.find(
+      (item) => item.appName === "gmail"
+    )?.id;
+    if (!connectedAccountId) {
+      throw new Error("No connected account found");
+    }
+    const trigger = await triggers.setup({
+      connectedAccountId,
+      triggerName: "gmail_new_gmail_message",
+      config: {
+        userId: connectedAccount.items[0].id,
+        interval: 60,
+        labelIds: "INBOX",
+      },
+    });
 
+    expect(trigger.status).toBe("success");
+    expect(trigger.triggerId).toBeTruthy();
 
-    it("should create a new trigger for gmail", async () => {
-        const connectedAccount = await connectedAccounts.list({ query: { user_uuid: 'default' } });
+    triggerId = trigger.triggerId;
+  });
 
-        const connectedAccountId = connectedAccount.items.find(item => item.appName === 'gmail')?.id;
-        const trigger = await triggers.setup(connectedAccountId, 'gmail_new_gmail_message', {
-            "userId": connectedAccount.items[0].id,
-            "interval": 60,
-            "labelIds": "INBOX",
-        },);
+  it("should disable, enable, and then disable the created trigger", async () => {
+    let trigger = await triggers.disable({ triggerId });
+    expect(trigger.status).toBe("success");
 
-        expect(trigger.status).toBe("success");
-        expect(trigger.triggerId).toBeTruthy();
+    trigger = await triggers.enable({ triggerId });
+    expect(trigger.status).toBe("success");
 
-        triggerId = trigger.triggerId;
-    })
+    trigger = await triggers.disable({ triggerId });
+    expect(trigger.status).toBe("success");
+  });
 
-    it("should disable, enable, and then disable the created trigger", async () => {
-        let trigger = await triggers.disable({ triggerId });
-        expect(trigger.status).toBe("success");
+  it("should get the config of a trigger", async () => {
+    const res = await triggers.getTriggerConfig({
+      triggerId: "GMAIL_NEW_GMAIL_MESSAGE",
+    });
+    expect(res.config.title).toBe("GmailNewMessageConfigSchema");
+  });
 
-        trigger = await triggers.enable({ triggerId });
-        expect(trigger.status).toBe("success");
-
-        trigger = await triggers.disable({ triggerId });
-        expect(trigger.status).toBe("success");
+  it("should get the payload of a trigger", async () => {
+    const res = await triggers.get({
+      triggerName: "GMAIL_NEW_GMAIL_MESSAGE",
     });
+    expect(res.displayName).toBe("New Gmail Message Received Trigger");
+  });
 
-    it("should subscribe to a trigger", async () => {
-        await triggers.subscribe((data) => {
-            // Explicitly passing the data to an empty function body
-        }, {
-            appName: "gmail",
-            triggerId: triggerId
-        });
+  it("should throw an error if trigger not found", async () => {
+    try {
+      await triggers.list({ triggerIds: ["INVALID_TRIGGER_ID"] });
+    } catch (e: unknown) {
+      const error = e as ComposioError;
+      expect(error.message).toContain("Trigger not found");
+    }
+  });
 
-        await triggers.unsubscribe();
+  // it("should subscribe to a trigger and receive a trigger", async () => {
+  //     function waitForTriggerReceived() {
+  //         return new Promise((resolve) => {
+  //             triggers.subscribe((data) => {
+  //                 resolve(data);
+  //             }, {
+  //                 appName: "github",
+  //                 triggerName: "GITHUB_ISSUE_ADDED_EVENT"
+  //             });
 
-    });
+  //             setTimeout(async () => {
+  //                 const actionName = "github_create_an_issue";
+  //                 // Not urgent
+  //                 const connectedAccountsResult = await connectedAccounts.list({ integrationId: 'ca85b86b-1198-4e1a-8d84-b14640564c77' });
+  //                 const connectionId = connectedAccountsResult.items[0].id;
 
+  //                 await actions.execute({
+  //                     actionName,
+  //                     requestBody: {
+  //                         connectedAccountId: connectionId,
+  //                         input: {
+  //                             title: "test",
+  //                             owner: "ComposioHQ",
+  //                             repo: "test_repo",
+  //                         },
+  //                         appName: 'github'
+  //                     }
+  //                 });
+  //             }, 4000);
+  //         });
+  //     }
+
+  //     const data = await waitForTriggerReceived();
+
+  //     //@ts-ignore
+  //     expect(data.payload.triggerName).toBe("GITHUB_ISSUE_ADDED_EVENT");
+
+  //     triggers.unsubscribe();
+  // });
 });
```
