@credal/actions 0.2.203 → 0.2.206

package/dist/actions/providers/jamf/getJamfUserComputerId.d.ts

@@ -0,0 +1,3 @@
+import type { jamfGetJamfUserComputerIdFunction } from "../../autogen/types.js";
+declare const getJamfUserComputerId: jamfGetJamfUserComputerIdFunction;
+export default getJamfUserComputerId;

package/dist/actions/providers/jamf/getJamfUserComputerId.js

@@ -0,0 +1,45 @@
+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());
+    });
+};
+import { axiosClient } from "../../util/axiosClient.js";
+const getJamfUserComputerId = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { authToken, subdomain } = authParams;
+    const { userEmail } = params;
+    if (!subdomain || !authToken) {
+        throw new Error("Instance and authToken are required to fetch Jamf user computer ID");
+    }
+    const url = `https://${subdomain}.jamfcloud.com`;
+    try {
+        const computers = yield axiosClient.get(`${url}/api/v1/computers-inventory`, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+            },
+        });
+        const filteredComputers = computers.data.results.filter(computer => { var _a; return ((_a = computer.userAndLocation) === null || _a === void 0 ? void 0 : _a.email) === userEmail; });
+        if (filteredComputers.length === 0) {
+            return {
+                success: false,
+                error: `No computers found for user with email: ${userEmail}`,
+            };
+        }
+        return {
+            success: true,
+            computerId: filteredComputers[0].id,
+        };
+    }
+    catch (error) {
+        console.error("Error retrieving Jamf user computer ID: ", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+export default getJamfUserComputerId;

package/dist/actions/providers/jamf/lockJamfComputerById.d.ts

@@ -0,0 +1,3 @@
+import type { jamfLockJamfComputerByIdFunction } from "../../autogen/types.js";
+declare const lockJamfComputerById: jamfLockJamfComputerByIdFunction;
+export default lockJamfComputerById;

package/dist/actions/providers/jamf/lockJamfComputerById.js

@@ -0,0 +1,39 @@
+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());
+    });
+};
+import { axiosClient } from "../../util/axiosClient.js";
+const lockJamfComputerById = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { authToken, subdomain } = authParams;
+    const { computerId, passcode } = params;
+    if (!subdomain || !authToken) {
+        throw new Error("Instance and authToken are required to fetch Jamf user computer ID");
+    }
+    const url = `https://${subdomain}.jamfcloud.com`;
+    try {
+        yield axiosClient.post(`${url}/JSSResource/computercommands/command/DeviceLock/id/${computerId}`, {
+            passcode,
+        }, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+            },
+        });
+        return {
+            success: true,
+        };
+    }
+    catch (error) {
+        console.error("Error locking Jamf computer: ", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+export default lockJamfComputerById;

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

@@ -0,0 +1,3 @@
+import type { jiraCommentJiraTicketWithMentionsFunction } from "../../autogen/types.js";
+declare const commentJiraTicketWithMentions: jiraCommentJiraTicketWithMentionsFunction;
+export default commentJiraTicketWithMentions;

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

@@ -0,0 +1,39 @@
+import { axiosClient } from "../../util/axiosClient.js";
+import { getJiraApiConfig, getErrorMessage } from "./utils.js";
+import { extractMentions, insertMentionNodes } from "./convertMentionsInAdf.js";
+import { markdownToAdf } from "marklassian";
+const commentJiraTicketWithMentions = async ({ params, authParams, }) => {
+    const { authToken } = authParams;
+    const { issueId, comment } = params;
+    try {
+        const { apiUrl, browseUrl, isDataCenter } = getJiraApiConfig(authParams);
+        if (isDataCenter) {
+            return {
+                success: false,
+                error: "commentJiraTicketWithMentions is only supported on Jira Cloud. Use commentJiraTicket for Jira Data Center.",
+            };
+        }
+        const { sanitized, mentions } = extractMentions(comment);
+        const adf = markdownToAdf(sanitized);
+        const body = insertMentionNodes(adf, mentions);
+        const response = await axiosClient.post(`${apiUrl}/issue/${issueId}/comment`, { body }, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+        });
+        return {
+            success: true,
+            commentUrl: `${browseUrl}/browse/${issueId}?focusedCommentId=${response.data.id}`,
+        };
+    }
+    catch (error) {
+        console.error("Error commenting on Jira ticket with mentions: ", error);
+        return {
+            success: false,
+            error: getErrorMessage(error),
+        };
+    }
+};
+export default commentJiraTicketWithMentions;

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

@@ -0,0 +1,21 @@
+/**
+ * Extracts [~accountid:XXXXX] patterns from raw text and replaces them with
+ * safe placeholders that won't be mangled by markdown parsers.
+ *
+ * Use with {@link insertMentionNodes} after markdown-to-ADF conversion.
+ */
+export declare function extractMentions(text: string): {
+    sanitized: string;
+    mentions: string[];
+};
+/**
+ * Walks an ADF tree and replaces placeholder tokens (produced by
+ * {@link extractMentions}) with proper ADF mention nodes.
+ */
+export declare function insertMentionNodes(adf: unknown, mentions: string[]): unknown;
+/**
+ * Walks an ADF tree and converts raw [~accountid:XXXXX] text patterns into
+ * ADF mention nodes. Works reliably for single mentions per paragraph; for
+ * multiple mentions use extractMentions + insertMentionNodes instead.
+ */
+export declare function convertMentionsInAdf(adf: unknown): unknown;

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

@@ -0,0 +1,125 @@
+const JIRA_MENTION_SOURCE = "\\[~accountid:([^\\]]+)\\]";
+const JIRA_MENTION_TEST = new RegExp(JIRA_MENTION_SOURCE);
+const PLACEHOLDER_PREFIX = "\uFFFCMENTION_";
+const PLACEHOLDER_SUFFIX = "\uFFFC";
+/**
+ * Extracts [~accountid:XXXXX] patterns from raw text and replaces them with
+ * safe placeholders that won't be mangled by markdown parsers.
+ *
+ * Use with {@link insertMentionNodes} after markdown-to-ADF conversion.
+ */
+export function extractMentions(text) {
+    const mentions = [];
+    const sanitized = text.replace(new RegExp(JIRA_MENTION_SOURCE, "g"), (_match, id) => {
+        const index = mentions.length;
+        mentions.push(id);
+        return `${PLACEHOLDER_PREFIX}${index}${PLACEHOLDER_SUFFIX}`;
+    });
+    return { sanitized, mentions };
+}
+/**
+ * Walks an ADF tree and replaces placeholder tokens (produced by
+ * {@link extractMentions}) with proper ADF mention nodes.
+ */
+export function insertMentionNodes(adf, mentions) {
+    if (mentions.length === 0)
+        return adf;
+    const placeholderRegex = new RegExp(`${escapeRegex(PLACEHOLDER_PREFIX)}(\\d+)${escapeRegex(PLACEHOLDER_SUFFIX)}`);
+    return walkAndReplace(adf, placeholderRegex, mentions);
+}
+/**
+ * Walks an ADF tree and converts raw [~accountid:XXXXX] text patterns into
+ * ADF mention nodes. Works reliably for single mentions per paragraph; for
+ * multiple mentions use extractMentions + insertMentionNodes instead.
+ */
+export function convertMentionsInAdf(adf) {
+    if (!adf || typeof adf !== "object")
+        return adf;
+    if (Array.isArray(adf))
+        return adf.flatMap(item => {
+            const result = convertMentionsInAdf(item);
+            return Array.isArray(result) ? result : [result];
+        });
+    const node = adf;
+    if (node.type === "text" && typeof node.text === "string" && JIRA_MENTION_TEST.test(node.text)) {
+        return splitTextNodeWithMentions(node, new RegExp(JIRA_MENTION_SOURCE, "g"), (_match, groups) => groups[0]);
+    }
+    if (Array.isArray(node.content)) {
+        const newContent = [];
+        for (const child of node.content) {
+            const result = convertMentionsInAdf(child);
+            if (Array.isArray(result)) {
+                newContent.push(...result);
+            }
+            else {
+                newContent.push(result);
+            }
+        }
+        return { ...node, content: newContent };
+    }
+    return node;
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function walkAndReplace(adf, regex, mentions) {
+    if (!adf || typeof adf !== "object")
+        return adf;
+    if (Array.isArray(adf))
+        return adf.flatMap(item => {
+            const result = walkAndReplace(item, regex, mentions);
+            return Array.isArray(result) ? result : [result];
+        });
+    const node = adf;
+    if (node.type === "text" && typeof node.text === "string" && regex.test(node.text)) {
+        return splitTextNodeWithMentions(node, new RegExp(`${escapeRegex(PLACEHOLDER_PREFIX)}(\\d+)${escapeRegex(PLACEHOLDER_SUFFIX)}`, "g"), (_match, groups) => mentions[parseInt(groups[0], 10)]);
+    }
+    if (Array.isArray(node.content)) {
+        const newContent = [];
+        for (const child of node.content) {
+            const result = walkAndReplace(child, regex, mentions);
+            if (Array.isArray(result)) {
+                newContent.push(...result);
+            }
+            else {
+                newContent.push(result);
+            }
+        }
+        return { ...node, content: newContent };
+    }
+    return node;
+}
+function splitTextNodeWithMentions(node, regex, resolveId) {
+    const text = node.text;
+    const marks = node.marks;
+    const results = [];
+    let lastIndex = 0;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        if (match.index > lastIndex) {
+            const textNode = { type: "text", text: text.slice(lastIndex, match.index) };
+            if (marks)
+                textNode.marks = marks;
+            results.push(textNode);
+        }
+        results.push({
+            type: "mention",
+            attrs: {
+                id: resolveId(match[0], match.slice(1)),
+                text: `@${resolveId(match[0], match.slice(1))}`,
+                accessLevel: "",
+            },
+        });
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        const textNode = { type: "text", text: text.slice(lastIndex) };
+        if (marks)
+            textNode.marks = marks;
+        results.push(textNode);
+    }
+    return results;
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

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

@@ -0,0 +1,3 @@
+import type { jiraUpdateServiceDeskRequestFunction } from "../../autogen/types.js";
+declare const updateServiceDeskRequest: jiraUpdateServiceDeskRequestFunction;
+export default updateServiceDeskRequest;

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

@@ -0,0 +1,72 @@
+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());
+    });
+};
+import { axiosClient } from "../../util/axiosClient.js";
+const updateServiceDeskRequest = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { issueId, requestTypeId, summary, description, priority, customFields } = params;
+    const { authToken, cloudId, baseUrl } = authParams;
+    if (!cloudId || !authToken) {
+        throw new Error("Valid Cloud ID and auth token are required to update service desk request");
+    }
+    // Use the regular Jira API for updating service desk requests as they are still Jira issues
+    const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/issue/${issueId}`;
+    const formattedDescription = description
+        ? {
+            type: "doc",
+            version: 1,
+            content: [
+                {
+                    type: "paragraph",
+                    content: [
+                        {
+                            type: "text",
+                            text: description,
+                        },
+                    ],
+                },
+            ],
+        }
+        : undefined;
+    const payload = {
+        fields: Object.assign(Object.assign(Object.assign(Object.assign({}, (summary && { summary })), (formattedDescription && { description: formattedDescription })), (priority && { priority: { name: priority } })), (customFields && Object.assign({}, customFields))),
+    };
+    try {
+        yield axiosClient.put(apiUrl, payload, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+        });
+        // Get the updated issue details to return current status and web link
+        const getResponse = yield axiosClient.get(apiUrl, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+            },
+        });
+        const issueKey = getResponse.data.key;
+        const currentStatus = getResponse.data.fields.status.name;
+        const webLink = `${baseUrl}/browse/${issueKey}`;
+        return {
+            success: true,
+            issueKey,
+            webLink,
+            currentStatus,
+        };
+    }
+    catch (error) {
+        console.error("Error updating service desk request:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+export default updateServiceDeskRequest;

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

@@ -70,5 +70,5 @@ export declare function getUserInfoFromAccountId(accountId: string | undefined,
     name: string | undefined;
     email: string | undefined;
 } | null>;
+export { convertMentionsInAdf } from "./convertMentionsInAdf.js";
 export declare function extractPlainText(adf: unknown): string;
-export {};

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

@@ -200,6 +200,7 @@ export async function getUserInfoFromAccountId(accountId, client) {
         return null;
     }
 }
+export { convertMentionsInAdf } from "./convertMentionsInAdf.js";
 export function extractPlainText(adf) {
     if (!adf || typeof adf !== "object")
         return "";

package/dist/actions/providers/kandji/getFVRecoveryKeyForDevice.d.ts

@@ -0,0 +1,3 @@
+import { type kandjiGetFVRecoveryKeyForDeviceFunction } from "../../autogen/types.js";
+declare const getFVRecoveryKeyForDevice: kandjiGetFVRecoveryKeyForDeviceFunction;
+export default getFVRecoveryKeyForDevice;

package/dist/actions/providers/kandji/getFVRecoveryKeyForDevice.js

@@ -0,0 +1,85 @@
+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());
+    });
+};
+import { axiosClient } from "../../util/axiosClient.js";
+const getFVRecoveryKeyForDevice = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { userEmail, subdomain } = params;
+    const { apiKey } = authParams;
+    if (!apiKey) {
+        throw new Error("Missing API key in auth parameters");
+    }
+    try {
+        // First list all devices to get the device for the specific device
+        const device = yield getDeviceByEmail({
+            apiKey,
+            userEmail,
+            subdomain,
+        });
+        if (!device) {
+            return {
+                success: false,
+                error: "Device not found for the given serial number",
+            };
+        }
+        // Then get the FV recovery key for that device
+        const fvRecoveryKey = yield axiosClient.get(`https://${subdomain}.api.kandji.io/api/v1/devices/${device.device_id}/secrets/filevaultkey`, {
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+        });
+        if (!fvRecoveryKey || !fvRecoveryKey.data || !fvRecoveryKey.data.key) {
+            return {
+                success: false,
+                error: "FireVault recovery key not found",
+            };
+        }
+        return {
+            success: true,
+            recoveryKey: fvRecoveryKey.data.key,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+function getDeviceByEmail(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const limit = 300;
+        let offset = 0;
+        const { apiKey, userEmail, subdomain } = input;
+        while (true) {
+            // Update params
+            const params = { limit, offset };
+            const endpoint = `https://${subdomain}.api.kandji.io/api/v1/devices`;
+            const response = yield axiosClient.get(endpoint, {
+                params: Object.assign({}, params),
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+            });
+            for (const device of response.data) {
+                if (device.user && device.user.email === userEmail) {
+                    // If the device user email matches, return the device
+                    return device;
+                }
+            }
+            offset += limit;
+            if (response.data.length === 0) {
+                break;
+            }
+        }
+        return null;
+    });
+}
+export default getFVRecoveryKeyForDevice;

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

