@getzep/zep-cloud 0.0.1-rc.1

package/esm/message_manager.js

@@ -0,0 +1,71 @@
+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());
+    });
+};
+import { Message } from "./message_models";
+import { handleRequest } from "./utils";
+export default class MessageManager {
+    constructor(client) {
+        this.client = client;
+    }
+    getSessionMessages(sessionId, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!sessionId || sessionId.trim() === "") {
+                throw new Error("sessionId must be provided");
+            }
+            let url = this.client.getFullUrl(`/sessions/${sessionId}/messages`);
+            const params = new URLSearchParams();
+            if (limit)
+                params.append("limit", limit.toString());
+            if (cursor)
+                params.append("cursor", cursor.toString());
+            if (params.toString())
+                url += `?${params.toString()}`;
+            const response = yield handleRequest(fetch(url, {
+                method: "GET",
+                headers: Object.assign(Object.assign({}, this.client.headers), { "Content-Type": "application/json" }),
+            }), `No session found for session ${sessionId}`);
+            const responseData = yield response.json();
+            return responseData.messages.map((message) => new Message(message));
+        });
+    }
+    getSessionMessage(sessionId, messageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!sessionId || sessionId.trim() === "") {
+                throw new Error("sessionId must be provided");
+            }
+            if (!messageId || messageId.trim() === "") {
+                throw new Error("messageId must be provided");
+            }
+            const response = yield handleRequest(fetch(this.client.getFullUrl(`/sessions/${sessionId}/messages/${messageId}`), {
+                headers: this.client.headers,
+            }), `No session found for session ${sessionId}, or message ${messageId}`);
+            const responseData = yield response.json();
+            return new Message(responseData);
+        });
+    }
+    updateSessionMessageMetadata(sessionId, messageId, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!sessionId || sessionId.trim() === "") {
+                throw new Error("sessionId must be provided");
+            }
+            if (!messageId || messageId.trim() === "") {
+                throw new Error("messageId must be provided");
+            }
+            const response = yield handleRequest(fetch(this.client.getFullUrl(`/sessions/${sessionId}/messages/${messageId}`), {
+                method: "PATCH",
+                headers: this.client.headers,
+                body: JSON.stringify({
+                    metadata,
+                }),
+            }), `No session found for session ${sessionId}, or message ${messageId}`);
+            const responseData = yield response.json();
+            return new Message(responseData);
+        });
+    }
+}

package/esm/message_models.d.ts

