@credal/actions 0.1.30 → 0.1.32

package/dist/actions/providers/ashby/searchCandidates.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axiosClient_1 = require("../../util/axiosClient");
+const searchCandidates = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { email, name } = params;
+    const { authToken } = authParams;
+    if (!authToken) {
+        throw new Error("Auth token is required");
+    }
+    const response = yield axiosClient_1.axiosClient.post(`https://api.ashbyhq.com/candidate.search`, {
+        email,
+        name,
+    }, {
+        auth: {
+            username: authToken,
+            password: "",
+        },
+    });
+    if (!response.data.success) {
+        throw new Error(response.data.errors.join("; "));
+    }
+    return {
+        candidates: response.data.results,
+    };
+});
+exports.default = searchCandidates;

package/dist/actions/providers/ashby/updateCandidate.d.ts

@@ -0,0 +1,3 @@
+import { ashbyUpdateCandidateFunction } from "../../autogen/types";
+declare const updateCandidate: ashbyUpdateCandidateFunction;
+export default updateCandidate;

package/dist/actions/providers/ashby/updateCandidate.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axiosClient_1 = require("../../util/axiosClient");
+const updateCandidate = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { authToken } = authParams;
+    if (!authToken) {
+        throw new Error("Auth token is required");
+    }
+    if (!params.candidateId) {
+        throw new Error("Candidate ID is required");
+    }
+    const body = {
+        candidateId: params.candidateId,
+    };
+    if (params.name !== undefined)
+        body.name = params.name;
+    if (params.email !== undefined)
+        body.email = params.email;
+    if (params.phoneNumber !== undefined)
+        body.phoneNumber = params.phoneNumber;
+    if (params.linkedInUrl !== undefined)
+        body.linkedInUrl = params.linkedInUrl;
+    if (params.githubUrl !== undefined)
+        body.githubUrl = params.githubUrl;
+    if (params.websiteUrl !== undefined)
+        body.websiteUrl = params.websiteUrl;
+    if (params.alternateEmail !== undefined)
+        body.alternateEmail = params.alternateEmail;
+    if (params.socialLinks !== undefined)
+        body.socialLinks = params.socialLinks;
+    if (params.sourceId !== undefined)
+        body.sourceId = params.sourceId;
+    if (params.creditedToUserId !== undefined)
+        body.creditedToUserId = params.creditedToUserId;
+    if (params.location !== undefined)
+        body.location = params.location;
+    if (params.createdAt !== undefined)
+        body.createdAt = params.createdAt;
+    if (params.sendNotifications !== undefined)
+        body.sendNotifications = params.sendNotifications;
+    const response = yield axiosClient_1.axiosClient.post(`https://api.ashbyhq.com/candidate.update`, body, {
+        auth: {
+            username: authToken,
+            password: "",
+        },
+    });
+    if (!response.data.success) {
+        throw new Error(response.data.errors.join("; "));
+    }
+});
+exports.default = updateCandidate;

package/dist/actions/providers/confluence/updatePage.js

