@prostgles/prostgles 2.3.6-dev.1786618620 → 2.3.6-dev.1786992729

package/dist/server/src/serverFunctions/adminServerFunctions/agenticWorkflowFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agenticWorkflowFunctions.d.ts","sourceRoot":"","sources":["../../../../../src/serverFunctions/adminServerFunctions/agenticWorkflowFunctions.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAiIR,GAAG;;;;;;;;;;;;;;;;;;;;;;CAqC9B,CAAC"}

package/dist/server/src/serverFunctions/adminServerFunctions/agenticWorkflowFunctions.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agenticWorkflowFunctions = void 0;
+const startAgenticWorkflowSchema_1 = require("../../../../common/mcp/startAgenticWorkflowSchema");
+const validateUserInput_1 = require("../../McpHub/ProstglesMcpHub/ProstglesMCPServers/Prostgles/agenticWorkflow/definitionValidation/validateUserInput");
+const addInstrumentationToTsLogic_1 = require("../../McpHub/ProstglesMcpHub/ProstglesMCPServers/Prostgles/agenticWorkflow/runtimeSdk/addInstrumentationToTsLogic");
+const getTsLogicSummary_1 = require("../../McpHub/ProstglesMcpHub/ProstglesMCPServers/Prostgles/agenticWorkflow/runtimeSdk/getTsLogicSummary");
+const getDefineAgenticWorkflowTsWithDbAndMcpTypes_1 = require("../../McpHub/ProstglesMcpHub/ProstglesMCPServers/Prostgles/agenticWorkflow/runtimeSetup/getDefineAgenticWorkflowTsWithDbAndMcpTypes");
+const startAgenticWorkflow_1 = require("../../McpHub/ProstglesMcpHub/ProstglesMCPServers/Prostgles/agenticWorkflow/startAgenticWorkflow");
+const runCodeInSandboxContainer_1 = require("../../McpHub/ProstglesMcpHub/ProstglesMCPServers/Prostgles/runCodeInSandboxContainer");
+const prostgles_server_1 = require("prostgles-server");
+const prostgles_types_1 = require("prostgles-types");
+const defineFunctionGroup_1 = require("../defineFunctionGroup");
+exports.agenticWorkflowFunctions = (0, defineFunctionGroup_1.defineFunctionGroupFunctions)({
+    startAgenticWorkflow: (0, prostgles_server_1.defineFunction)({
+        unrestrictedDbAccess: true,
+        input: (0, prostgles_types_1.pickKeys)(startAgenticWorkflowSchema_1.startAgenticWorkflowSchema, [
+            "chatId",
+            "workflowId",
+            "userInputValue",
+            "messageId",
+            "executionMode",
+            "autoApproveAllTools",
+        ]),
+        run: async ({ chatId, userInputValue, workflowId, messageId, executionMode, autoApproveAllTools, }, { dbo: dbs, user, clientReq }) => {
+            const chat = await dbs.llm_chats.findOne({
+                id: chatId,
+                user_id: user.id,
+            });
+            if (!chat) {
+                return {
+                    state: "init-error",
+                    message: "Chat not found",
+                    error: undefined,
+                };
+            }
+            const { connection_id } = chat;
+            if (!connection_id) {
+                return {
+                    state: "init-error",
+                    message: `Chat with id ${chatId} does not have a connection_id`,
+                    error: undefined,
+                };
+            }
+            const workflow = await dbs.agentic_workflows.findOne({
+                id: workflowId,
+                chat_id: chatId,
+            });
+            if (!workflow) {
+                return {
+                    state: "init-error",
+                    message: `Workflow with id ${workflowId} not found for chat ${chatId}`,
+                    error: undefined,
+                };
+            }
+            const userInputValidation = workflow.definition_data.userInput &&
+                (0, validateUserInput_1.validateUserInput)(userInputValue, workflow.definition_data.userInput);
+            if (userInputValidation?.isValid === false) {
+                return {
+                    state: "init-error",
+                    message: userInputValidation.error,
+                    error: undefined,
+                };
+            }
+            return (0, startAgenticWorkflow_1.startAgenticWorkflow)({
+                workflow,
+                dbs,
+                user,
+                connection_id,
+                chat,
+                messageId,
+                clientReq,
+                executionMode,
+                userInputValue: userInputValidation?.value ?? {},
+                autoApproveAllTools,
+            });
+        },
+    }),
+    stopAgenticWorkflow: (0, prostgles_server_1.defineFunction)({
+        unrestrictedDbAccess: true,
+        input: {
+            chatId: "integer",
+            messageId: "string",
+        },
+        run: async ({ chatId, messageId }, { user, dbo: dbs }) => {
+            return (0, startAgenticWorkflow_1.stopAgenticWorkflow)({
+                dbs,
+                chatId,
+                messageId,
+                userId: user.id,
+            });
+        },
+    }),
+    getAgenticWorkflowTypes: (0, prostgles_server_1.defineFunction)({
+        unrestrictedDbAccess: true,
+        input: {
+            connectionId: "string",
+            workflowId: { optional: true, type: "number" },
+        },
+        run: async ({ connectionId, workflowId }, { dbo: dbs, user }) => {
+            const workflow = !workflowId ? undefined : (await dbs.agentic_workflows.findOne({
+                id: workflowId,
+                user_id: user.id,
+            }));
+            const files = await (0, getDefineAgenticWorkflowTsWithDbAndMcpTypes_1.getAgenticWorkflowFiles)(dbs, "runtime", connectionId, {
+                type: "full",
+                ddlStatements: (workflow?.definition_data.databaseAccessDefinitions?.mode ===
+                    "custom") ?
+                    workflow.definition_data.databaseAccessDefinitions.ddlStatements
+                    : undefined,
+            });
+            const astInfo = (0, getTsLogicSummary_1.summariseWorkflowFile)(workflow?.definition ?? "");
+            const summary = (0, getTsLogicSummary_1.renderSummary)(astInfo);
+            const instrumentedFile = (0, addInstrumentationToTsLogic_1.instrumentWorkflowFile)(files["defineAgenticWorkflow.ts"]);
+            return {
+                files,
+                astNodes: astInfo,
+                summary,
+                instrumentedFile,
+            };
+        },
+    }),
+    stopDockerContainer: (0, prostgles_server_1.defineFunction)({
+        unrestrictedDbAccess: true,
+        input: {
+            chatId: "integer",
+            toolUseId: "string",
+        },
+        run: async ({ chatId, toolUseId }, { dbo: dbs, user }) => {
+            const container = await dbs.docker_containers.findOne({
+                chat_id: chatId,
+                user_id: user.id,
+                tool_use_id: toolUseId,
+            });
+            if (!container) {
+                throw new Error(`Container with tool use id ${toolUseId} not found for chat ${chatId}`);
+            }
+            (0, runCodeInSandboxContainer_1.stopContainer)(container.id);
+            await dbs.docker_containers.update({
+                id: container.id,
+            }, {
+                state: {
+                    status: "stopped",
+                },
+            });
+            return { success: true };
+        },
+    }),
+});
+//# sourceMappingURL=agenticWorkflowFunctions.js.map