@@ -0,0 +1,37 @@
+import { MessageType } from "@langchain/core/messages";
+export type RoleType = "user" | "assistant" | "system" | "function" | "tool" | "norole";
+/**
+ * IMessage interface for providing input to create a Message instance.
+ */
+export interface IMessage {
+    uuid?: string;
+    created_at?: string;
+    role: string;
+    role_type: RoleType;
+    content: string;
+    token_count?: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Represents a message in the memory.
+ */
+export declare class Message {
+    uuid?: string;
+    created_at?: string;
+    role: string;
+    role_type: RoleType;
+    content: string;
+    token_count?: number;
+    metadata?: Record<string, any>;
+    /**
+     * Constructs a new Message instance.
+     * @param {IMessage} data - The data to create a message instance.
+     */
+    constructor(data: IMessage);
+    /**
+     * Converts the Message instance to a dictionary.
+     * @returns {IMessage} A dictionary representation of Message instance.
+     */
+    toDict(): IMessage;
+}
+export declare const getZepMessageRoleType: (role: MessageType) => RoleType;

package/esm/message_models.js

@@ -0,0 +1,49 @@
+/**
+ * Represents a message in the memory.
+ */
+export class Message {
+    /**
+     * Constructs a new Message instance.
+     * @param {IMessage} data - The data to create a message instance.
+     */
+    constructor(data) {
+        this.uuid = data.uuid;
+        this.created_at = data.created_at;
+        this.role = data.role;
+        this.role_type = data.role_type;
+        this.content = data.content;
+        this.token_count = data.token_count;
+        this.metadata = data.metadata;
+    }
+    /**
+     * Converts the Message instance to a dictionary.
+     * @returns {IMessage} A dictionary representation of Message instance.
+     */
+    toDict() {
+        return {
+            uuid: this.uuid,
+            created_at: this.created_at,
+            role: this.role,
+            role_type: this.role_type,
+            content: this.content,
+            token_count: this.token_count,
+            metadata: this.metadata,
+        };
+    }
+}
+export const getZepMessageRoleType = (role) => {
+    switch (role) {
+        case "human":
+            return "user";
+        case "ai":
+            return "assistant";
+        case "system":
+            return "system";
+        case "function":
+            return "function";
+        case "tool":
+            return "tool";
+        default:
+            return "norole";
+    }
+};

package/esm/user_manager.d.ts

@@ -0,0 +1,76 @@
+import { User, ICreateUserRequest, IUpdateUserRequest } from "./user_models";
+import { Session } from "./memory_models";
+import { IZepClient } from "./interfaces";
+/**
+ * UserManager class handles all user related operations such as
+ * adding, getting, updating, deleting, listing users and their sessions.
+ * It uses the IZepClient interface to make requests to the server.
+ */
+export default class UserManager {
+    client: IZepClient;
+    constructor(client: IZepClient);
+    /**
+     * Add a new user.
+     *
+     * @param {ICreateUserRequest} user - The user details to be added.
+     * @returns {Promise<User>} A Promise that resolves to a User object.
+     * @throws {APIError} If the request fails.
+     */
+    add(user: ICreateUserRequest): Promise<User>;
+    /**
+     * Get a user by their ID.
+     *
+     * @param {string} userId - The ID of the user to be retrieved.
+     * @returns {Promise<User>} A Promise that resolves to a User object.
+     * @throws {NotFoundError} If the request no user is found for the given ID.
+     * @throws {APIError} If the request fails.
+     */
+    get(userId: string): Promise<User>;
+    /**
+     * Update a user's details.
+     *
+     * @param {IUpdateUserRequest} user - The updated user details.
+     * @returns {Promise<User>} A Promise that resolves to a User object with the updated details.
+     * @throws {NotFoundError} If the request no user is found for the given ID.
+     * @throws {APIError} If the request fails.
+     */
+    update(user: IUpdateUserRequest): Promise<User>;
+    /**
+     * Delete a user by their ID.
+     *
+     * @param {string} userId - The ID of the user to be deleted.
+     * @returns {Promise<string>} A Promise that resolves to a string message confirming deletion.
+     * @throws {NotFoundError} If the request no user is found for the given ID.
+     * @throws {APIError} If the request fails.
+     */
+    delete(userId: string): Promise<string>;
+    /**
+     * List all users.
+     *
+     * @param {number} limit - The maximum number of users to return.
+     * @param {number} cursor - The index to start listing users from.
+     * @returns {Promise<User[]>} A Promise that resolves to an array of User objects.
+     * @throws {APIError} If the request fails.
+     */
+    list(limit?: number, cursor?: number): Promise<User[]>;
+    /**
+     * Get all sessions for a user.
+     *
+     * @param {string} userId - The ID of the user to retrieve sessions for.
+     * @returns {Promise<Session[]>} A Promise that resolves to an array of Session objects.
+     * @throws {NotFoundError} If no sessions are found for the given user ID.
+     * @throws {APIError} If the request fails.
+     */
+    getSessions(userId: string): Promise<Session[]>;
+    /**
+     * List users in chunks.
+     *
+     * This method retrieves users in chunks of a specified size.
+     * It is a generator function that yields each chunk of users as they are retrieved.
+     *
+     * @param {number} chunkSize - The size of the user chunks to retrieve. Defaults to 100.
+     * @yields {Promise<User[]>} A Promise that resolves to an array of User objects.
+     * @throws {APIError} If the request fails.
+     */
+    listChunked(chunkSize?: number): AsyncGenerator<User[], void, unknown>;
+}

package/esm/user_manager.js

@@ -0,0 +1,174 @@
+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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { User, UpdateUserRequest, CreateUserRequest, } from "./user_models";
+import { Session } from "./memory_models";
+import { handleRequest } from "./utils";
+/**
+ * UserManager class handles all user related operations such as
+ * adding, getting, updating, deleting, listing users and their sessions.
+ * It uses the IZepClient interface to make requests to the server.
+ */
+export default class UserManager {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Add a new user.
+     *
+     * @param {ICreateUserRequest} user - The user details to be added.
+     * @returns {Promise<User>} A Promise that resolves to a User object.
+     * @throws {APIError} If the request fails.
+     */
+    add(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newUserRequest = new CreateUserRequest(user);
+            const response = yield handleRequest(fetch(this.client.getFullUrl(`/users`), {
+                method: "POST",
+                headers: Object.assign(Object.assign({}, this.client.headers), { "Content-Type": "application/json" }),
+                body: JSON.stringify(newUserRequest.toDict()),
+            }), `Failed to add user ${user.user_id}`);
+            const responseData = yield response.json();
+            return new User(responseData);
+        });
+    }
+    /**
+     * Get a user by their ID.
+     *
+     * @param {string} userId - The ID of the user to be retrieved.
+     * @returns {Promise<User>} A Promise that resolves to a User object.
+     * @throws {NotFoundError} If the request no user is found for the given ID.
+     * @throws {APIError} If the request fails.
+     */
+    get(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield handleRequest(fetch(this.client.getFullUrl(`/users/${userId}`), {
+                headers: this.client.headers,
+            }), `No user found for userId ${userId}`);
+            const responseData = yield response.json();
+            return new User(responseData);
+        });
+    }
+    /**
+     * Update a user's details.
+     *
+     * @param {IUpdateUserRequest} user - The updated user details.
+     * @returns {Promise<User>} A Promise that resolves to a User object with the updated details.
+     * @throws {NotFoundError} If the request no user is found for the given ID.
+     * @throws {APIError} If the request fails.
+     */
+    update(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newUserUpdate = new UpdateUserRequest(user);
+            const response = yield handleRequest(fetch(this.client.getFullUrl(`/users/${user.user_id}`), {
+                method: "PATCH",
+                headers: Object.assign(Object.assign({}, this.client.headers), { "Content-Type": "application/json" }),
+                body: JSON.stringify(newUserUpdate.toDict()),
+            }), `Failed to update user ${user.user_id}`);
+            const responseData = yield response.json();
+            return new User(responseData);
+        });
+    }
+    /**
+     * Delete a user by their ID.
+     *
+     * @param {string} userId - The ID of the user to be deleted.
+     * @returns {Promise<string>} A Promise that resolves to a string message confirming deletion.
+     * @throws {NotFoundError} If the request no user is found for the given ID.
+     * @throws {APIError} If the request fails.
+     */
+    delete(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield handleRequest(fetch(this.client.getFullUrl(`/users/${userId}`), {
+                method: "DELETE",
+                headers: this.client.headers,
+            }), `Failed to delete user ${userId}`);
+            return response.text();
+        });
+    }
+    /**
+     * List all users.
+     *
+     * @param {number} limit - The maximum number of users to return.
+     * @param {number} cursor - The index to start listing users from.
+     * @returns {Promise<User[]>} A Promise that resolves to an array of User objects.
+     * @throws {APIError} If the request fails.
+     */
+    list(limit, cursor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = new URLSearchParams();
+            if (limit !== undefined)
+                params.append("limit", limit.toString());
+            if (cursor !== undefined)
+                params.append("cursor", cursor.toString());
+            const response = yield handleRequest(fetch(`${this.client.getFullUrl("/users")}?${params.toString()}`, {
+                headers: this.client.headers,
+            }));
+            const data = yield response.json();
+            return data.map((user) => new User(user));
+        });
+    }
+    /**
+     * Get all sessions for a user.
+     *
+     * @param {string} userId - The ID of the user to retrieve sessions for.
+     * @returns {Promise<Session[]>} A Promise that resolves to an array of Session objects.
+     * @throws {NotFoundError} If no sessions are found for the given user ID.
+     * @throws {APIError} If the request fails.
+     */
+    getSessions(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield handleRequest(fetch(this.client.getFullUrl(`/users/${userId}/sessions`), {
+                headers: this.client.headers,
+            }), `No sessions found for userId ${userId}`);
+            const data = yield response.json();
+            return data.map((session) => new Session(session));
+        });
+    }
+    /**
+     * List users in chunks.
+     *
+     * This method retrieves users in chunks of a specified size.
+     * It is a generator function that yields each chunk of users as they are retrieved.
+     *
+     * @param {number} chunkSize - The size of the user chunks to retrieve. Defaults to 100.
+     * @yields {Promise<User[]>} A Promise that resolves to an array of User objects.
+     * @throws {APIError} If the request fails.
+     */
+    listChunked(chunkSize = 100) {
+        return __asyncGenerator(this, arguments, function* listChunked_1() {
+            let cursor;
+            while (true) {
+                // eslint-disable-next-line no-await-in-loop
+                const users = yield __await(this.list(chunkSize, cursor));
+                if (users.length === 0) {
+                    // We've reached the last page
+                    break;
+                }
+                yield yield __await(users);
+                if (cursor === undefined) {
+                    cursor = 0;
+                }
+                cursor += chunkSize;
+            }
+        });
+    }
+}