@@ -8,28 +8,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const axiosClient_1 = require("../../util/axiosClient");
-function getConfluenceRequestConfig(baseUrl, username, apiToken) {
-    return {
+const axios_1 = __importDefault(require("axios"));
+function getConfluenceApi(baseUrl, username, apiToken) {
+    const api = axios_1.default.create({
         baseURL: baseUrl,
         headers: {
             Accept: "application/json",
+            // Tokens are associated with a specific user.
             Authorization: `Basic ${Buffer.from(`${username}:${apiToken}`).toString("base64")}`,
         },
-    };
+    });
+    return api;
 }
 const confluenceUpdatePage = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    const { pageId, content, title } = params;
-    const { baseUrl, authToken, username } = authParams;
-    if (!baseUrl || !authToken || !username) {
-        throw new Error("Missing required authentication information");
-    }
-    const config = getConfluenceRequestConfig(baseUrl, username, authToken);
+    const { pageId, username, content, title } = params;
+    const { baseUrl, authToken } = authParams;
+    const api = getConfluenceApi(baseUrl, username, authToken);
     // Get current version number
-    const response = yield axiosClient_1.axiosClient.get(`/api/v2/pages/${pageId}`, config);
+    const response = yield api.get(`/api/v2/pages/${pageId}`);
     const currVersion = response.data.version.number;
-    const payload = {
+    yield api.put(`/api/v2/pages/${pageId}`, {
         id: pageId,
         status: "current",
         title,
@@ -40,7 +42,6 @@ const confluenceUpdatePage = (_a) => __awaiter(void 0, [_a], void 0, function* (
         version: {
             number: currVersion + 1,
         },
-    };
-    yield axiosClient_1.axiosClient.put(`/api/v2/pages/${pageId}`, payload, config);
+    });
 });
 exports.default = confluenceUpdatePage;

package/dist/actions/providers/google-oauth/scheduleCalendarMeeting.d.ts

@@ -0,0 +1,6 @@
+import { googleOauthScheduleCalendarMeetingFunction } from "../../autogen/types";
+/**
+ * Creates a new Google calendar event using OAuth authentication
+ */
+declare const scheduleCalendarMeeting: googleOauthScheduleCalendarMeetingFunction;
+export default scheduleCalendarMeeting;

package/dist/actions/providers/google-oauth/scheduleCalendarMeeting.js

@@ -0,0 +1,74 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("uuid");
+const axiosClient_1 = require("../../util/axiosClient");
+/**
+ * Creates a new Google calendar event using OAuth authentication
+ */
+const scheduleCalendarMeeting = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    if (!authParams.authToken) {
+        throw new Error("authToken is required for Google Calendar API");
+    }
+    const { calendarId, name, start, end, description, attendees, useGoogleMeet } = params;
+    // https://developers.google.com/calendar/api/v3/reference/events/insert
+    let createEventApiUrl = `https://www.googleapis.com/calendar/v3/calendars/${calendarId}/events`;
+    const data = {
+        summary: name,
+        start: {
+            dateTime: start,
+        },
+        end: {
+            dateTime: end,
+        },
+    };
+    if (description) {
+        data.description = description;
+    }
+    if (attendees) {
+        data.attendees = attendees.map(attendee => ({ email: attendee }));
+    }
+    if (useGoogleMeet) {
+        createEventApiUrl += "?conferenceDataVersion=1";
+        data.conferenceData = {
+            createRequest: {
+                requestId: (0, uuid_1.v4)(),
+            },
+        };
+    }
+    try {
+        const response = yield axiosClient_1.axiosClient.post(createEventApiUrl, data, {
+            headers: {
+                Authorization: `Bearer ${authParams.authToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (response.status < 200 || response.status >= 300) {
+            return {
+                success: false,
+                error: response.data.error,
+            };
+        }
+        return {
+            success: true,
+            eventId: response.data.id,
+            eventUrl: response.data.htmlLink,
+        };
+    }
+    catch (error) {
+        console.error("Error scheduling calendar meeting", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+exports.default = scheduleCalendarMeeting;

package/dist/actions/providers/jira/assignJiraTicket.d.ts

@@ -0,0 +1,3 @@
+import { jiraAssignJiraTicketFunction } from "../../autogen/types";
+declare const assignJiraTicket: jiraAssignJiraTicketFunction;
+export default assignJiraTicket;

package/dist/actions/providers/jira/assignJiraTicket.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+const assignJiraTicket = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { authToken, cloudId, baseUrl } = authParams;
+    const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/`;
+    if (!cloudId || !authToken) {
+        throw new Error("Valid Cloud ID and auth token are required to assign Jira ticket");
+    }
+    try {
+        let assigneeId = params.assignee;
+        if (assigneeId && assigneeId.includes("@")) {
+            assigneeId = yield (0, utils_1.getUserAccountIdFromEmail)(assigneeId, apiUrl, authToken);
+        }
+        if (!assigneeId) {
+            throw new Error("Unable to get valid assignee account ID.");
+        }
+        yield axios_1.default.put(`${apiUrl}issue/${params.issueId}/assignee`, { accountId: assigneeId }, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+        });
+        return {
+            success: true,
+            ticketUrl: `${baseUrl}/browse/${params.issueId}`,
+        };
+    }
+    catch (error) {
+        const axiosError = error;
+        console.error("Error assigning issue:", axiosError);
+        return {
+            success: false,
+            error: axiosError.message,
+        };
+    }
+});
+exports.default = assignJiraTicket;

package/dist/actions/providers/jira/commentJiraTicket.d.ts

@@ -0,0 +1,3 @@
+import { jiraCommentJiraTicketFunction } from "../../autogen/types";
+declare const CommentJiraTicket: jiraCommentJiraTicketFunction;
+export default CommentJiraTicket;

package/dist/actions/providers/jira/commentJiraTicket.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axiosClient_1 = require("../../util/axiosClient");
+const CommentJiraTicket = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { authToken, cloudId, baseUrl } = authParams;
+    if (!cloudId || !(params === null || params === void 0 ? void 0 : params.issueId)) {
+        throw new Error("Cloud ID and Issue ID are required to comment on a Jira ticket");
+    }
+    const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/issue/${params.issueId}/comment`;
+    try {
+        const response = yield axiosClient_1.axiosClient.post(apiUrl, {
+            body: {
+                type: "doc",
+                version: 1,
+                content: [
+                    {
+                        type: "paragraph",
+                        content: [
+                            {
+                                type: "text",
+                                text: params.comment,
+                            },
+                        ],
+                    },
+                ],
+            },
+        }, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+        });
+        return {
+            success: true,
+            commentUrl: `${baseUrl}/browse/${params.issueId}?focusedCommentId=${response.data.id}`,
+        };
+    }
+    catch (error) {
+        console.error("Error commenting on Jira ticket: ", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+exports.default = CommentJiraTicket;

package/dist/actions/providers/jira/createJiraTicket.js

@@ -10,28 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const axiosClient_1 = require("../../util/axiosClient");
-function getUserAccountId(email, apiUrl, authToken) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const response = yield axiosClient_1.axiosClient.get(`${apiUrl}/user/search?query=${encodeURIComponent(email)}`, {
-                headers: {
-                    Authorization: `Bearer ${authToken}`,
-                    Accept: "application/json",
-                },
-            });
-            if (response.data && response.data.length > 0) {
-                return response.data[0].accountId;
-            }
-            return null;
-        }
-        catch (error) {
-            // Try to complete request without assignee/reporter.
-            const axiosError = error;
-            console.error("Error finding user:", axiosError.message);
-            return null;
-        }
-    });
-}
+const utils_1 = require("./utils");
 const createJiraTicket = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
     const { authToken, cloudId, baseUrl } = authParams;
     const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/`;
@@ -41,12 +20,12 @@ const createJiraTicket = (_a) => __awaiter(void 0, [_a], void 0, function* ({ pa
     // If assignee is an email, look up the account ID
     let reporterId = null;
     if (params.reporter && typeof params.reporter === "string" && params.reporter.includes("@") && authToken) {
-        reporterId = yield getUserAccountId(params.reporter, apiUrl, authToken);
+        reporterId = yield (0, utils_1.getUserAccountIdFromEmail)(params.reporter, apiUrl, authToken);
     }
     // If assignee is an email, look up the account ID
     let assigneeId = null;
     if (params.assignee && typeof params.assignee === "string" && params.assignee.includes("@") && authToken) {
-        assigneeId = yield getUserAccountId(params.assignee, apiUrl, authToken);
+        assigneeId = yield (0, utils_1.getUserAccountIdFromEmail)(params.assignee, apiUrl, authToken);
     }
     const description = {
         type: "doc",

package/dist/actions/providers/jira/utils.d.ts

@@ -0,0 +1 @@
+export declare function getUserAccountIdFromEmail(email: string, apiUrl: string, authToken: string): Promise<string | null>;

package/dist/actions/providers/jira/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserAccountIdFromEmail = getUserAccountIdFromEmail;
+const axiosClient_1 = require("../../util/axiosClient");
+function getUserAccountIdFromEmail(email, apiUrl, authToken) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield axiosClient_1.axiosClient.get(`${apiUrl}/user/search?query=${encodeURIComponent(email)}`, {
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    Accept: "application/json",
+                },
+            });
+            if (response.data && response.data.length > 0) {
+                return response.data[0].accountId;
+            }
+            return null;
+        }
+        catch (error) {
+            const axiosError = error;
+            console.error("Error finding user:", axiosError.message);
+            return null;
+        }
+    });
+}

package/dist/actions/providers/microsoft/messageTeamsChannel.d.ts

@@ -0,0 +1,3 @@
+import { microsoftMessageTeamsChannelFunction } from "../../autogen/types";
+declare const sendMessageToTeamsChannel: microsoftMessageTeamsChannelFunction;
+export default sendMessageToTeamsChannel;

package/dist/actions/providers/microsoft/messageTeamsChannel.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+const sendMessageToTeamsChannel = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { channelId, teamId, message } = params;
+    if (!teamId) {
+        return {
+            success: false,
+            error: "Team ID is required to send a message",
+        };
+    }
+    if (!channelId) {
+        return { success: false, error: "Channel ID is required to send a message" };
+    }
+    if (!message) {
+        return {
+            success: false,
+            error: "Message content is required to send a message",
+        };
+    }
+    try {
+        const messageId = yield (0, utils_1.sendMessage)(`/teams/${teamId}/channels/${channelId}/messages`, message, authParams);
+        return {
+            success: true,
+            messageId: messageId,
+        };
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+exports.default = sendMessageToTeamsChannel;

package/dist/actions/providers/microsoft/messageTeamsChat.d.ts

@@ -0,0 +1,3 @@
+import { microsoftMessageTeamsChatFunction } from "../../autogen/types";
+declare const sendMessageToTeamsChat: microsoftMessageTeamsChatFunction;
+export default sendMessageToTeamsChat;

package/dist/actions/providers/microsoft/messageTeamsChat.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+const sendMessageToTeamsChat = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { chatId, message } = params;
+    if (!chatId) {
+        return {
+            success: false,
+            error: "Chat ID is required to send a message",
+        };
+    }
+    if (!message) {
+        return {
+            success: false,
+            error: "Message content is required to send a message",
+        };
+    }
+    try {
+        const messageId = yield (0, utils_1.sendMessage)(`/chats/${chatId}/messages`, message, authParams);
+        return {
+            success: true,
+            messageId: messageId,
+        };
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+exports.default = sendMessageToTeamsChat;

package/dist/actions/providers/microsoft/utils.d.ts

@@ -0,0 +1,4 @@
+import { Client } from "@microsoft/microsoft-graph-client";
+import { AuthParamsType } from "../../autogen/types";
+export declare function getGraphClientForMessageSend(authParams: AuthParamsType): Promise<Client>;
+export declare function sendMessage(api_url: string, message: string, authParams: AuthParamsType): Promise<string>;

package/dist/actions/providers/microsoft/utils.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGraphClientForMessageSend = getGraphClientForMessageSend;
+exports.sendMessage = sendMessage;
+const microsoft_graph_client_1 = require("@microsoft/microsoft-graph-client");
+const axiosClient_1 = require("../../util/axiosClient");
+function getGraphClientForMessageSend(authParams) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!authParams.clientId ||
+            !authParams.clientSecret ||
+            !authParams.tenantId ||
+            !authParams.refreshToken ||
+            !authParams.redirectUri) {
+            throw new Error("Missing required authentication parameters");
+        }
+        const url = `https://login.microsoftonline.com/${authParams.tenantId}/oauth2/v2.0/token`;
+        const params = new URLSearchParams({
+            client_id: authParams.clientId,
+            client_secret: authParams.clientSecret,
+            scope: "offline_access ChannelMessage.Send ChatMessage.Send",
+            grant_type: "refresh_token",
+            refresh_token: authParams.refreshToken,
+            redirect_uri: authParams.redirectUri,
+        });
+        const response = yield axiosClient_1.axiosClient.post(url, params, {
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        });
+        const accessToken = response.data.access_token;
+        return microsoft_graph_client_1.Client.init({
+            authProvider: done => {
+                done(null, accessToken);
+            },
+        });
+    });
+}
+function sendMessage(api_url, message, authParams) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const client = yield getGraphClientForMessageSend(authParams);
+        const response = yield client.api(api_url).post({
+            body: {
+                content: message,
+            },
+        });
+        return response.id;
+    });
+}

