@credal/actions 0.1.31 → 0.1.34

package/dist/actions/providers/ashby/listCandidateNotes.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 });
+const axiosClient_1 = require("../../util/axiosClient");
+const listCandidateNotes = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { candidateId } = 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.listNotes`, {
+        candidateId,
+    }, {
+        auth: {
+            username: authToken,
+            password: "",
+        },
+    });
+    if (!response.data.success) {
+        throw new Error(response.data.errors.join("; "));
+    }
+    return {
+        notes: response.data.results,
+    };
+});
+exports.default = listCandidateNotes;

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

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

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

@@ -0,0 +1,31 @@
+"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 listCandidates = (_a) => __awaiter(void 0, [_a], void 0, function* ({ authParams, }) {
+    const { authToken } = authParams;
+    if (!authToken) {
+        throw new Error("Auth token is required");
+    }
+    const response = yield axiosClient_1.axiosClient.post(`https://api.ashbyhq.com/candidate.list`, null, {
+        auth: {
+            username: authToken,
+            password: "",
+        },
+    });
+    if (!response.data.success) {
+        throw new Error(response.data.errors.join("; "));
+    }
+    return {
+        candidates: response.data.results,
+    };
+});
+exports.default = listCandidates;

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

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

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

@@ -20,11 +20,8 @@ function getConfluenceRequestConfig(baseUrl, username, apiToken) {
     };
 }
 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 { pageId, username, content, title } = params;
+    const { baseUrl, authToken } = authParams;
     const config = getConfluenceRequestConfig(baseUrl, username, authToken);
     // Get current version number
     const response = yield axiosClient_1.axiosClient.get(`/api/v2/pages/${pageId}`, config);

package/dist/actions/providers/github/createBranch.d.ts

@@ -0,0 +1,6 @@
+import { githubCreateBranchFunction } from "../../autogen/types";
+/**
+ * Creates a new branch in a GitHub repository
+ */
+declare const createBranch: githubCreateBranchFunction;
+export default createBranch;

package/dist/actions/providers/github/createBranch.js

@@ -0,0 +1,68 @@
+"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 rest_1 = require("@octokit/rest");
+const request_error_1 = require("@octokit/request-error");
+/**
+ * Creates a new branch in a GitHub repository
+ */
+const createBranch = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    if (!authParams.authToken) {
+        return { success: false, error: "authToken is required for GitHub API" };
+    }
+    const { repositoryOwner, repositoryName, branchName, baseRefOrHash } = params;
+    const octokit = new rest_1.Octokit({ auth: authParams.authToken });
+    try {
+        // Get the reference or commit SHA for the base branch or tag
+        const { data: baseRefData } = yield octokit.git
+            .getRef({
+            owner: repositoryOwner,
+            repo: repositoryName,
+            ref: baseRefOrHash,
+        })
+            .catch((error) => __awaiter(void 0, void 0, void 0, function* () {
+            if (error.status === 404 && /^[a-f0-9]{40}$/i.test(baseRefOrHash)) {
+                // If baseRef is a full commit SHA and not a ref, use it directly
+                return { data: { object: { sha: baseRefOrHash } } };
+            }
+            else if (error.status === 404 && /^[a-f0-9]{7,39}$/i.test(baseRefOrHash)) {
+                // If baseRef is a short commit SHA, try to resolve it to a full SHA
+                const { data: commits } = yield octokit.repos.listCommits({
+                    owner: repositoryOwner,
+                    repo: repositoryName,
+                    sha: baseRefOrHash,
+                    per_page: 1,
+                });
+                if (commits.length > 0) {
+                    return { data: { object: { sha: commits[0].sha } } };
+                }
+            }
+            throw error;
+        }));
+        // Create a new branch from the base reference
+        yield octokit.git.createRef({
+            owner: repositoryOwner,
+            repo: repositoryName,
+            ref: `refs/heads/${branchName}`,
+            sha: baseRefData.object.sha,
+        });
+        return { success: true };
+    }
+    catch (error) {
+        if (error instanceof request_error_1.RequestError) {
+            console.error("GitHub API error:", error.message);
+            return { success: false, error: error.message };
+        }
+        console.error("Unexpected error:", error);
+        return { success: false, error: error instanceof Error ? error.message : "An unexpected error occurred" };
+    }
+});
+exports.default = createBranch;