package/esm/user_models.d.ts

@@ -0,0 +1,84 @@
+export interface IUser {
+    uuid?: string;
+    id?: number;
+    created_at?: Date;
+    updated_at?: Date;
+    deleted_at?: Date;
+    user_id: string;
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+    metadata?: Record<string, any>;
+}
+export declare class User implements IUser {
+    uuid?: string;
+    id?: number;
+    created_at?: Date;
+    updated_at?: Date;
+    deleted_at?: Date;
+    user_id: string;
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+    metadata?: Record<string, any>;
+    constructor({ user_id, uuid, id, created_at, updated_at, deleted_at, email, first_name, last_name, metadata, }: {
+        user_id: string;
+        uuid?: string;
+        id?: number;
+        created_at?: Date;
+        updated_at?: Date;
+        deleted_at?: Date;
+        email?: string;
+        first_name?: string;
+        last_name?: string;
+        metadata?: Record<string, any>;
+    });
+    toDict(): IUser;
+}
+export interface ICreateUserRequest {
+    user_id: string;
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+    metadata?: Record<string, any>;
+}
+export declare class CreateUserRequest implements ICreateUserRequest {
+    user_id: string;
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+    metadata?: Record<string, any>;
+    constructor({ user_id, email, first_name, last_name, metadata, }: {
+        user_id: string;
+        email?: string;
+        first_name?: string;
+        last_name?: string;
+        metadata?: Record<string, any>;
+    });
+    toDict(): ICreateUserRequest;
+}
+export interface IUpdateUserRequest {
+    uuid?: string;
+    user_id: string;
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+    metadata?: Record<string, any>;
+}
+export declare class UpdateUserRequest implements IUpdateUserRequest {
+    uuid?: string;
+    user_id: string;
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+    metadata?: Record<string, any>;
+    constructor({ uuid, user_id, email, first_name, last_name, metadata, }: {
+        uuid?: string;
+        user_id: string;
+        email?: string;
+        first_name?: string;
+        last_name?: string;
+        metadata?: Record<string, any>;
+    });
+    toDict(): IUpdateUserRequest;
+}

