@credal/actions 0.0.1

package/dist/actions/groups.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_GROUPS = void 0;
+const templates_1 = require("../actions/autogen/templates");
+exports.ACTION_GROUPS = {
+    SLACK_LIST_CONVERSATIONS: {
+        description: "Actions for interacting with Slack",
+        actions: [templates_1.slackListConversationsDefinition, templates_1.slackSendMessageDefinition],
+    },
+    CONFLUENCE_UPDATE_PAGE: {
+        description: "Action for updating Confluence",
+        actions: [templates_1.confluenceUpdatePageDefinition],
+    },
+    MATH_ADD: {
+        description: "Action for adding two numbers",
+        actions: [templates_1.mathAddDefinition],
+    },
+    MAPS_VALIDATE: {
+        description: "Action for validating a Google maps address",
+        actions: [templates_1.googlemapsValidateAddressDefinition],
+    },
+    CREDAL_CALL_COPILOT: {
+        description: "Action for calling a Credal Copilot",
+        actions: [templates_1.credalCallCopilotDefinition],
+    },
+    ZENDESK_CREATE_TICKET: {
+        description: "Action for creating a Zendesk ticket",
+        actions: [templates_1.zendeskCreateZendeskTicketDefinition],
+    },
+    MONGO_INSERT_DOC: {
+        description: "Action for inserting a document into a MongoDB collection",
+        actions: [templates_1.mongoInsertMongoDocDefinition],
+    },
+    SNOWFLAKE_GET_ROW_BY_FIELD_VALUE: {
+        description: "Action for getting a row from a Snowflake table by field value",
+        actions: [templates_1.snowflakeGetRowByFieldValueDefinition],
+    },
+};

package/dist/actions/invoke.d.ts

@@ -0,0 +1,8 @@
+interface InvokeActionInput<P, A> {
+    provider: string;
+    name: string;
+    parameters: P;
+    authParams: A;
+}
+export declare function invokeAction<P, A>(input: InvokeActionInput<P, A>): Promise<any>;
+export {};

package/dist/actions/invoke.js

@@ -0,0 +1,20 @@
+"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.invokeAction = invokeAction;
+const actionMapper_1 = require("./actionMapper");
+function invokeAction(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { provider, name, parameters, authParams } = input;
+        const providerFunction = actionMapper_1.ActionMapper[provider][name].fn;
+        return providerFunction({ params: parameters, authParams });
+    });
+}

package/dist/actions/invokeMapper.d.ts

@@ -0,0 +1,9 @@
+import { type ActionFunction } from "./autogen/types";
+import { z } from "zod";
+interface ActionFunctionComponents {
+    fn: ActionFunction<any, any, any>;
+    paramsSchema: z.ZodSchema;
+    outputSchema: z.ZodSchema;
+}
+export declare const FunctionMapper: Record<string, Record<string, ActionFunctionComponents>>;
+export {};

package/dist/actions/invokeMapper.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionMapper = void 0;
+const add_1 = __importDefault(require("./providers/math/add"));
+const list_conversations_1 = __importDefault(require("./providers/slack/list_conversations"));
+const updatePage_1 = __importDefault(require("./providers/confluence/updatePage"));
+const types_1 = require("./autogen/types");
+exports.FunctionMapper = {
+    math: {
+        add: {
+            fn: add_1.default,
+            paramsSchema: types_1.mathAddParamsSchema,
+            outputSchema: types_1.mathAddOutputSchema,
+        },
+    },
+    slack: {
+        listConversations: {
+            fn: list_conversations_1.default,
+            paramsSchema: types_1.slackListConversationsParamsSchema,
+            outputSchema: types_1.slackListConversationsOutputSchema,
+        },
+    },
+    confluence: {
+        updatePage: {
+            fn: updatePage_1.default,
+            paramsSchema: types_1.confluenceUpdatePageParamsSchema,
+            outputSchema: types_1.confluenceUpdatePageOutputSchema,
+        },
+    },
+};