@@ -0,0 +1,3 @@
+import type { microsoftSendOutlookEmailFunction } from "../../autogen/types.js";
+declare const sendEmail: microsoftSendOutlookEmailFunction;
+export default sendEmail;

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

@@ -0,0 +1,48 @@
+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());
+    });
+};
+import { getGraphClient } from "./utils.js";
+const sendEmail = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { toRecipients, subject, body, ccRecipients, bccRecipients } = params;
+    let client = undefined;
+    try {
+        client = yield getGraphClient(authParams);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: "Error while authorizing: " + (error instanceof Error ? error.message : "Unknown error"),
+        };
+    }
+    try {
+        const message = {
+            message: Object.assign(Object.assign({ subject, body: {
+                    contentType: "HTML",
+                    content: body,
+                }, toRecipients: toRecipients.map(email => ({ emailAddress: { address: email } })) }, (ccRecipients && ccRecipients.length > 0
+                ? { ccRecipients: ccRecipients.map(email => ({ emailAddress: { address: email } })) }
+                : {})), (bccRecipients && bccRecipients.length > 0
+                ? { bccRecipients: bccRecipients.map(email => ({ emailAddress: { address: email } })) }
+                : {})),
+            saveToSentItems: true,
+        };
+        yield client.api("/me/sendMail").post(message);
+        return {
+            success: true,
+        };
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            success: false,
+            error: "Error sending email: " + (error instanceof Error ? error.message : "Unknown error"),
+        };
+    }
+});
+export default sendEmail;