package/dist/server/src/serverFunctions/adminServerFunctions/agenticWorkflowFunctions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agenticWorkflowFunctions.js","sourceRoot":"","sources":["../../../../../src/serverFunctions/adminServerFunctions/agenticWorkflowFunctions.ts"],"names":[],"mappings":"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"}

package/dist/server/src/serverFunctions/adminServerFunctions/backupServerFunctions.d.ts

@@ -0,0 +1,453 @@
+export declare const backupServerFunctions: {
+    readonly backupConnections: {
+        input?: {
+            connectionNames: {
+                optional: true;
+                type: "string[]";
+            };
+            allActive: {
+                optional: true;
+                type: "boolean";
+            };
+            name: "string";
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            connectionNames: {
+                optional: true;
+                type: "string[]";
+            };
+            allActive: {
+                optional: true;
+                type: "boolean";
+            };
+            name: "string";
+        }>, context: import("prostgles-server").UnrestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+    } & {
+        unrestrictedDbAccess: true;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly restoreConnections: {
+        input?: {
+            backupName: "string";
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            backupName: "string";
+        }>, context: import("prostgles-server").UnrestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<number>;
+    } & {
+        unrestrictedDbAccess: true;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly pgDump: {
+        input?: {
+            conId: "string";
+            credId: {
+                oneOf: ("number" | {
+                    enum: null[];
+                })[];
+            };
+            opts: {
+                type: {
+                    name: {
+                        type: "string";
+                        optional: true;
+                    };
+                    initiator: {
+                        type: "string";
+                        optional: true;
+                    };
+                    options: {
+                        readonly oneOfType: readonly [{
+                            readonly command: {
+                                readonly enum: readonly ["pg_dumpall"];
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly globalsOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly rolesOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly schemaOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly encoding: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        }, {
+                            readonly command: {
+                                readonly enum: readonly ["pg_dump"];
+                            };
+                            readonly format: {
+                                readonly enum: readonly ["p", "t", "c"];
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly create: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly encoding: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly numberOfJobs: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly noOwner: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly compressionLevel: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly excludeSchema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly schemaOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        }];
+                    };
+                };
+            };
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            conId: "string";
+            credId: {
+                oneOf: ("number" | {
+                    enum: null[];
+                })[];
+            };
+            opts: {
+                type: {
+                    name: {
+                        type: "string";
+                        optional: true;
+                    };
+                    initiator: {
+                        type: "string";
+                        optional: true;
+                    };
+                    options: {
+                        readonly oneOfType: readonly [{
+                            readonly command: {
+                                readonly enum: readonly ["pg_dumpall"];
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly globalsOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly rolesOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly schemaOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly encoding: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        }, {
+                            readonly command: {
+                                readonly enum: readonly ["pg_dump"];
+                            };
+                            readonly format: {
+                                readonly enum: readonly ["p", "t", "c"];
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly create: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly encoding: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly numberOfJobs: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly noOwner: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly compressionLevel: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly excludeSchema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly schemaOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        }];
+                    };
+                };
+            };
+        }>, context: import("prostgles-server").RestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string | undefined>;
+    } & {
+        unrestrictedDbAccess?: undefined;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly pgRestore: {
+        input?: {
+            bkpId: "string";
+            connId: {
+                type: "string";
+                optional: true;
+            };
+            opts: "any";
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            bkpId: "string";
+            connId: {
+                type: "string";
+                optional: true;
+            };
+            opts: "any";
+        }>, context: import("prostgles-server").RestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+    } & {
+        unrestrictedDbAccess?: undefined;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly bkpDelete: {
+        input?: {
+            bkpId: "string";
+            force: {
+                type: "boolean";
+                optional: true;
+            };
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            bkpId: "string";
+            force: {
+                type: "boolean";
+                optional: true;
+            };
+        }>, context: import("prostgles-server").RestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+    } & {
+        unrestrictedDbAccess?: undefined;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly streamBackupFile: {
+        input?: {
+            data: {
+                oneOfType: readonly [{
+                    readonly type: {
+                        readonly enum: readonly ["start"];
+                    };
+                    readonly fileName: "string";
+                    readonly connectionId: "string";
+                    readonly sizeBytes: "integer";
+                    readonly restoreOptions: {
+                        readonly type: {
+                            readonly command: {
+                                readonly enum: readonly ["pg_restore", "psql"];
+                            };
+                            readonly format: {
+                                readonly enum: readonly ["p", "t", "c"];
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                            };
+                            readonly singleTransaction: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly excludeSchema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly newDbName: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly create: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly noOwner: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly numberOfJobs: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        };
+                    };
+                }, {
+                    readonly type: {
+                        readonly enum: readonly ["chunk"];
+                    };
+                    readonly streamId: "string";
+                    readonly chunk: "Blob";
+                }, {
+                    readonly type: {
+                        readonly enum: readonly ["end"];
+                    };
+                    readonly streamId: "string";
+                }];
+            };
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            data: {
+                oneOfType: readonly [{
+                    readonly type: {
+                        readonly enum: readonly ["start"];
+                    };
+                    readonly fileName: "string";
+                    readonly connectionId: "string";
+                    readonly sizeBytes: "integer";
+                    readonly restoreOptions: {
+                        readonly type: {
+                            readonly command: {
+                                readonly enum: readonly ["pg_restore", "psql"];
+                            };
+                            readonly format: {
+                                readonly enum: readonly ["p", "t", "c"];
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                            };
+                            readonly singleTransaction: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly excludeSchema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly newDbName: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly create: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly noOwner: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly numberOfJobs: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        };
+                    };
+                }, {
+                    readonly type: {
+                        readonly enum: readonly ["chunk"];
+                    };
+                    readonly streamId: "string";
+                    readonly chunk: "Blob";
+                }, {
+                    readonly type: {
+                        readonly enum: readonly ["end"];
+                    };
+                    readonly streamId: "string";
+                }];
+            };
+        }>, context: import("prostgles-server").RestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string | undefined>;
+    } & {
+        unrestrictedDbAccess?: undefined;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+};
+//# sourceMappingURL=backupServerFunctions.d.ts.map

package/dist/server/src/serverFunctions/adminServerFunctions/backupServerFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backupServerFunctions.d.ts","sourceRoot":"","sources":["../../../../../src/serverFunctions/adminServerFunctions/backupServerFunctions.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkKhC,CAAC"}