package/dist/actions/parse.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+declare const actionTemplateSchema: z.ZodObject<z.objectUtil.extendShape<{
+    description: z.ZodString;
+    scopes: z.ZodArray<z.ZodString, "many">;
+    parameters: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        required: z.ZodArray<z.ZodString, "many">;
+        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        required: string[];
+        properties: Record<string, any>;
+    }, {
+        type: string;
+        required: string[];
+        properties: Record<string, any>;
+    }>>;
+    output: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        required: z.ZodArray<z.ZodString, "many">;
+        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        required: string[];
+        properties: Record<string, any>;
+    }, {
+        type: string;
+        required: string[];
+        properties: Record<string, any>;
+    }>>;
+}, {
+    name: z.ZodString;
+    provider: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    description: string;
+    scopes: string[];
+    name: string;
+    provider: string;
+    parameters?: {
+        type: string;
+        required: string[];
+        properties: Record<string, any>;
+    } | undefined;
+    output?: {
+        type: string;
+        required: string[];
+        properties: Record<string, any>;
+    } | undefined;
+}, {
+    description: string;
+    scopes: string[];
+    name: string;
+    provider: string;
+    parameters?: {
+        type: string;
+        required: string[];
+        properties: Record<string, any>;
+    } | undefined;
+    output?: {
+        type: string;
+        required: string[];
+        properties: Record<string, any>;
+    } | undefined;
+}>;
+export type ActionTemplate = z.infer<typeof actionTemplateSchema>;
+export {};

package/dist/actions/parse.js

