@credal/actions 0.0.1

package/dist/actions/providers/mongodb/insertMongoDoc.js

@@ -0,0 +1,36 @@
+"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 mongodb_1 = require("mongodb");
+const insertMongoDoc = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { baseUrl } = authParams;
+    const { collectionName, databaseName, document } = params;
+    if (!baseUrl)
+        throw new Error("baseUrl is required to connect to the mongodb cluster");
+    const client = new mongodb_1.MongoClient(baseUrl);
+    try {
+        yield client.connect();
+        console.log("Connected successfully to MongoDB");
+        const db = client.db(databaseName);
+        const collection = db.collection(collectionName);
+        const insert = yield collection.insertOne(document);
+        const objectId = insert.insertedId.toString();
+        return { objectId };
+    }
+    catch (error) {
+        console.error("Error connecting to MongoDB or performing operations", error);
+        throw error;
+    }
+    finally {
+        yield client.close();
+    }
+});
+exports.default = insertMongoDoc;

package/dist/actions/providers/slack/helpers.d.ts

@@ -0,0 +1,6 @@
+import { WebClient } from "@slack/web-api";
+import { Channel } from "@slack/web-api/dist/types/response/ConversationsListResponse";
+export type ChannelWithId = Channel & {
+    id: string;
+};
+export declare function getSlackChannels(client: WebClient): Promise<ChannelWithId[]>;

package/dist/actions/providers/slack/helpers.js

@@ -0,0 +1,53 @@
+"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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSlackChannels = getSlackChannels;
+function getSlackChannels(client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const limit = 100;
+        const allChannels = [];
+        const allChannelsIterable = yield client.paginate("conversations.list", {
+            exclude_archived: true,
+            limit,
+        });
+        try {
+            for (var _d = true, _e = __asyncValues(allChannelsIterable), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const page = _c;
+                if (!page.channels)
+                    continue; // Not expected
+                for (const channel of page.channels) {
+                    const channelId = channel.id;
+                    if (channelId) {
+                        allChannels.push(Object.assign(Object.assign({}, channel), { id: channelId }));
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return allChannels;
+    });
+}

package/dist/actions/providers/slack/index.d.ts

@@ -0,0 +1 @@
+export * as listConversations from "./listConversations";

package/dist/actions/providers/slack/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listConversations = void 0;
+exports.listConversations = __importStar(require("./listConversations"));

package/dist/actions/providers/slack/listConversations.d.ts

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

package/dist/actions/providers/slack/listConversations.js

@@ -0,0 +1,41 @@
+"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 web_api_1 = require("@slack/web-api");
+const helpers_1 = require("./helpers");
+const slackListConversations = (_a) => __awaiter(void 0, [_a], void 0, function* ({ authParams, }) {
+    const client = new web_api_1.WebClient(authParams.authToken);
+    try {
+        const allChannels = yield (0, helpers_1.getSlackChannels)(client);
+        const filteredChannels = [];
+        for (const channel of allChannels) {
+            if (channel.name && channel.topic && channel.topic.value && channel.purpose && channel.purpose.value) {
+                const purpose = channel.purpose.value;
+                const topic = channel.topic.value;
+                const name = channel.name;
+                filteredChannels.push(Object.assign(Object.assign({}, channel), { purpose, topic, name }));
+            }
+        }
+        return {
+            channels: filteredChannels,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            // Enhance error with more context
+            throw new Error(`Failed to list Slack conversations: ${error.message}`);
+        }
+        else {
+            throw error;
+        }
+    }
+});
+exports.default = slackListConversations;

package/dist/actions/providers/slack/list_conversations.d.ts

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

package/dist/actions/providers/slack/list_conversations.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 web_api_1 = require("@slack/web-api");
+const slackListConversations = (_a) => __awaiter(void 0, [_a], void 0, function* ({ authParams, }) {
+    var _b;
+    const client = new web_api_1.WebClient(authParams.authToken);
+    const allChannels = [];
+    let cursor;
+    const limit = 100;
+    try {
+        do {
+            const response = yield client.conversations.list({
+                exclude_archived: true,
+                limit: limit,
+                cursor: cursor,
+            });
+            if (!response.ok) {
+                throw new Error(`Slack API error: ${response.error}`);
+            }
+            // Add channels from this page to our results
+            if (response.channels && Array.isArray(response.channels)) {
+                allChannels.push(...response.channels);
+            }
+            // Get cursor for next page
+            cursor = (_b = response.response_metadata) === null || _b === void 0 ? void 0 : _b.next_cursor;
+            // If user specified a limit and we've hit it, stop paginating
+            if (limit && allChannels.length >= limit) {
+                allChannels.splice(limit); // Trim to exact limit
+                break;
+            }
+        } while (cursor && cursor.length > 0);
+        return {
+            channels: allChannels.map(channel => ({
+                id: channel.id,
+                name: channel.name,
+                topic: channel.topic.value,
+                purpose: channel.purpose.value,
+            })),
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            // Enhance error with more context
+            throw new Error(`Failed to list Slack conversations: ${error.message}`);
+        }
+        else {
+            throw error;
+        }
+    }
+});
+exports.default = slackListConversations;

package/dist/actions/providers/slack/sendMessage.d.ts

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

package/dist/actions/providers/slack/sendMessage.js

@@ -0,0 +1,36 @@
+"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 web_api_1 = require("@slack/web-api");
+const helpers_1 = require("./helpers");
+const sendMessage = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const client = new web_api_1.WebClient(authParams.authToken);
+    const { channelName, message } = params;
+    const allChannels = yield (0, helpers_1.getSlackChannels)(client);
+    const channel = allChannels.find(channel => channel.name == channelName);
+    if (!channel || !channel.id) {
+        throw Error(`Channel with name ${channelName} not found`);
+    }
+    yield client.chat.postMessage({
+        channel: channel.id,
+        blocks: [
+            {
+                type: "section",
+                text: {
+                    type: "mrkdwn",
+                    text: message,
+                },
+            },
+        ],
+    });
+    return;
+});
+exports.default = sendMessage;