package/dist/actions/providers/github/createOrUpdateFile.d.ts

@@ -0,0 +1,6 @@
+import { githubCreateOrUpdateFileFunction } from "../../autogen/types";
+/**
+ * Creates or updates a file in a GitHub repository
+ */
+declare const createOrUpdateFile: githubCreateOrUpdateFileFunction;
+export default createOrUpdateFile;

package/dist/actions/providers/github/createOrUpdateFile.js

@@ -0,0 +1,75 @@
+"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 rest_1 = require("@octokit/rest");
+const request_error_1 = require("@octokit/request-error");
+const zod_1 = require("zod");
+/**
+ * Creates or updates a file in a GitHub repository
+ */
+const createOrUpdateFile = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    if (!authParams.authToken) {
+        return { success: false, error: "authToken is required for GitHub API" };
+    }
+    const { repositoryOwner, repositoryName, filePath, branch, fileContent, commitMessage } = params;
+    const octokit = new rest_1.Octokit({ auth: authParams.authToken });
+    let fileSha = undefined;
+    let operationPreformed = undefined;
+    try {
+        const { data: fileData } = yield octokit.repos.getContent({
+            owner: repositoryOwner,
+            repo: repositoryName,
+            path: filePath,
+            ref: branch,
+        });
+        if (params.noOverwrite) {
+            return { success: false, error: "Path already exists and noOverwrite is set to true." };
+        }
+        if (Array.isArray(fileData)) {
+            console.error(`Error: Path is a directory, not a file. Path: ${filePath}`);
+            return { success: false, error: `Path is a directory, not a file. Path: ${filePath}` };
+        }
+        fileSha = fileData.sha;
+        operationPreformed = "updated";
+    }
+    catch (error) {
+        if (error instanceof request_error_1.RequestError && error.status === 404) {
+            console.log(`File not found, creating new file.`);
+            operationPreformed = "created";
+        }
+        else {
+            return { success: false, error: error instanceof Error ? error.message : "An unknown error occurred" };
+        }
+    }
+    try {
+        const { data: commitData } = yield octokit.repos.createOrUpdateFileContents({
+            owner: repositoryOwner,
+            repo: repositoryName,
+            path: filePath,
+            message: commitMessage,
+            content: Buffer.from(fileContent).toString("base64"),
+            branch,
+            sha: fileSha,
+        });
+        const OperationEnum = zod_1.z.enum(["created", "updated"]);
+        return {
+            success: true,
+            newCommitSha: commitData.commit.sha,
+            operation: OperationEnum.parse(operationPreformed),
+        };
+    }
+    catch (error) {
+        console.error("Error creating or updating file:", error);
+        const errorMessage = error instanceof Error ? error.message : "An unknown error occurred";
+        return { success: false, error: errorMessage };
+    }
+});
+exports.default = createOrUpdateFile;

package/dist/actions/providers/github/createPullRequest.d.ts

@@ -0,0 +1,6 @@
+import { githubCreatePullRequestFunction } from "../../autogen/types";
+/**
+ * Creates a pull request in a GitHub repository
+ */
+declare const createPullRequest: githubCreatePullRequestFunction;
+export default createPullRequest;

package/dist/actions/providers/github/createPullRequest.js