@@ -0,0 +1,201 @@
+"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 ajv_1 = __importDefault(require("ajv"));
+const promises_1 = __importDefault(require("fs/promises"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const json_schema_to_zod_1 = __importDefault(require("json-schema-to-zod"));
+const ts_morph_1 = require("ts-morph");
+const zod_1 = require("zod");
+const string_1 = require("../utils/string");
+const jsonObjectSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    required: zod_1.z.array(zod_1.z.string()),
+    properties: zod_1.z.record(zod_1.z.string(), zod_1.z.any()), // Permissive for now, validate using JSON schema later
+});
+const actionSchema = zod_1.z.object({
+    description: zod_1.z.string(),
+    scopes: zod_1.z.array(zod_1.z.string()),
+    parameters: jsonObjectSchema.optional(),
+    output: jsonObjectSchema.optional(),
+});
+const actionTemplateSchema = actionSchema.extend({
+    name: zod_1.z.string(),
+    provider: zod_1.z.string(),
+});
+const providerSchema = zod_1.z.record(zod_1.z.string(), actionSchema);
+const configSchema = zod_1.z.object({
+    actions: zod_1.z.record(zod_1.z.string(), providerSchema),
+});
+const authParamsSchemaStr = `
+z.object({
+    authToken: z.string().optional(),
+    baseUrl: z.string().optional(),
+    apiKey: z.string().optional(),
+})
+`;
+function validateObject(object) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ajv = new ajv_1.default({
+            strict: true,
+            strictTypes: true,
+            strictTuples: true,
+            strictRequired: true,
+        });
+        // validate schema and check required fields
+        const validParameters = ajv.validateSchema(object);
+        if (!validParameters) {
+            throw new Error(`Error validating object: ${JSON.stringify(ajv.errors, null, 4)}`);
+        }
+        // check required fields
+        const requiredFields = object.required;
+        for (const field of requiredFields) {
+            if (!object.properties[field]) {
+                throw new Error(`Required field ${field} is missing`);
+            }
+        }
+    });
+}
+function addActionTypes(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ file, prefix, action }) {
+        // add parameter types
+        const paramsName = `${prefix}Params`;
+        yield addTypesToFile({
+            file,
+            obj: action.parameters,
+            fallback: "z.object({})",
+            name: paramsName,
+        });
+        // add output types
+        const outputName = `${prefix}Output`;
+        yield addTypesToFile({
+            file,
+            obj: action.output,
+            fallback: "z.void()",
+            name: outputName,
+        });
+        // add function type
+        const functionName = `${prefix}Function`;
+        file.addTypeAlias({
+            name: functionName,
+            type: `ActionFunction<${paramsName}Type, AuthParamsType, ${outputName}Type>`,
+            isExported: true,
+        });
+    });
+}
+function addTypesToFile(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ file, obj, fallback, name, }) {
+        const zodSchema = obj ? (0, json_schema_to_zod_1.default)(obj) : fallback;
+        const zodName = `${name}Schema`;
+        file.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            isExported: true,
+            declarations: [
+                {
+                    name: zodName,
+                    initializer: zodSchema,
+                },
+            ],
+        });
+        file.addTypeAlias({
+            name: `${name}Type`,
+            type: `z.infer<typeof ${zodName}>`,
+            isExported: true,
+        });
+    });
+}
+function generateTypes(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ inputPath = "src/actions/schema.yaml", outputPath = "src/actions/autogen/templates.ts", templatesOutputPath = "src/actions/autogen/types.ts", }) {
+        const yamlContent = yield promises_1.default.readFile(inputPath, "utf8");
+        const rawConfig = js_yaml_1.default.load(yamlContent);
+        // Validate the config
+        const parsedConfig = configSchema.parse(rawConfig);
+        // Generate the TypeScript file
+        // Initialize ts-morph project
+        const project = new ts_morph_1.Project();
+        const templatesFile = project.createSourceFile(outputPath, "", { overwrite: true });
+        const typesFile = project.createSourceFile(templatesOutputPath, "", { overwrite: true });
+        // Add imports
+        templatesFile.addImportDeclaration({
+            moduleSpecifier: "../../actions/parse",
+            namedImports: ["ActionTemplate"],
+        });
+        typesFile.addImportDeclaration({
+            moduleSpecifier: "zod",
+            namedImports: ["z"],
+        });
+        // Initialization: set up generic ActionFunction type
+        typesFile.addTypeAlias({
+            name: "ActionFunction",
+            typeParameters: ["P", "A", "O"],
+            type: "(input: {params: P, authParams: A}) => Promise<O>",
+            isExported: true,
+        });
+        // Initialization: set up authparams zod schema and type
+        typesFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            isExported: true,
+            declarations: [
+                {
+                    name: "AuthParamsSchema",
+                    initializer: authParamsSchemaStr,
+                },
+            ],
+        });
+        typesFile.addTypeAlias({
+            name: "AuthParamsType",
+            type: "z.infer<typeof AuthParamsSchema>",
+            isExported: true,
+        });
+        for (const [categoryName, category] of Object.entries(parsedConfig.actions)) {
+            for (const [actionName, action] of Object.entries(category)) {
+                if (action.parameters) {
+                    yield validateObject(action.parameters);
+                }
+                if (action.output) {
+                    yield validateObject(action.output);
+                }
+                const actionPrefix = `${categoryName}${(0, string_1.snakeToPascal)(actionName)}`;
+                const constName = `${actionPrefix}Definition`;
+                // Convert the action definition to a string representation
+                const templateObj = Object.assign({ provider: categoryName, name: actionName }, action);
+                // Validate the template object
+                const template = actionTemplateSchema.parse(templateObj);
+                // Add the constant declaration
+                const templateStr = JSON.stringify(template, null, 4);
+                templatesFile.addVariableStatement({
+                    declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+                    isExported: true,
+                    declarations: [
+                        {
+                            name: constName,
+                            type: "ActionTemplate",
+                            initializer: templateStr,
+                        },
+                    ],
+                });
+                // parameter types
+                yield addActionTypes({
+                    file: typesFile,
+                    prefix: actionPrefix,
+                    action,
+                });
+            }
+        }
+        // Save the generated TypeScript file
+        yield templatesFile.save();
+        yield typesFile.save();
+    });
+}
+generateTypes({});

package/dist/actions/providers/confluence/updatePage.d.ts

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

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