package/esm/user_models.js

@@ -0,0 +1,44 @@
+/* eslint-disable camelcase */
+import { toDictFilterEmpty } from "./utils";
+export class User {
+    constructor({ user_id, uuid, id, created_at, updated_at, deleted_at, email, first_name, last_name, metadata, }) {
+        this.user_id = user_id;
+        this.uuid = uuid;
+        this.id = id;
+        this.created_at = created_at;
+        this.updated_at = updated_at;
+        this.deleted_at = deleted_at;
+        this.email = email;
+        this.first_name = first_name;
+        this.last_name = last_name;
+        this.metadata = metadata;
+    }
+    toDict() {
+        return toDictFilterEmpty(this);
+    }
+}
+export class CreateUserRequest {
+    constructor({ user_id, email, first_name, last_name, metadata, }) {
+        this.user_id = user_id;
+        this.email = email;
+        this.first_name = first_name;
+        this.last_name = last_name;
+        this.metadata = metadata;
+    }
+    toDict() {
+        return toDictFilterEmpty(this);
+    }
+}
+export class UpdateUserRequest {
+    constructor({ uuid, user_id, email, first_name, last_name, metadata, }) {
+        this.uuid = uuid;
+        this.user_id = user_id;
+        this.email = email;
+        this.first_name = first_name;
+        this.last_name = last_name;
+        this.metadata = metadata;
+    }
+    toDict() {
+        return toDictFilterEmpty(this);
+    }
+}

package/esm/utils.d.ts

