import { LEVELSNAMES } from "../common/LevelLogs.js";
/**
 *  used in SDK parameter "messagesDataStore": DataStoreType.NoStore, Parameter to override the storeMessages parameter of the SDK to define the behaviour of the storage of the messages (Enum DataStoreType in lib/config/config , default value "DataStoreType.UsestoreMessagesField" so it follows the storeMessages behaviour)
 *                          DataStoreType.NoStore Tell the server to NOT store the messages for delay distribution or for history of the bot and the contact.
 *                          DataStoreType.NoPermanentStore Tell the server to NOT store the messages for history of the bot and the contact. But being stored temporarily as a normal part of delivery (e.g. if the recipient is offline at the time of sending).
 *                          DataStoreType.StoreTwinSide The messages are fully stored.
 *                          DataStoreType.UsestoreMessagesField to follow the storeMessages SDK's parameter behaviour.
 *                          DataStoreType.Store Offline storage and Message Archive Management (XEP-0313) [4] can define their own rules on what messages to store and usually only store messages that contain a body element. However a sender may want to indicate that a message is worth storing even though it might not match those rules.
 * @public
 * @enum {string}
 * @readonly
 */
declare enum DataStoreType {
    /** Tell the server to NOT store the messages for delay distribution or for history of the bot and the contact. */
    NoStore = "no-store",
    /** Tell the server to NOT store the messages for history of the bot and the contact. But being stored temporarily as a normal part of delivery (e.g. if the recipient is offline at the time of sending). */
    NoPermanentStore = "no-permanent-store",
    /** The messages are fully stored. */
    StoreTwinSide = "storetwinside",
    /** To follow the storeMessages SDK's parameter behaviour. */
    UsestoreMessagesField = "OldstoreMessagesUsed",
    /**
     * Offline storage and Message Archive Management (XEP-0313) [4] can define their own rules on what messages to store and usually only store messages that contain a body element.
     * However a sender may want to indicate that a message is worth storing even though it might not match those rules
     * (e.g. an encrypted message that carries the payload outside the body element). Such a message can be marked with a <store/> hint.
     * */
    Store = "store"
}
declare enum UrgencyType {
    /**
     * Urgent message
     * @type {UrgencyType.HIGH}
     */
    HIGH = "high",
    /**
     *  important message
     * @type {UrgencyType.MIDDLE}
     */
    MIDDLE = "middle",
    /**
     *  information message
      * @type {UrgencyType.LOW}
     */
    LOW = "low",
    /**
     *  standard message (null/undefined value is also treated as a standard message)
     * @type {UrgencyType.STANDARD}
     */
    STANDARD = "std"
}
declare let conf: {
    sandbox: {
        http: {
            host: string;
            port: string;
            protocol: string;
        };
        xmpp: {
            host: string;
            port: string;
            protocol: string;
            timeBetweenXmppRequests: string;
            raiseLowLevelXmppInEvent: boolean;
            raiseLowLevelXmppOutReq: boolean;
            maxIdleTimer: number;
            maxPingAnswerTimer: number;
            xmppRessourceName: any;
            maxPendingAsyncLockXmppQueue: number;
            stanzaMaxLength: number;
        };
        s2s: {
            hostCallback: string;
            locallistenningport: string;
            expressEngine: any;
        };
        rest: {
            useRestAtStartup: boolean;
            useGotLibForHttp: boolean;
            gotOptions: {
                agentOptions: {
                    /**
                     * Keep sockets around in a pool to be used by other requests in the future. Default = false
                     */
                    keepAlive: boolean;
                    /**
                     * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000.
                     * Only relevant if keepAlive is set to true.
                     */
                    keepAliveMsecs: number;
                    /**
                     * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
                     */
                    maxSockets: number;
                    /**
                     * Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached. Default: Infinity.
                     */
                    maxTotalSockets: number;
                    /**
                     * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.
                     */
                    maxFreeSockets: number;
                    /**
                     * Socket timeout in milliseconds. This will set the timeout after the socket is connected.
                     */
                    timeout: number;
                    /**
                     * If not false, the server certificate is verified against the list of supplied CAs. Default: true.
                     */
                    rejectUnauthorized: boolean;
                };
                gotRequestOptions: {
                    timeout: {
                        lookup: number;
                        connect: number;
                        secureConnect: number;
                        socket: number;
                        send: number;
                        response: number;
                    };
                };
            };
        };
    };
    official: {
        http: {
            host: string;
            port: string;
            protocol: string;
        };
        xmpp: {
            host: string;
            port: string;
            protocol: string;
            timeBetweenXmppRequests: string;
            raiseLowLevelXmppInEvent: boolean;
            raiseLowLevelXmppOutReq: boolean;
            maxIdleTimer: number;
            maxPingAnswerTimer: number;
            xmppRessourceName: any;
            maxPendingAsyncLockXmppQueue: number;
            stanzaMaxLength: number;
        };
        s2s: {
            hostCallback: string;
            locallistenningport: string;
            expressEngine: any;
        };
        rest: {
            useRestAtStartup: boolean;
            useGotLibForHttp: boolean;
            gotOptions: {
                agentOptions: {
                    /**
                     * Keep sockets around in a pool to be used by other requests in the future. Default = false
                     */
                    keepAlive: boolean;
                    /**
                     * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000.
                     * Only relevant if keepAlive is set to true.
                     */
                    keepAliveMsecs: number;
                    /**
                     * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
                     */
                    maxSockets: number;
                    /**
                     * Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached. Default: Infinity.
                     */
                    maxTotalSockets: number;
                    /**
                     * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.
                     */
                    maxFreeSockets: number;
                    /**
                     * Socket timeout in milliseconds. This will set the timeout after the socket is connected.
                     */
                    timeout: number;
                    /**
                     * If not false, the server certificate is verified against the list of supplied CAs. Default: true.
                     */
                    rejectUnauthorized: boolean;
                };
                gotRequestOptions: {
                    timeout: {
                        lookup: number;
                        connect: number;
                        secureConnect: number;
                        socket: number;
                        send: number;
                        response: number;
                    };
                };
            };
        };
    };
    any: {
        http: {
            host: string;
            port: string;
            protocol: string;
        };
        xmpp: {
            host: string;
            port: string;
            protocol: string;
            timeBetweenXmppRequests: string;
            raiseLowLevelXmppInEvent: boolean;
            raiseLowLevelXmppOutReq: boolean;
            maxIdleTimer: number;
            maxPingAnswerTimer: number;
            xmppRessourceName: any;
            maxPendingAsyncLockXmppQueue: number;
            stanzaMaxLength: number;
        };
        s2s: {
            hostCallback: string;
            locallistenningport: string;
            expressEngine: any;
        };
        rest: {
            useRestAtStartup: boolean;
            useGotLibForHttp: boolean;
            gotOptions: {
                agentOptions: {
                    /**
                     * Keep sockets around in a pool to be used by other requests in the future. Default = false
                     */
                    keepAlive: boolean;
                    /**
                     * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000.
                     * Only relevant if keepAlive is set to true.
                     */
                    keepAliveMsecs: number;
                    /**
                     * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
                     */
                    maxSockets: number;
                    /**
                     * Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached. Default: Infinity.
                     */
                    maxTotalSockets: number;
                    /**
                     * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.
                     */
                    maxFreeSockets: number;
                    /**
                     * Socket timeout in milliseconds. This will set the timeout after the socket is connected.
                     */
                    timeout: number;
                    /**
                     * If not false, the server certificate is verified against the list of supplied CAs. Default: true.
                     */
                    rejectUnauthorized: boolean;
                };
                gotRequestOptions: {
                    timeout: {
                        lookup: number;
                        connect: number;
                        secureConnect: number;
                        socket: number;
                        send: number;
                        response: number;
                    };
                };
            };
        };
    };
    logs: {
        path: string;
        level: LEVELSNAMES;
        color: boolean;
        enableConsoleLog: boolean;
        enableEventsLogs: boolean;
        enableEncryptedLogs: boolean;
        "system-dev": {
            internals: boolean;
            http: boolean;
        };
        zippedArchive: boolean;
        maxSize: string;
        maxFiles: any;
    };
    im: {
        sendReadReceipt: boolean;
        messageMaxLength: number;
        sendMessageToConnectedUser: boolean;
        conversationsRetrievedFormat: string;
        storeMessages: boolean;
        copyMessage: boolean;
        nbMaxConversations: number;
        rateLimitPerHour: number;
        messagesDataStore: DataStoreType;
        autoInitialGetBubbles: boolean;
        autoInitialBubblePresence: boolean;
        maxBubbleJoinInProgress: number;
        autoInitialBubbleFormat: string;
        autoInitialBubbleUnsubscribed: boolean;
        autoLoadConversations: boolean;
        autoLoadConversationHistory: boolean;
        autoLoadContacts: boolean;
        autoInitialLoadContactsInfoBulk: boolean;
        autoLoadCallLog: boolean;
        forceHistoryGetContactFromServer: boolean;
        enableCarbon: boolean;
        enablesendurgentpushmessages: boolean;
        useMessageEditionAndDeletionV2: boolean;
        storeMessagesInConversation: boolean;
        maxMessagesStoredInConversation: number;
    };
    mode: string;
    concurrentRequests: number;
    requestsRate: {
        useRequestRateLimiter: boolean;
        maxReqByIntervalForRequestRate: number;
        intervalForRequestRate: number;
        timeoutRequestForRequestRate: number;
    };
    intervalBetweenCleanMemoryCache: number;
    debug: boolean;
    permitSearchFromPhoneBook: boolean;
    displayOrder: string;
    testOutdatedVersion: boolean;
    testDNSentry: boolean;
    autoReconnectIgnoreErrors: boolean;
    httpoverxmppserver: boolean;
    servicesToStart: {
        s2s: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        presence: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        contacts: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        conversations: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        im: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        profiles: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        groups: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        bubbles: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        telephony: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        channels: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        admin: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        fileServer: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        fileStorage: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        calllog: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        favorites: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        alerts: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        invitation: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        settings: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        webinar: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        rbvoice: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        httpoverxmpp: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        rpcoverxmpp: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
        tasks: {
            start_up: boolean;
            optional: boolean;
            logEntryParameters: boolean;
        };
    };
};
export { conf as config, DataStoreType, UrgencyType };