@@ -0,0 +1,47 @@
+"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"));
+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, username, content, title } = params;
+    const { baseUrl, authToken } = authParams;
+    const api = getConfluenceApi(baseUrl, username, authToken);
+    // Get current version number
+    const response = yield api.get(`/api/v2/pages/${pageId}`);
+    const currVersion = response.data.version.number;
+    yield api.put(`/api/v2/pages/${pageId}`, {
+        id: pageId,
+        status: "current",
+        title,
+        body: {
+            representation: "storage",
+            value: content,
+        },
+        version: {
+            number: currVersion + 1,
+        },
+    });
+});
+exports.default = confluenceUpdatePage;

package/dist/actions/providers/credal/callCopilot.d.ts

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

package/dist/actions/providers/credal/callCopilot.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 sdk_1 = require("@credal/sdk");
+const callCopilot = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const requestBody = {
+        agentId: params.agentId,
+        query: params.query,
+        userEmail: params.userEmail,
+    };
+    const client = new sdk_1.CredalClient({ apiKey: authParams.apiKey });
+    const response = yield client.copilots.sendMessage({
+        agentId: requestBody.agentId,
+        message: requestBody.query,
+        userEmail: requestBody.userEmail,
+    });
+    return {
+        response: response.sendChatResult.type === "ai_response_result"
+            ? response.sendChatResult.response.message
+            : "Error getting response",
+    };
+});
+exports.default = callCopilot;

package/dist/actions/providers/googlemaps/validateAddress.d.ts

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

package/dist/actions/providers/googlemaps/validateAddress.js

@@ -0,0 +1,30 @@
+"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 validateAddress = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const url = `https://addressvalidation.googleapis.com/v1:validateAddress?key=${authParams.apiKey}`;
+    const requestBody = {
+        address: {
+            addressLines: [...params.addressLines, params.locality, params.regionCode, params.postalCode],
+        },
+    };
+    const response = yield axios_1.default.post(url, requestBody, {
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    return response.data;
+});
+exports.default = validateAddress;

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

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

package/dist/actions/providers/jira/createJiraTicket.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());
+    });
+};
+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 createTicket = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { authToken, baseUrl } = authParams;
+    const url = `${baseUrl}/rest/api/3/issue`;
+    const payload = {
+        fields: Object.assign({ project: {
+                key: params.projectKey,
+            }, summary: params.summary, description: params.description, issuetype: {
+                name: params.issueType,
+            } }, (params.reporter ? { reporter: { id: params.reporter } } : {})),
+    };
+    const response = yield axios_1.default.post(url, payload, {
+        headers: {
+            Authorization: `Basic ${Buffer.from(`${params.username}:${authToken}`).toString("base64")}`,
+            "Content-Type": "application/json",
+        },
+    });
+    return response.data;
+});
+exports.default = createTicket;

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

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

package/dist/actions/providers/jira/createTicket.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());
+    });
+};
+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 createTicket = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { authToken, baseUrl } = authParams;
+    const url = `${baseUrl}/rest/api/3/issue`;
+    const payload = {
+        fields: Object.assign({ project: {
+                key: params.projectKey,
+            }, summary: params.summary, description: params.description, issuetype: {
+                name: params.issueType,
+            } }, (params.reporter ? { reporter: { id: params.reporter } } : {})),
+    };
+    const response = yield axios_1.default.post(url, payload, {
+        headers: {
+            Authorization: `Basic ${Buffer.from(`${params.username}:${authToken}`).toString("base64")}`,
+            "Content-Type": "application/json",
+        },
+    });
+    return response.data;
+});
+exports.default = createTicket;

package/dist/actions/providers/math/add.d.ts

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

package/dist/actions/providers/math/add.js

@@ -0,0 +1,17 @@
+"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 mathAdd = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params }) {
+    return {
+        result: params.a + params.b,
+    };
+});
+exports.default = mathAdd;

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

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

package/dist/actions/providers/math/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.add = void 0;
+exports.add = __importStar(require("./add"));

package/dist/actions/providers/mongodb/insertMongoDoc.d.ts

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