@fonoster/autopilot 0.5.5 → 0.7.2

package/dist/cerebro/cerebro.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { EffectsManager } from "./effects";
-import { Intent, IntentsEngine } from "../intents/types";
-import { SGatherStream, VoiceRequest, VoiceResponse } from "@fonoster/voice";
-import { CerebroConfig, CerebroStatus } from "./types";
-import Events from "events";
-export declare class Cerebro {
-    voiceResponse: VoiceResponse;
-    cerebroEvents: Events;
-    voiceRequest: VoiceRequest;
-    status: CerebroStatus;
-    activationTimeout: number;
-    maxIteractionsBeforeHangup: number;
-    failedInteractions: number;
-    activeTimer: NodeJS.Timer;
-    interactionTimer: NodeJS.Timer;
-    intentsEngine: IntentsEngine;
-    stream: SGatherStream;
-    config: CerebroConfig;
-    lastIntent: Intent;
-    effects: EffectsManager;
-    interactionsTimer: NodeJS.Timeout;
-    isCallHandover: boolean;
-    isDead: boolean;
-    constructor(config: CerebroConfig);
-    wake(): Promise<void>;
-    sleep(): Promise<void>;
-    startActiveTimer(): void;
-    resetActiveTimer(): void;
-    /**
-     * Start the interactions timer
-     * If the user doesn't say anything we should play the welcome message
-     * If it gets played twice many times we should hangup
-     * If the user says something we should reset the timer
-     * If we just finish an effect we should reset the timer
-     */
-    startInteractionTimer(): void;
-    resetInteractionTimer(): void;
-    stopPlayback(): Promise<void>;
-    cleanup(): Promise<void>;
-}

package/dist/cerebro/cerebro.js