package/dist/actions/providers/okta/addUserToGroup.d.ts

@@ -0,0 +1,3 @@
+import type { oktaAddUserToGroupFunction } from "../../autogen/types.js";
+declare const addUserToGroup: oktaAddUserToGroupFunction;
+export default addUserToGroup;

package/dist/actions/providers/okta/addUserToGroup.js

@@ -0,0 +1,56 @@
+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());
+    });
+};
+import { AxiosError } from "axios";
+import { axiosClient } from "../../util/axiosClient.js";
+const addUserToGroup = (_a) => __awaiter(void 0, [_a], void 0, function* ({ authParams, params, }) {
+    var _b, _c;
+    const { authToken, baseUrl } = authParams;
+    if (!authToken || !baseUrl) {
+        return {
+            success: false,
+            error: "Missing Okta OAuth token (authToken) or base URL (baseUrl) in authParams.",
+        };
+    }
+    try {
+        const requestConfig = {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+        };
+        const endpointUrl = new URL(`/api/v1/groups/${params.groupId}/users/${params.userId}`, baseUrl).toString();
+        const response = yield axiosClient.put(endpointUrl, {}, requestConfig);
+        if (response.status === 204) {
+            return { success: true };
+        }
+        else {
+            const errorDetail = ((_b = response.data) === null || _b === void 0 ? void 0 : _b.errorSummary) || ((_c = response.data) === null || _c === void 0 ? void 0 : _c.message) || `Okta API responded with status ${response.status}`;
+            return { success: false, error: `Failed to add user to group: ${errorDetail}` };
+        }
+    }
+    catch (error) {
+        console.error("Error adding user to group:", error);
+        let errorMessage = "Unknown error while adding user to group";
+        if (error instanceof AxiosError && error.response) {
+            const oktaError = error.response.data;
+            errorMessage =
+                (oktaError === null || oktaError === void 0 ? void 0 : oktaError.errorSummary) || (oktaError === null || oktaError === void 0 ? void 0 : oktaError.message) || `Okta API request failed with status ${error.response.status}`;
+        }
+        else if (error instanceof Error) {
+            errorMessage = error.message;
+        }
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+});
+export default addUserToGroup;

package/dist/actions/providers/okta/getOktaGroup.d.ts

@@ -0,0 +1,3 @@
+import type { oktaGetOktaGroupFunction } from "../../autogen/types.js";
+declare const getOktaGroup: oktaGetOktaGroupFunction;
+export default getOktaGroup;