@@ -0,0 +1,18 @@
+declare const API_BASEPATH = "/api";
+declare const API_VERSION = "v2";
+declare const SERVER_ERROR_MESSAGE = "Failed to connect to Zep server. Please check that:\n- the server is running \n- the API URL is correct\n- No other process is using the same port";
+declare const MINIMUM_SERVER_VERSION = "0.21.0";
+declare const MIN_SERVER_WARNING_MESSAGE = "You are using an incompatible Zep server version. Please upgrade to 0.21.0 or later.";
+declare function warnDeprecation(functionName: string): void;
+declare function isVersionGreaterOrEqual(version: string | null): boolean;
+declare function handleRequest(requestPromise: Promise<Response>, notFoundMessage?: string | null): Promise<Response>;
+export declare function toDictFilterEmpty(instance: any): any;
+declare function isFloat(n: any): boolean;
+/**
+ * Joins the given paths into a single path.
+ *
+ * @param {...string[]} paths - The paths to join.
+ * @returns {string} The joined path.
+ */
+declare function joinPaths(...paths: string[]): string;
+export { warnDeprecation, handleRequest, SERVER_ERROR_MESSAGE, MIN_SERVER_WARNING_MESSAGE, MINIMUM_SERVER_VERSION, API_BASEPATH, API_VERSION, isVersionGreaterOrEqual, isFloat, joinPaths, };

package/esm/utils.js

@@ -0,0 +1,95 @@
+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());
+    });
+};
+import semver from "semver";
+import { APIError, AuthenticationError, NotFoundError } from "./errors";
+const API_BASEPATH = "/api";
+const API_VERSION = "v2";
+const SERVER_ERROR_MESSAGE = `Failed to connect to Zep server. Please check that:
+- the server is running 
+- the API URL is correct
+- No other process is using the same port`;
+const MINIMUM_SERVER_VERSION = "0.21.0";
+const MIN_SERVER_WARNING_MESSAGE = `You are using an incompatible Zep server version. Please upgrade to ${MINIMUM_SERVER_VERSION} or later.`;
+function warnDeprecation(functionName) {
+    console.warn(`Warning: ${functionName} is deprecated and will be removed in the next major release.`);
+}
+/*
+ * Use semver to compare the server version to the minimum version.
+ * Returns true if the server version is greater than or equal to the minimum version.
+ *
+ * If the version string is null or an invalid semver, returns false.
+ */
+function isVersionGreaterOrEqual(version) {
+    if (!version) {
+        return false;
+    }
+    const versionString = version.split("-")[0];
+    if (!semver.valid(versionString)) {
+        return false;
+    }
+    return semver.gte(versionString, MINIMUM_SERVER_VERSION);
+}
+/*
+ * Handles a request promise, throwing an appropriate error if the request fails.
+ */
+function handleRequest(requestPromise, notFoundMessage = null) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield requestPromise;
+            if (!response.ok) {
+                switch (response.status) {
+                    case 404:
+                        throw new NotFoundError(notFoundMessage || `Resource not found.`);
+                    case 401:
+                        throw new AuthenticationError("Authentication failed.");
+                    default:
+                        throw new APIError(`Got an unexpected status code: ${response.status}`, response.status, yield response.text());
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === "Failed to fetch") {
+                throw new APIError(SERVER_ERROR_MESSAGE);
+            }
+            throw error;
+        }
+    });
+}
+/*
+ * Converts an object to a dictionary, removing any null or undefined values.
+ */
+export function toDictFilterEmpty(instance) {
+    const dict = {};
+    Object.keys(instance).forEach((key) => {
+        if (instance[key] !== null && instance[key] !== undefined) {
+            dict[key] = instance[key];
+        }
+    });
+    return dict;
+}
+/*
+ * Returns true if the given value is a float or zero.
+ */
+function isFloat(n) {
+    if (n === 0)
+        return true;
+    return Number(n) === n && n % 1 !== 0;
+}
+/**
+ * Joins the given paths into a single path.
+ *
+ * @param {...string[]} paths - The paths to join.
+ * @returns {string} The joined path.
+ */
+function joinPaths(...paths) {
+    return paths.map((path) => path.replace(/^\/+|\/+$/g, "")).join("/");
+}
+export { warnDeprecation, handleRequest, SERVER_ERROR_MESSAGE, MIN_SERVER_WARNING_MESSAGE, MINIMUM_SERVER_VERSION, API_BASEPATH, API_VERSION, isVersionGreaterOrEqual, isFloat, joinPaths, };