package/dist/actions/providers/snowflake/getRowByFieldValue.d.ts

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

package/dist/actions/providers/snowflake/getRowByFieldValue.js

@@ -0,0 +1,100 @@
+"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 snowflake_sdk_1 = __importDefault(require("snowflake-sdk"));
+const crypto_1 = __importDefault(require("crypto"));
+const getRowByFieldValue = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { databaseName, tableName, fieldName, warehouse, fieldValue, user, accountName } = params;
+    const { apiKey: privateKey } = authParams;
+    if (!privateKey) {
+        throw new Error("Private key is required");
+    }
+    const buffer = Buffer.from(privateKey);
+    const privateKeyObject = crypto_1.default.createPrivateKey({
+        key: buffer,
+        format: "pem",
+        passphrase: "password",
+    });
+    const privateKeyCorrectFormat = privateKeyObject.export({
+        format: "pem",
+        type: "pkcs8",
+    });
+    const privateKeyCorrectFormatString = privateKeyCorrectFormat.toString();
+    if (!accountName || !user || !databaseName || !warehouse || !tableName || !fieldName || !fieldValue) {
+        throw new Error("Account name and user are required");
+    }
+    // Set up a connection using snowflake-sdk
+    const connection = snowflake_sdk_1.default.createConnection({
+        account: accountName,
+        username: user,
+        privateKey: privateKeyCorrectFormatString,
+        authenticator: "SNOWFLAKE_JWT",
+        role: "ACCOUNTADMIN", // If you have specific role requirements
+        warehouse: warehouse, // Similarly for warehouse
+        database: databaseName,
+        schema: "PUBLIC",
+    });
+    try {
+        yield new Promise((resolve, reject) => {
+            connection.connect((err, conn) => {
+                if (err) {
+                    console.error("Unable to connect:", err.message);
+                    return reject(err);
+                }
+                console.log("Successfully connected to Snowflake.");
+                resolve(conn);
+            });
+        });
+        const query = `SELECT * FROM ${databaseName}.PUBLIC.${tableName} WHERE ${fieldName} = ?`;
+        const binds = [fieldValue];
+        return yield new Promise((resolve, reject) => {
+            connection.execute({
+                sqlText: query,
+                binds: binds,
+                complete: (err, stmt, rows) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    if (!rows) {
+                        return {
+                            row: {
+                                rowContents: {},
+                            },
+                        };
+                    }
+                    return resolve({
+                        row: {
+                            rowContents: rows[0],
+                        },
+                    });
+                },
+            });
+        });
+    }
+    catch (error) {
+        console.error("An error occurred while executing the query:", error);
+        throw error;
+    }
+    finally {
+        connection.destroy(err => {
+            if (err) {
+                console.log("Failed to disconnect:", err);
+            }
+            else {
+                console.log("Disconnected from Snowflake.");
+            }
+        });
+    }
+});
+exports.default = getRowByFieldValue;

package/dist/actions/providers/zendesk/createZendeskTicket.d.ts

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