@@ -1,266 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cerebro = void 0;
-/* eslint-disable require-jsdoc */
-/*
- * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
- * http://github.com/fonoster/rox
- *
- * This file is part of Rox AI
- *
- * Licensed under the MIT License (the "License");
- * you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    https://opensource.org/licenses/MIT
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const effects_1 = require("./effects");
-const types_1 = require("./types");
-const util_1 = require("../util");
-const types_2 = require("../events/types");
-const logger_1 = require("@fonoster/logger");
-const events_1 = __importDefault(require("events"));
-const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
-class Cerebro {
-    voiceResponse;
-    cerebroEvents;
-    voiceRequest;
-    status;
-    activationTimeout;
-    maxIteractionsBeforeHangup = 2;
-    failedInteractions = 0;
-    activeTimer;
-    interactionTimer;
-    intentsEngine;
-    stream;
-    config;
-    lastIntent;
-    effects;
-    interactionsTimer;
-    isCallHandover = false;
-    isDead = false;
-    constructor(config) {
-        this.voiceResponse = config.voiceResponse;
-        this.voiceRequest = config.voiceRequest;
-        this.cerebroEvents = new events_1.default();
-        this.status = types_1.CerebroStatus.SLEEP;
-        this.activationTimeout = config.activationTimeout || 15000;
-        this.intentsEngine = config.intentsEngine;
-        this.effects = new effects_1.EffectsManager({
-            playbackId: config.voiceConfig.playbackId,
-            eventsClient: config.eventsClient,
-            voice: config.voiceResponse,
-            voiceConfig: config.voiceConfig,
-            activationIntentId: config.activationIntentId,
-            transfer: config.transfer
-        });
-        this.config = config;
-    }
-    // Subscribe to events
-    async wake() {
-        this.status = types_1.CerebroStatus.AWAKE_PASSIVE;
-        // This timer becomes active only if we don't have an activation intent
-        if (!this.config.activationIntentId) {
-            this.startInteractionTimer();
-        }
-        this.voiceResponse.on("error", (error) => {
-            this.cerebroEvents.emit("error", error);
-            (0, logger_1.ulogger)({
-                accessKeyId: this.voiceRequest.accessKeyId,
-                eventType: logger_1.ULogType.APP,
-                level: "error",
-                message: error.message
-            });
-        });
-        const speechConfig = { source: "speech,dtmf" };
-        if (this.config.alternativeLanguageCode) {
-            speechConfig.model = "command_and_search";
-            speechConfig.alternativeLanguageCodes = [
-                this.config.alternativeLanguageCode
-            ];
-        }
-        this.stream = await this.voiceResponse.sgather(speechConfig);
-        this.stream.on("transcript", async (data) => {
-            if (data.isFinal && data.transcript) {
-                logger.verbose("clear interactions timer", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-                clearTimeout(this.interactionsTimer);
-                const intent = await this.intentsEngine.findIntent(data.transcript, {
-                    telephony: {
-                        caller_id: this.voiceRequest.callerNumber
-                    }
-                });
-                logger.verbose("cerebro received new transcription from user", {
-                    sessionId: this.voiceRequest.sessionId,
-                    text: data.transcript,
-                    ref: intent.ref,
-                    confidence: intent.confidence
-                });
-                if (intent.effects.find((e) => e.type === "hangup") ||
-                    intent.effects.find((e) => e.type === "transfer")) {
-                    logger.verbose("call hand over: stop all the timers and close the stream", {
-                        sessionId: this.voiceRequest.sessionId
-                    });
-                    clearTimeout(this.activeTimer);
-                    clearTimeout(this.interactionsTimer);
-                    this.voiceResponse.closeMediaPipe();
-                    this.isCallHandover = true;
-                }
-                await this.effects.invokeEffects(intent, this.status, async () => {
-                    await this.stopPlayback();
-                    if (this.config.activationIntentId === intent.ref) {
-                        (0, util_1.sendClientEvent)(this.config.eventsClient, {
-                            eventName: types_2.CLIENT_EVENTS.RECOGNIZING
-                        });
-                        if (this.status === types_1.CerebroStatus.AWAKE_ACTIVE) {
-                            this.resetActiveTimer();
-                        }
-                        else {
-                            this.startActiveTimer();
-                        }
-                    }
-                }, () => {
-                    logger.verbose("invokeEffects cleanup callback", {
-                        sessionId: this.voiceRequest.sessionId
-                    });
-                    this.cleanup();
-                });
-                if (this.isDead || this.isCallHandover) {
-                    try {
-                        logger.verbose("the call was handover or cerebro was cleaned up", {
-                            sessionId: this.voiceRequest.sessionId
-                        });
-                        this.voiceResponse.hangup();
-                    }
-                    catch (e) {
-                        // All we can do is try as the call may have already been hung up
-                    }
-                    return;
-                }
-                logger.verbose("cerebro finished processing intent effects", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-                // Reset the interactions timer
-                if (!this.config.activationIntentId) {
-                    this.resetInteractionTimer();
-                }
-                // WARNING: It doesn't appear that we are using this anywhere
-                this.lastIntent = intent;
-            }
-        });
-    }
-    // Unsubscribe from events
-    async sleep() {
-        logger.verbose("cerebro timeout and is going to sleep");
-        await this.voiceResponse.closeMediaPipe();
-        this.stream.close();
-        this.status = types_1.CerebroStatus.SLEEP;
-    }
-    startActiveTimer() {
-        this.status = types_1.CerebroStatus.AWAKE_ACTIVE;
-        this.activeTimer = setTimeout(() => {
-            this.status = types_1.CerebroStatus.AWAKE_PASSIVE;
-            (0, util_1.sendClientEvent)(this.config.eventsClient, {
-                eventName: types_2.CLIENT_EVENTS.RECOGNIZING_FINISHED
-            });
-            logger.verbose("cerebro changed awake status", { status: this.status });
-        }, this.activationTimeout);
-        logger.verbose("cerebro changed awake status", { status: this.status });
-    }
-    resetActiveTimer() {
-        logger.verbose("cerebro is reseting awake status");
-        clearTimeout(this.activeTimer);
-        this.startActiveTimer();
-    }
-    /**
-     * Start the interactions timer
-     * If the user doesn't say anything we should play the welcome message
-     * If it gets played twice many times we should hangup
-     * If the user says something we should reset the timer
-     * If we just finish an effect we should reset the timer
-     */
-    startInteractionTimer() {
-        logger.verbose("cerebro is starting interactions timer", {
-            sessionId: this.voiceRequest.sessionId
-        });
-        this.interactionsTimer = setInterval(async () => {
-            this.failedInteractions++;
-            logger.verbose("cerebro is counting interactions", {
-                sessionId: this.voiceRequest.sessionId,
-                failedInteractions: this.failedInteractions
-            });
-            // Fix hard coded intent
-            let intentId = "welcome";
-            if (this.failedInteractions >= this.maxIteractionsBeforeHangup) {
-                logger.verbose("there was no interaction so for a long time so we hangup", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-                // Fix hard coded intent
-                intentId = "goodbye";
-                clearTimeout(this.interactionsTimer);
-            }
-            const intent = await this.intentsEngine.findIntentWithEvent(intentId, {
-                telephony: {
-                    caller_id: this.voiceRequest.callerNumber
-                }
-            });
-            await this.effects.invokeEffects(intent, this.status, () => {
-                logger.verbose("invokeEffects callback", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-            }, () => {
-                logger.verbose("invokeEffects cleanup callback", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-                this.cleanup();
-            });
-        }, this.activationTimeout);
-    }
-    resetInteractionTimer() {
-        logger.verbose("cerebro is reseting interactions timer", {
-            sessionId: this.voiceRequest.sessionId
-        });
-        // Reset the failed interactions timer
-        this.failedInteractions = 0;
-        clearTimeout(this.interactionsTimer);
-        this.startInteractionTimer();
-    }
-    async stopPlayback() {
-        const { playbackId } = this.config.voiceConfig;
-        if (playbackId) {
-            try {
-                const playbackControl = this.voiceResponse.playback(playbackId);
-                logger.verbose("cerebro is stoping playback", { playbackId });
-                await playbackControl.stop();
-            }
-            catch (e) {
-                (0, logger_1.ulogger)({
-                    accessKeyId: this.voiceRequest.accessKeyId,
-                    eventType: logger_1.ULogType.APP,
-                    level: "error",
-                    message: e.message
-                });
-            }
-        }
-    }
-    // Cleanup all timers and events
-    async cleanup() {
-        this.isDead = true;
-        await this.voiceResponse.closeMediaPipe();
-        this.stream.close();
-        this.cerebroEvents.removeAllListeners();
-        clearTimeout(this.activeTimer);
-        clearTimeout(this.interactionsTimer);
-    }
-}
-exports.Cerebro = Cerebro;

package/dist/cerebro/effects.d.ts

@@ -1,11 +0,0 @@
-import { VoiceResponse } from "@fonoster/voice";
-import { Intent } from "../intents/types";
-import { EffectsManagerConfig, CerebroStatus, Effect } from "./types";
-export declare class EffectsManager {
-    voice: VoiceResponse;
-    config: EffectsManagerConfig;
-    constructor(config: EffectsManagerConfig);
-    invokeEffects(intent: Intent, status: CerebroStatus, activateCallback: () => void, cleanupCallback: () => void): Promise<void>;
-    run(effect: Effect): Promise<void>;
-    transferEffect(effect: Effect): Promise<void>;
-}

package/dist/cerebro/effects.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EffectsManager = void 0;
-const nanoid_1 = require("nanoid");
-const helper_1 = require("./helper");
-const types_1 = require("./types");
-const util_1 = require("../util");
-const types_2 = require("../events/types");
-const logger_1 = require("@fonoster/logger");
-const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
-class EffectsManager {
-    voice;
-    config;
-    constructor(config) {
-        this.voice = config.voice;
-        this.config = config;
-    }
-    async invokeEffects(intent, status, activateCallback, cleanupCallback) {
-        activateCallback();
-        logger.verbose("intent received", { intentRef: intent.ref });
-        if (this.config.activationIntentId === intent.ref) {
-            logger.verbose("fired activation intent");
-            return;
-        }
-        else if (this.config.activationIntentId &&
-            status != types_1.CerebroStatus.AWAKE_ACTIVE) {
-            logger.verbose("received an intent but cerebro is not awake");
-            // If we have activation intent cerebro needs and active status
-            // before we can have any effects
-            return;
-        }
-        // eslint-disable-next-line no-loops/no-loops
-        for (const e of intent.effects) {
-            try {
-                logger.verbose("effects running", { type: e.type });
-                await this.run(e);
-            }
-            catch (e) {
-                const axiosError = e;
-                if (axiosError.response?.status !== 404) {
-                    logger.error("error running effect", { error: e });
-                    return;
-                }
-                cleanupCallback();
-            }
-        }
-    }
-    async run(effect) {
-        switch (effect.type) {
-            case "say":
-                await this.voice.say(effect.parameters["response"], this.config.voiceConfig);
-                break;
-            case "hangup":
-                await this.voice.hangup();
-                (0, util_1.sendClientEvent)(this.config.eventsClient, {
-                    eventName: types_2.CLIENT_EVENTS.HANGUP
-                });
-                break;
-            case "transfer":
-                // TODO: Add record effect
-                await this.transferEffect(effect);
-                break;
-            case "send_data":
-                // Only send if client support events
-                (0, util_1.sendClientEvent)(this.config.eventsClient, {
-                    eventName: types_2.CLIENT_EVENTS.RECOGNIZING_FINISHED
-                });
-                (0, util_1.sendClientEvent)(this.config.eventsClient, {
-                    eventName: types_2.CLIENT_EVENTS.INTENT,
-                    intent: effect.parameters
-                });
-                break;
-            default:
-                throw new Error(`effects received unknown effect ${effect.type}`);
-        }
-    }
-    async transferEffect(effect) {
-        await this.voice.closeMediaPipe();
-        const stream = await this.voice.dial(effect.parameters["destination"]);
-        const playbackId = (0, nanoid_1.nanoid)();
-        const control = this.voice.playback(playbackId);
-        let stay = true;
-        const moveForward = async () => {
-            stay = false;
-            await control.stop();
-        };
-        stream.on("answer", () => {
-            logger.verbose("call answered", {
-                destination: effect.parameters["destination"]
-            });
-            moveForward();
-        });
-        stream.on("busy", async () => {
-            logger.verbose("call busy", {
-                destination: effect.parameters["destination"]
-            });
-            await moveForward();
-            await (0, helper_1.playBusyAndHangup)(this.voice, playbackId, this.config);
-        });
-        stream.on("noanswer", async () => {
-            logger.verbose("call no answer", {
-                destination: effect.parameters["destination"]
-            });
-            await moveForward();
-            await (0, helper_1.playNoAnswerAndHangup)(this.voice, playbackId, this.config);
-        });
-        // eslint-disable-next-line no-loops/no-loops
-        while (stay) {
-            await (0, helper_1.playTransfering)(this.voice, playbackId, this.config);
-        }
-    }
-}
-exports.EffectsManager = EffectsManager;

package/dist/cerebro/helper.d.ts

@@ -1,5 +0,0 @@
-import { VoiceResponse } from "@fonoster/voice";
-import { EffectsManagerConfig } from "./types";
-export declare const playTransfering: (voice: VoiceResponse, playbackId: string, config: EffectsManagerConfig) => Promise<void>;
-export declare const playBusyAndHangup: (voice: VoiceResponse, playbackId: string, config: EffectsManagerConfig) => Promise<void>;
-export declare const playNoAnswerAndHangup: (voice: VoiceResponse, playbackId: string, config: EffectsManagerConfig) => Promise<void>;

package/dist/cerebro/helper.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.playNoAnswerAndHangup = exports.playBusyAndHangup = exports.playTransfering = void 0;
-const playOrSay = async (param) => {
-    if (param.media) {
-        await param.voice.play("sound:" + param.media, {
-            playbackId: param.playbackId
-        });
-    }
-    if (param.message) {
-        if (param.voiceConfig) {
-            param.voiceConfig.playbackId = param.playbackId;
-        }
-        else {
-            param.voiceConfig = { playbackId: param.playbackId };
-        }
-        await param.voice.say(param.message, param.voiceConfig);
-    }
-};
-const playTransfering = async (voice, playbackId, config) => await playOrSay({
-    voice,
-    voiceConfig: config.voiceConfig,
-    playbackId,
-    media: config.transfer?.media,
-    message: config.transfer?.message
-});
-exports.playTransfering = playTransfering;
-const playBusyAndHangup = async (voice, playbackId, config) => await playOrSay({
-    voice,
-    voiceConfig: config.voiceConfig,
-    playbackId,
-    media: config.transfer?.mediaBusy,
-    message: config.transfer?.messageBusy
-});
-exports.playBusyAndHangup = playBusyAndHangup;
-const playNoAnswerAndHangup = async (voice, playbackId, config) => await playOrSay({
-    voice,
-    voiceConfig: config.voiceConfig,
-    playbackId,
-    media: config.transfer?.mediaNoAnswer,
-    message: config.transfer?.messageNoAnswer
-});
-exports.playNoAnswerAndHangup = playNoAnswerAndHangup;

package/dist/cerebro/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./cerebro";
-export * from "./effects";

package/dist/cerebro/types.d.ts

@@ -1,40 +0,0 @@
-import { VoiceResponse } from "@fonoster/voice";
-import { VoiceRequest } from "@fonoster/voice/dist/types";
-import { EventsClient } from "../events/emitter";
-import { IntentsEngine } from "../intents/types";
-export declare enum CerebroStatus {
-    SLEEP = 0,
-    AWAKE_ACTIVE = 1,
-    AWAKE_PASSIVE = 2
-}
-export interface CerebroConfig {
-    voiceRequest: VoiceRequest;
-    voiceResponse: VoiceResponse;
-    activationTimeout?: number;
-    activationIntentId?: string;
-    intentsEngine: IntentsEngine;
-    voiceConfig: Record<string, string | string[]>;
-    eventsClient: EventsClient | null;
-    transfer?: Transfer;
-    alternativeLanguageCode?: string;
-}
-export interface Transfer {
-    media?: string;
-    mediaNoAnswer?: string;
-    mediaBusy?: string;
-    message?: string;
-    messageNoAnswer?: string;
-    messageBusy?: string;
-}
-export interface EffectsManagerConfig {
-    eventsClient: EventsClient | null;
-    voice: VoiceResponse;
-    voiceConfig: Record<string, unknown>;
-    activationIntentId?: string;
-    playbackId: string;
-    transfer?: Transfer;
-}
-export interface Effect {
-    type: "say" | "hangup" | "send_data" | "transfer";
-    parameters: Record<string, unknown>;
-}

package/dist/cerebro/types.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CerebroStatus = void 0;
-var CerebroStatus;
-(function (CerebroStatus) {
-    CerebroStatus[CerebroStatus["SLEEP"] = 0] = "SLEEP";
-    CerebroStatus[CerebroStatus["AWAKE_ACTIVE"] = 1] = "AWAKE_ACTIVE";
-    CerebroStatus[CerebroStatus["AWAKE_PASSIVE"] = 2] = "AWAKE_PASSIVE";
-})(CerebroStatus || (exports.CerebroStatus = CerebroStatus = {}));

package/dist/events/emitter.d.ts

@@ -1,7 +0,0 @@
-import { EventEmitter, ClientEvent } from "./types";
-import WebSocket = require("ws");
-export declare class EventsClient implements EventEmitter {
-    ws: WebSocket;
-    constructor(ws: WebSocket);
-    send(event: ClientEvent): void;
-}

package/dist/events/emitter.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventsClient = void 0;
-class EventsClient {
-    ws;
-    constructor(ws) {
-        this.ws = ws;
-    }
-    send(event) {
-        this.ws.send(JSON.stringify(event));
-    }
-}
-exports.EventsClient = EventsClient;

package/dist/events/server.d.ts

@@ -1,12 +0,0 @@
-import { EventsClient } from "./emitter";
-import WebSocket = require("ws");
-export declare class EventsServer {
-    clientConnections: Map<string, WebSocket>;
-    wss: WebSocket.Server;
-    port: number;
-    constructor(clientConnections: Map<string, WebSocket>, port?: number);
-    start(): void;
-    getConnection(clientId: string): EventsClient | null;
-    removeConnection(clientId: string): void;
-}
-export declare const eventsServer: EventsServer;

package/dist/events/server.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.eventsServer = exports.EventsServer = void 0;
-/* eslint-disable require-jsdoc */
-/*
- * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
- * http://github.com/fonoster/rox
- *
- * This file is part of Rox AI
- *
- * Licensed under the MIT License (the "License");
- * you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    https://opensource.org/licenses/MIT
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const emitter_1 = require("./emitter");
-const logger_1 = require("@fonoster/logger");
-const WebSocket = require("ws");
-const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
-// Events server
-class EventsServer {
-    clientConnections;
-    wss;
-    port;
-    constructor(clientConnections, port = 3001) {
-        this.port = port;
-        this.wss = new WebSocket.Server({ port });
-        this.clientConnections = clientConnections;
-    }
-    start() {
-        this.wss.on("connection", (ws) => {
-            logger.verbose("received a new client connection");
-            ws.on("message", (data) => {
-                // Once we receive the first and only message from client we
-                // save the client in the clientConnections map
-                const clientId = JSON.parse(data.toString()).clientId;
-                this.clientConnections.set(clientId, ws);
-                logger.verbose("added clientId to list of connections", { clientId });
-            });
-            ws.send(JSON.stringify({
-                name: "connected",
-                payload: {}
-            }));
-        });
-        logger.verbose("starting events server", { port: this.port });
-    }
-    getConnection(clientId) {
-        const connection = this.clientConnections.get(clientId);
-        if (!connection) {
-            return null;
-        }
-        return new emitter_1.EventsClient(connection);
-    }
-    removeConnection(clientId) {
-        this.clientConnections.delete(clientId);
-    }
-}
-exports.EventsServer = EventsServer;
-// Starting events server
-exports.eventsServer = new EventsServer(new Map());

package/dist/events/types.d.ts

@@ -1,20 +0,0 @@
-export declare enum CLIENT_EVENTS {
-    RECOGNIZING = "RECOGNIZING",
-    ANSWERED = "ANSWERED",
-    RECOGNIZING_FINISHED = "RECOGNIZING_FINISHED",
-    INTENT = "INTENT",
-    HANGUP = "HANGUP"
-}
-export interface EventEmitter {
-    send(payload?: ClientEvent): void;
-}
-export interface Intent {
-    icon?: string;
-    title: string;
-    description: string;
-    transcript: string;
-}
-export interface ClientEvent {
-    eventName: CLIENT_EVENTS;
-    intent?: Intent;
-}

package/dist/file-retention/cron.d.ts

@@ -1,2 +0,0 @@
-import { ServerConfig } from "../types";
-export declare const startFileRetentionPolicy: (config: ServerConfig) => void;