@@ -0,0 +1,48 @@
+"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 rest_1 = require("@octokit/rest");
+const request_error_1 = require("@octokit/request-error");
+/**
+ * Creates a pull request in a GitHub repository
+ */
+const createPullRequest = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    if (!authParams.authToken) {
+        return { success: false, error: "authToken is required for GitHub API" };
+    }
+    const { repositoryOwner, repositoryName, head, base, title, description } = params;
+    const octokit = new rest_1.Octokit({ auth: authParams.authToken });
+    try {
+        // Create the pull request
+        const { data: pullRequestData } = yield octokit.pulls.create({
+            owner: repositoryOwner,
+            repo: repositoryName,
+            head,
+            base,
+            title,
+            body: description,
+        });
+        return {
+            success: true,
+            pullRequestUrl: pullRequestData.html_url,
+            pullRequestNumber: pullRequestData.number,
+        };
+    }
+    catch (error) {
+        if (error instanceof request_error_1.RequestError) {
+            console.error("GitHub API error:", error.message);
+            return { success: false, error: error.message };
+        }
+        console.error("Unexpected error:", error);
+        return { success: false, error: "An unexpected error occurred" };
+    }
+});
+exports.default = createPullRequest;

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

@@ -0,0 +1,6 @@
+import { googleOauthCreatePresentationFunction } from "../../autogen/types";
+/**
+ * Creates a new Google Slides presentation using OAuth authentication
+ */
+declare const createPresentation: googleOauthCreatePresentationFunction;
+export default createPresentation;

package/dist/actions/providers/google-oauth/createPresentation.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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axiosClient_1 = require("../../util/axiosClient");
+/**
+ * Creates a new Google Slides presentation using OAuth authentication
+ */
+const createPresentation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    if (!authParams.authToken) {
+        throw new Error("authToken is required for Google Slides API");
+    }
+    const { title, pageSize } = params;
+    const baseApiUrl = "https://slides.googleapis.com/v1/presentations";
+    const requestBody = Object.assign({ title }, (pageSize && { pageSize }));
+    try {
+        const response = yield axiosClient_1.axiosClient.post(baseApiUrl, requestBody, {
+            headers: {
+                Authorization: `Bearer ${authParams.authToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (response.status < 200 || response.status >= 300) {
+            return {
+                success: false,
+                error: response.statusText,
+            };
+        }
+        const { presentationId } = response.data;
+        const presentationUrl = `https://docs.google.com/presentation/d/${presentationId}/edit`;
+        return {
+            success: true,
+            presentationId,
+            presentationUrl,
+        };
+    }
+    catch (error) {
+        console.error("Error creating presentation:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+exports.default = createPresentation;

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

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

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

@@ -0,0 +1,62 @@
+"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"));
+/**
+ * Creates a new Google Spreadsheet using OAuth authentication
+ */
+const createSpreadsheet = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    if (!authParams.authToken) {
+        throw new Error("authToken is required for Google Sheets API");
+    }
+    const { title, sheets = [], properties = {} } = params;
+    const baseApiUrl = "https://sheets.googleapis.com/v4/spreadsheets";
+    const requestBody = {
+        properties: Object.assign({ title }, properties),
+        sheets: sheets.map(sheet => ({ properties: sheet })),
+    };
+    try {
+        const response = yield axios_1.default.post(baseApiUrl, requestBody, {
+            headers: {
+                Authorization: `Bearer ${authParams.authToken}`,
+            },
+        });
+        if (response.status < 200 || response.status >= 300) {
+            return {
+                success: false,
+                error: response.statusText,
+            };
+        }
+        const { spreadsheetId, sheets: createdSheets } = response.data;
+        const spreadsheetUrl = `https://docs.google.com/spreadsheets/d/${spreadsheetId}`;
+        return {
+            success: true,
+            spreadsheetId,
+            spreadsheetUrl,
+            sheets: createdSheets.map((sheet) => ({
+                sheetId: sheet.properties.sheetId,
+                title: sheet.properties.title,
+                index: sheet.properties.index,
+            })),
+        };
+    }
+    catch (error) {
+        console.error("Error creating spreadsheet:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+exports.default = createSpreadsheet;

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/google-oauth/updateDoc.d.ts

@@ -0,0 +1,7 @@
+import { googleOauthUpdateDocFunction } from "../../autogen/types";
+/**
+ * Updates an existing Google Docs document using OAuth authentication with batch requests
+ * https://developers.google.com/workspace/docs/api/reference/rest/v1/documents/batchUpdate
+ */
+declare const updateDoc: googleOauthUpdateDocFunction;
+export default updateDoc;