package/dist/actions/providers/salesforce/createCase.d.ts

@@ -0,0 +1,3 @@
+import { salesforceCreateCaseFunction } from "../../autogen/types";
+declare const createCase: salesforceCreateCaseFunction;
+export default createCase;

package/dist/actions/providers/salesforce/createCase.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axiosClient_1 = require("../../util/axiosClient");
+const createCase = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { authToken, baseUrl } = authParams;
+    const { subject, description, priority, origin, customFields } = params;
+    if (!authToken || !baseUrl) {
+        return {
+            success: false,
+            error: "authToken and baseUrl are required for Salesforce API",
+        };
+    }
+    const url = `${baseUrl}/services/data/v56.0/sobjects/Case`;
+    const caseData = Object.assign({ Subject: subject, Description: description, Priority: priority, Origin: origin }, customFields);
+    try {
+        const response = yield axiosClient_1.axiosClient.post(url, caseData, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        return {
+            success: true,
+            caseId: response.data.id,
+        };
+    }
+    catch (error) {
+        console.error("Error creating Salesforce case:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "An unknown error occurred",
+        };
+    }
+});
+exports.default = createCase;

package/dist/actions/providers/salesforce/generateSalesReport.d.ts

@@ -0,0 +1,3 @@
+import { salesforceGenerateSalesReportFunction } from "../../autogen/types";
+declare const generateSalesReport: salesforceGenerateSalesReportFunction;
+export default generateSalesReport;