package/dist/actions/providers/zendesk/createZendeskTicket.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());
+    });
+};
+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 createZendeskTicket = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { apiKey } = authParams;
+    const { subdomain, subject, body, requesterEmail } = params;
+    const url = `https://${subdomain}.zendesk.com/api/v2/tickets.json`;
+    const payload = {
+        ticket: {
+            subject,
+            comment: {
+                body,
+            },
+        },
+    };
+    if (!apiKey) {
+        throw new Error("API key is required");
+    }
+    try {
+        const response = yield axios_1.default.post(url, payload, {
+            auth: {
+                username: `${requesterEmail}/token`,
+                password: apiKey,
+            },
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error creating ticket", error);
+        return { ticketId: "Error" };
+    }
+});
+exports.default = createZendeskTicket;

package/dist/actions/schema.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParametersObject = createParametersObject;
+function createParametersObject(parameters) {
+    return Object.fromEntries(Object.entries(parameters).map(([key, param]) => [key, param.type]));
+}

package/dist/actions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/app.d.ts

@@ -0,0 +1,9 @@
+import { ActionTemplate } from "./actions/parse";
+import { AuthParamsType } from "./actions/autogen/types";
+export declare function runAction(name: string, provider: string, authentication: AuthParamsType, parameters: Record<string, any>): Promise<any>;
+export type ActionGroupsReturn = {
+    name: string;
+    description: string;
+    actions: ActionTemplate[];
+}[];
+export declare function getActionGroups(): Promise<ActionGroupsReturn>;

package/dist/app.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.runAction = runAction;
+exports.getActionGroups = getActionGroups;
+const groups_1 = require("./actions/groups");
+const templates = __importStar(require("./actions/autogen/templates"));
+const invoke_1 = require("./actions/invoke");
+function runAction(name, provider, authentication, 
+// eslint-disable-next-line
+parameters) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!parameters || !name || !provider) {
+            throw Error("Missing params");
+        }
+        const allActions = yield getActions();
+        const actionTemplate = allActions.find(x => x.name == name && x.provider == provider);
+        if (!actionTemplate) {
+            throw Error(`Action with name ${name} does not exist`);
+        }
+        const result = yield (0, invoke_1.invokeAction)({
+            provider: actionTemplate.provider,
+            name: actionTemplate.name,
+            parameters: parameters,
+            authParams: authentication,
+        });
+        return result;
+    });
+}
+/**
+ * HELPER FUNCTIONS
+ */
+function getActions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Object.values(templates);
+    });
+}
+function getActionGroups() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allDefinitions = yield getActions();
+        const result = [];
+        for (const [key, value] of Object.entries(groups_1.ACTION_GROUPS)) {
+            const actionGroupDetails = [];
+            for (const action of value.actions) {
+                const definition = allDefinitions.find(def => def.name === action.name);
+                if (definition) {
+                    actionGroupDetails.push(definition);
+                }
+            }
+            if (actionGroupDetails.length > 0) {
+                result.push({ name: key, description: value.description, actions: actionGroupDetails });
+            }
+        }
+        return result;
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { runAction, getActionGroups, type ActionGroupsReturn } from "./app";
+export { ACTION_GROUPS, type ActionGroups } from "./actions/groups";
+export * from "./actions/autogen/templates";
+export * from "./actions/autogen/types";
+export * from "./actions/providers/math/index";
+export * from "./actions/providers/slack/index";

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+// Do not use "@/" in this file because it won't generate declaration files properly
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_GROUPS = exports.getActionGroups = exports.runAction = void 0;
+var app_1 = require("./app");
+Object.defineProperty(exports, "runAction", { enumerable: true, get: function () { return app_1.runAction; } });
+Object.defineProperty(exports, "getActionGroups", { enumerable: true, get: function () { return app_1.getActionGroups; } });
+var groups_1 = require("./actions/groups");
+Object.defineProperty(exports, "ACTION_GROUPS", { enumerable: true, get: function () { return groups_1.ACTION_GROUPS; } });
+__exportStar(require("./actions/autogen/templates"), exports);
+__exportStar(require("./actions/autogen/types"), exports);
+__exportStar(require("./actions/providers/math/index"), exports);
+__exportStar(require("./actions/providers/slack/index"), exports);

package/dist/main.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const list_conversations_1 = __importDefault(require("./actions/providers/slack/list_conversations"));
+const result = (0, list_conversations_1.default)({
+    accessToken: "xoxp-4172665288294-8092684180551-8154529379075-89f1f70cc06e5648e8f912ba96f56626"
+}).then((result) => {
+    console.log(result);
+});

package/dist/utils/string.d.ts

@@ -0,0 +1 @@
+export declare function snakeToPascal(str: string): string;

package/dist/utils/string.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snakeToPascal = snakeToPascal;
+function snakeToPascal(str) {
+    return str
+        .replace(/_/g, " ")
+        .split(" ")
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join("");
+}