@meshagent/meshagent 0.5.19 → 0.6.1

package/dist/node/meshagent-client.js

@@ -0,0 +1,1051 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Meshagent = void 0;
+const helpers_1 = require("./helpers");
+const requirement_1 = require("./requirement");
+const participant_token_1 = require("./participant-token");
+function pruneUndefinedValues(value) {
+    if (Array.isArray(value)) {
+        const prunedItems = value
+            .map((item) => pruneUndefinedValues(item))
+            .filter((item) => item !== undefined);
+        return prunedItems;
+    }
+    if (value === null || value === undefined) {
+        return value === undefined ? undefined : null;
+    }
+    if (typeof value === "object") {
+        const result = {};
+        for (const [key, entryValue] of Object.entries(value)) {
+            if (entryValue === undefined) {
+                continue;
+            }
+            result[key] = pruneUndefinedValues(entryValue);
+        }
+        return result;
+    }
+    return value;
+}
+function serializeServiceSpec(service) {
+    return pruneUndefinedValues(service);
+}
+class Meshagent {
+    constructor({ baseUrl, token } = {}) {
+        const resolvedBaseUrl = (0, helpers_1.meshagentBaseUrl)(baseUrl).replace(/\/+$/, "");
+        this.baseUrl = resolvedBaseUrl || "https://api.meshagent.com";
+        const envToken = typeof process !== "undefined" ? process.env?.MESHAGENT_API_KEY : undefined;
+        this.token = token ?? envToken ?? undefined;
+    }
+    buildUrl(path, query) {
+        const url = new URL(path, this.baseUrl);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return url.toString();
+    }
+    async request(path, options) {
+        const { method = "GET", query, json, body, headers, action, responseType = "json" } = options;
+        const url = this.buildUrl(path, query);
+        const finalHeaders = {};
+        if (this.token) {
+            finalHeaders["Authorization"] = `Bearer ${this.token}`;
+        }
+        if (headers) {
+            for (const [key, value] of Object.entries(headers)) {
+                finalHeaders[key] = value;
+            }
+        }
+        let requestBody = undefined;
+        if (json !== undefined && json !== null) {
+            requestBody = JSON.stringify(json);
+            finalHeaders["Content-Type"] = "application/json";
+        }
+        else if (body !== undefined && body !== null) {
+            if (body instanceof ArrayBuffer) {
+                requestBody = new Uint8Array(body);
+            }
+            else {
+                requestBody = body;
+            }
+        }
+        const response = await fetch(url, {
+            method,
+            headers: finalHeaders,
+            body: requestBody ?? undefined,
+        });
+        if (!response.ok) {
+            let message;
+            try {
+                message = await response.text();
+            }
+            catch {
+                message = "<unable to read body>";
+            }
+            throw new requirement_1.RoomException(`Failed to ${action}. Status code: ${response.status}, body: ${message}`);
+        }
+        switch (responseType) {
+            case "json":
+                if (response.status === 204) {
+                    return {};
+                }
+                return (await response.json());
+            case "text":
+                return (await response.text());
+            case "arrayBuffer":
+                return new Uint8Array(await response.arrayBuffer());
+            case "void":
+            default:
+                return undefined;
+        }
+    }
+    parseRoomShare(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid room share payload: expected object");
+        }
+        const { id, project_id: projectId, projectId: projectIdAlt, settings } = data;
+        if (typeof id !== "string") {
+            throw new requirement_1.RoomException("Invalid room share payload: missing id");
+        }
+        const finalProjectId = typeof projectIdAlt === "string" ? projectIdAlt : typeof projectId === "string" ? projectId : undefined;
+        if (!finalProjectId) {
+            throw new requirement_1.RoomException("Invalid room share payload: missing project id");
+        }
+        return {
+            id,
+            projectId: finalProjectId,
+            settings: (settings && typeof settings === "object") ? settings : {},
+        };
+    }
+    parseRoomShareConnectionInfo(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid room share connection payload");
+        }
+        const { jwt, room_name: roomNameRaw, roomName, project_id: projectIdRaw, projectId, settings, room_url: roomUrlRaw, roomUrl } = data;
+        if (typeof jwt !== "string") {
+            throw new requirement_1.RoomException("Invalid room share connection payload: missing jwt");
+        }
+        const roomNameValue = typeof roomName === "string" ? roomName : roomNameRaw;
+        const projectIdValue = typeof projectId === "string" ? projectId : projectIdRaw;
+        const roomUrlValue = typeof roomUrl === "string" ? roomUrl : roomUrlRaw;
+        if (typeof roomNameValue !== "string" || typeof projectIdValue !== "string" || typeof roomUrlValue !== "string") {
+            throw new requirement_1.RoomException("Invalid room share connection payload: missing fields");
+        }
+        return {
+            jwt,
+            roomName: roomNameValue,
+            projectId: projectIdValue,
+            settings: (settings && typeof settings === "object") ? settings : {},
+            roomUrl: roomUrlValue,
+        };
+    }
+    parseRoomSession(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid room session payload");
+        }
+        const { id, room_id: roomIdRaw, roomId, room_name: roomNameRaw, roomName, created_at: createdRaw, createdAt, is_active: isActiveRaw, isActive, participants } = data;
+        if (typeof id !== "string") {
+            throw new requirement_1.RoomException("Invalid room session payload: missing id");
+        }
+        const roomNameValue = typeof roomName === "string" ? roomName : roomNameRaw;
+        if (typeof roomNameValue !== "string") {
+            throw new requirement_1.RoomException("Invalid room session payload: missing room name");
+        }
+        const created = typeof createdAt === "string" ? createdAt : createdRaw;
+        if (typeof created !== "string") {
+            throw new requirement_1.RoomException("Invalid room session payload: missing created_at");
+        }
+        const isActiveValue = typeof isActive === "boolean" ? isActive : isActiveRaw;
+        if (typeof isActiveValue !== "boolean") {
+            throw new requirement_1.RoomException("Invalid room session payload: missing is_active");
+        }
+        return {
+            id,
+            roomId: typeof roomId === "string" ? roomId : typeof roomIdRaw === "string" ? roomIdRaw : undefined,
+            roomName: roomNameValue,
+            createdAt: new Date(created),
+            isActive: isActiveValue,
+            participants: participants && typeof participants === "object" ? participants : undefined,
+        };
+    }
+    parseRoom(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid room payload");
+        }
+        const { id, name, metadata } = data;
+        if (typeof id !== "string" || typeof name !== "string") {
+            throw new requirement_1.RoomException("Invalid room payload: missing id or name");
+        }
+        return {
+            id,
+            name,
+            metadata: metadata && typeof metadata === "object" ? metadata : {},
+        };
+    }
+    parseProjectRoomGrant(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid room grant payload");
+        }
+        const roomData = data.room;
+        const room = this.parseRoom(roomData);
+        const userId = data.user_id ?? data.userId;
+        if (typeof userId !== "string") {
+            throw new requirement_1.RoomException("Invalid room grant payload: missing user_id");
+        }
+        const permissionsRaw = data.permissions;
+        const permissions = permissionsRaw && typeof permissionsRaw === "object" ? participant_token_1.ApiScope.fromJSON(permissionsRaw) : new participant_token_1.ApiScope();
+        return { room, userId, permissions };
+    }
+    parseProjectRoomGrantCount(data) {
+        const roomData = (data && typeof data === "object") ? (data.room ?? { id: data.room_id, name: data.room_name, metadata: data.metadata ?? {} }) : undefined;
+        if (!roomData) {
+            throw new requirement_1.RoomException("Invalid room grant count payload: missing room");
+        }
+        const room = this.parseRoom(roomData);
+        const count = data.count;
+        if (typeof count !== "number") {
+            throw new requirement_1.RoomException("Invalid room grant count payload: missing count");
+        }
+        return { room, count };
+    }
+    parseProjectUserGrantCount(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid room grant user count payload");
+        }
+        const { user_id: userIdRaw, userId, count, first_name: firstNameRaw, firstName, last_name: lastNameRaw, lastName, email } = data;
+        const userIdValue = typeof userId === "string" ? userId : userIdRaw;
+        if (typeof userIdValue !== "string") {
+            throw new requirement_1.RoomException("Invalid room grant user count payload: missing user_id");
+        }
+        if (typeof count !== "number") {
+            throw new requirement_1.RoomException("Invalid room grant user count payload: missing count");
+        }
+        if (typeof email !== "string") {
+            throw new requirement_1.RoomException("Invalid room grant user count payload: missing email");
+        }
+        return {
+            userId: userIdValue,
+            count,
+            firstName: typeof firstName === "string" ? firstName : firstNameRaw,
+            lastName: typeof lastName === "string" ? lastName : lastNameRaw,
+            email,
+        };
+    }
+    parseBalance(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid balance payload");
+        }
+        const balanceValue = data.balance;
+        if (typeof balanceValue !== "number") {
+            throw new requirement_1.RoomException("Invalid balance payload: missing balance");
+        }
+        const threshold = data.auto_recharge_threshold ?? data.autoRechargeThreshold;
+        const amount = data.auto_recharge_amount ?? data.autoRechargeAmount;
+        const lastRechargeRaw = data.last_recharge ?? data.lastRecharge;
+        return {
+            balance: balanceValue,
+            autoRechargeThreshold: typeof threshold === "number" ? threshold : null,
+            autoRechargeAmount: typeof amount === "number" ? amount : null,
+            lastRecharge: typeof lastRechargeRaw === "string" ? new Date(lastRechargeRaw) : null,
+        };
+    }
+    parseTransaction(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid transaction payload");
+        }
+        const { id, amount, reference, referenceType, reference_type: referenceTypeRaw, description, created_at: createdAtRaw, createdAt } = data;
+        if (typeof id !== "string" || typeof amount !== "number" || typeof description !== "string") {
+            throw new requirement_1.RoomException("Invalid transaction payload: missing fields");
+        }
+        const createdValue = typeof createdAt === "string" ? createdAt : createdAtRaw;
+        if (typeof createdValue !== "string") {
+            throw new requirement_1.RoomException("Invalid transaction payload: missing created_at");
+        }
+        const referenceTypeValue = typeof referenceType === "string" ? referenceType : referenceTypeRaw;
+        return {
+            id,
+            amount,
+            reference: typeof reference === "string" ? reference : null,
+            referenceType: typeof referenceTypeValue === "string" ? referenceTypeValue : null,
+            description,
+            createdAt: new Date(createdValue),
+        };
+    }
+    parseSecret(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid secret payload");
+        }
+        const type = data.type;
+        if (type === "docker") {
+            const server = data.server;
+            const username = data.username;
+            const password = data.password;
+            if (typeof server !== "string" || typeof username !== "string" || typeof password !== "string") {
+                throw new requirement_1.RoomException("Invalid docker secret payload");
+            }
+            return {
+                id: typeof data.id === "string" ? data.id : undefined,
+                name: data.name,
+                type: "docker",
+                server,
+                username,
+                password,
+                email: typeof data.email === "string" ? data.email : undefined,
+            };
+        }
+        if (type === "keys") {
+            const record = data.data;
+            if (!record || typeof record !== "object") {
+                throw new requirement_1.RoomException("Invalid keys secret payload");
+            }
+            return {
+                id: typeof data.id === "string" ? data.id : undefined,
+                name: data.name,
+                type: "keys",
+                data: record,
+            };
+        }
+        throw new requirement_1.RoomException(`Unknown secret type: ${type}`);
+    }
+    toSecretPayload(secret) {
+        if (secret.type === "docker") {
+            return {
+                name: secret.name,
+                type: secret.type,
+                data: {
+                    server: secret.server,
+                    username: secret.username,
+                    password: secret.password,
+                    email: secret.email ?? "none@example.com",
+                },
+            };
+        }
+        return {
+            name: secret.name,
+            type: secret.type,
+            data: { ...secret.data },
+        };
+    }
+    parseOAuthClient(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid OAuth client payload");
+        }
+        const { client_id: clientIdRaw, clientId, client_secret: clientSecretRaw, clientSecret, grant_types: grantTypesRaw, grantTypes, response_types: responseTypesRaw, responseTypes, redirect_uris: redirectUrisRaw, redirectUris, scope, project_id: projectIdRaw, projectId, metadata } = data;
+        const clientIdValue = typeof clientId === "string" ? clientId : clientIdRaw;
+        const clientSecretValue = typeof clientSecret === "string" ? clientSecret : clientSecretRaw;
+        const grantTypesValue = Array.isArray(grantTypes) ? grantTypes : grantTypesRaw;
+        const responseTypesValue = Array.isArray(responseTypes) ? responseTypes : responseTypesRaw;
+        const redirectUrisValue = Array.isArray(redirectUris) ? redirectUris : redirectUrisRaw;
+        const projectIdValue = typeof projectId === "string" ? projectId : projectIdRaw;
+        if (typeof clientIdValue !== "string" ||
+            typeof clientSecretValue !== "string" ||
+            !Array.isArray(grantTypesValue) ||
+            !Array.isArray(responseTypesValue) ||
+            !Array.isArray(redirectUrisValue) ||
+            typeof scope !== "string" ||
+            typeof projectIdValue !== "string") {
+            throw new requirement_1.RoomException("Invalid OAuth client payload: missing required fields");
+        }
+        return {
+            clientId: clientIdValue,
+            clientSecret: clientSecretValue,
+            grantTypes: grantTypesValue.map(String),
+            responseTypes: responseTypesValue.map(String),
+            redirectUris: redirectUrisValue.map(String),
+            scope,
+            projectId: projectIdValue,
+            metadata: metadata && typeof metadata === "object" ? metadata : {},
+        };
+    }
+    parseRoomConnectionInfo(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid room connection payload");
+        }
+        const { jwt, room_name: roomNameRaw, roomName, project_id: projectIdRaw, projectId, room_url: roomUrlRaw, roomUrl } = data;
+        const roomNameValue = typeof roomName === "string" ? roomName : roomNameRaw;
+        const projectIdValue = typeof projectId === "string" ? projectId : projectIdRaw;
+        const roomUrlValue = typeof roomUrl === "string" ? roomUrl : roomUrlRaw;
+        if (typeof jwt !== "string" || typeof roomNameValue !== "string" || typeof projectIdValue !== "string" || typeof roomUrlValue !== "string") {
+            throw new requirement_1.RoomException("Invalid room connection payload: missing fields");
+        }
+        return { jwt, roomName: roomNameValue, projectId: projectIdValue, roomUrl: roomUrlValue };
+    }
+    encodePathComponent(value) {
+        return encodeURIComponent(value);
+    }
+    async upload({ projectId, path, data }) {
+        let body = data;
+        if (data instanceof ArrayBuffer) {
+            body = new Uint8Array(data);
+        }
+        await this.request(`/projects/${projectId}/storage/upload`, {
+            method: "POST",
+            query: { path },
+            body,
+            headers: { "Content-Type": "application/octet-stream" },
+            action: "upload file",
+            responseType: "void",
+        });
+    }
+    async download({ projectId, path }) {
+        return await this.request(`/projects/${projectId}/storage/download`, {
+            method: "GET",
+            query: { path },
+            action: "download file",
+            responseType: "arrayBuffer",
+        });
+    }
+    async getProjectRole(projectId) {
+        const payload = await this.request(`/accounts/projects/${projectId}/role`, {
+            action: "fetch project role",
+        });
+        const role = payload?.role;
+        if (role !== "member" && role !== "admin" && role !== "developer") {
+            throw new requirement_1.RoomException("Invalid role payload");
+        }
+        return role;
+    }
+    async createShare(projectId, settings) {
+        return await this.request(`/accounts/projects/${projectId}/shares`, {
+            method: "POST",
+            json: { settings: settings ?? {} },
+            action: "create share",
+        });
+    }
+    async deleteShare(projectId, shareId) {
+        await this.request(`/accounts/projects/${projectId}/shares/${shareId}`, {
+            method: "DELETE",
+            action: "delete share",
+            responseType: "void",
+        });
+    }
+    async updateShare(projectId, shareId, settings) {
+        await this.request(`/accounts/projects/${projectId}/shares/${shareId}`, {
+            method: "PUT",
+            json: { settings: settings ?? {} },
+            action: "update share",
+            responseType: "void",
+        });
+    }
+    async listShares(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/shares`, {
+            action: "list shares",
+        });
+        const shares = Array.isArray(data?.shares) ? data.shares : [];
+        return shares.map((item) => this.parseRoomShare(item));
+    }
+    async connectShare(shareId) {
+        const data = await this.request(`/shares/${shareId}/connect`, {
+            method: "POST",
+            json: {},
+            action: "connect share",
+        });
+        return this.parseRoomShareConnectionInfo(data);
+    }
+    async createProject(name, settings) {
+        return await this.request(`/accounts/projects`, {
+            method: "POST",
+            json: { name, settings },
+            action: "create project",
+        });
+    }
+    async addUserToProject(projectId, userId, options = {}) {
+        const { isAdmin = false, isDeveloper = false } = options;
+        return await this.request(`/accounts/projects/${projectId}/users`, {
+            method: "POST",
+            json: {
+                project_id: projectId,
+                user_id: userId,
+                is_admin: isAdmin,
+                is_developer: isDeveloper,
+            },
+            action: "add user to project",
+        });
+    }
+    async removeUserFromProject(projectId, userId) {
+        return await this.request(`/accounts/projects/${projectId}/users/${userId}`, {
+            method: "DELETE",
+            action: "remove user from project",
+        });
+    }
+    async updateProjectSettings(projectId, settings) {
+        return await this.request(`/accounts/projects/${projectId}/settings`, {
+            method: "PUT",
+            json: settings,
+            action: "update project settings",
+        });
+    }
+    async getUsersInProject(projectId) {
+        return await this.request(`/accounts/projects/${projectId}/users`, {
+            action: "fetch project users",
+        });
+    }
+    async getUserProfile(userId) {
+        return await this.request(`/accounts/profiles/${userId}`, {
+            action: "fetch user profile",
+        });
+    }
+    async updateUserProfile(userId, firstName, lastName) {
+        return await this.request(`/accounts/profiles/${userId}`, {
+            method: "PUT",
+            json: { first_name: firstName, last_name: lastName },
+            action: "update user profile",
+        });
+    }
+    async listProjects() {
+        return await this.request(`/accounts/projects`, {
+            action: "list projects",
+        });
+    }
+    async getProject(projectId) {
+        return await this.request(`/accounts/projects/${projectId}`, {
+            action: "get project",
+        });
+    }
+    async createApiKey(projectId, name, description) {
+        return await this.request(`/accounts/projects/${projectId}/api-keys`, {
+            method: "POST",
+            json: { name, description },
+            action: "create api key",
+        });
+    }
+    async deleteApiKey(projectId, id) {
+        await this.request(`/accounts/projects/${projectId}/api-keys/${id}`, {
+            method: "DELETE",
+            action: "delete api key",
+            responseType: "void",
+        });
+    }
+    async listApiKeys(projectId) {
+        return await this.request(`/accounts/projects/${projectId}/api-keys`, {
+            action: "list api keys",
+        });
+    }
+    async getPricing() {
+        return await this.request(`/pricing`, {
+            action: "fetch pricing data",
+        });
+    }
+    async getStatus(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/status`, {
+            action: "fetch project status",
+        });
+        const enabled = data?.["enabled"];
+        if (typeof enabled !== "boolean") {
+            throw new requirement_1.RoomException("Invalid status payload: expected boolean 'enabled'");
+        }
+        return enabled;
+    }
+    async getBalance(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/balance`, {
+            action: "fetch balance",
+        });
+        return this.parseBalance(data);
+    }
+    async getRecentTransactions(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/transactions`, {
+            action: "fetch transactions",
+        });
+        const list = Array.isArray(data?.transactions) ? data.transactions : [];
+        return list.map((item) => this.parseTransaction(item));
+    }
+    async setAutoRecharge({ projectId, enabled, amount, threshold }) {
+        await this.request(`/accounts/projects/${projectId}/recharge`, {
+            method: "POST",
+            json: { enabled, amount, threshold },
+            action: "update auto recharge settings",
+            responseType: "void",
+        });
+    }
+    async getCheckoutUrl(projectId, { successUrl, cancelUrl }) {
+        const data = await this.request(`/accounts/projects/${projectId}/subscription`, {
+            method: "POST",
+            json: { success_url: successUrl, cancel_url: cancelUrl },
+            action: "create subscription checkout",
+        });
+        const url = data?.["checkout_url"];
+        if (typeof url !== "string") {
+            throw new requirement_1.RoomException("Invalid subscription payload: expected 'checkout_url' string");
+        }
+        return url;
+    }
+    async getCreditsCheckoutUrl(projectId, { successUrl, cancelUrl, quantity }) {
+        const data = await this.request(`/accounts/projects/${projectId}/credits`, {
+            method: "POST",
+            json: { success_url: successUrl, cancel_url: cancelUrl, quantity },
+            action: "create credits checkout",
+        });
+        const url = data?.["checkout_url"];
+        if (typeof url !== "string") {
+            throw new requirement_1.RoomException("Invalid credits payload: expected 'checkout_url' string");
+        }
+        return url;
+    }
+    async getSubscription(projectId) {
+        return await this.request(`/accounts/projects/${projectId}/subscription`, {
+            action: "fetch subscription",
+        });
+    }
+    async getUsage(projectId, options = {}) {
+        const { start, end, interval, report } = options;
+        const data = await this.request(`/accounts/projects/${projectId}/usage`, {
+            query: {
+                start: start ? start.toISOString() : undefined,
+                end: end ? end.toISOString() : undefined,
+                interval,
+                report,
+            },
+            action: "retrieve usage",
+        });
+        const usage = data?.["usage"];
+        if (!Array.isArray(usage)) {
+            throw new requirement_1.RoomException("Invalid usage payload: expected 'usage' to be a list");
+        }
+        return usage.filter((item) => item && typeof item === "object");
+    }
+    async getSession(projectId, sessionId) {
+        return await this.request(`/accounts/projects/${projectId}/sessions/${sessionId}`, {
+            action: "fetch session",
+        });
+    }
+    async listActiveSessions(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/sessions/active`, {
+            action: "list active sessions",
+        });
+        const sessions = Array.isArray(data?.sessions) ? data.sessions : [];
+        return sessions.map((item) => this.parseRoomSession(item));
+    }
+    async listRecentSessions(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/sessions`, {
+            action: "list sessions",
+        });
+        const sessions = Array.isArray(data?.sessions) ? data.sessions : [];
+        return sessions.map((item) => this.parseRoomSession(item));
+    }
+    async listSessionEvents(projectId, sessionId) {
+        const data = await this.request(`/accounts/projects/${projectId}/sessions/${sessionId}/events`, {
+            action: "list session events",
+        });
+        const events = data?.["events"];
+        return Array.isArray(events) ? events : [];
+    }
+    async terminateSession(projectId, sessionId) {
+        await this.request(`/accounts/projects/${projectId}/sessions/${sessionId}/terminate`, {
+            method: "POST",
+            action: "terminate session",
+            responseType: "void",
+        });
+    }
+    async listSessionSpans(projectId, sessionId) {
+        const data = await this.request(`/accounts/projects/${projectId}/sessions/${sessionId}/spans`, {
+            action: "list session spans",
+        });
+        const spans = data?.["spans"];
+        return Array.isArray(spans) ? spans : [];
+    }
+    async listSessionMetrics(projectId, sessionId) {
+        const data = await this.request(`/accounts/projects/${projectId}/sessions/${sessionId}/metrics`, {
+            action: "list session metrics",
+        });
+        const metrics = data?.["metrics"];
+        return Array.isArray(metrics) ? metrics : [];
+    }
+    async createWebhook(projectId, params) {
+        const { name, url, events, description = "", action: webhookAction = "", payload = null } = params;
+        return await this.request(`/accounts/projects/${projectId}/webhooks`, {
+            method: "POST",
+            json: { name, description, url, events, action: webhookAction, payload },
+            action: "create webhook",
+        });
+    }
+    async updateWebhook(projectId, webhookId, params) {
+        const { name, url, events, description = "", action: webhookAction = null, payload = null } = params;
+        return await this.request(`/accounts/projects/${projectId}/webhooks/${webhookId}`, {
+            method: "PUT",
+            json: { name, description, url, events, action: webhookAction, payload },
+            action: "update webhook",
+        });
+    }
+    async listWebhooks(projectId) {
+        return await this.request(`/accounts/projects/${projectId}/webhooks`, {
+            action: "list webhooks",
+        });
+    }
+    async deleteWebhook(projectId, webhookId) {
+        await this.request(`/accounts/projects/${projectId}/webhooks/${webhookId}`, {
+            method: "DELETE",
+            action: "delete webhook",
+            responseType: "void",
+        });
+    }
+    async createMailbox(params) {
+        const { projectId, address, room, queue } = params;
+        await this.request(`/accounts/projects/${projectId}/mailboxes`, {
+            method: "POST",
+            json: { address, room, queue },
+            action: "create mailbox",
+            responseType: "void",
+        });
+    }
+    async updateMailbox(params) {
+        const { projectId, address, room, queue } = params;
+        await this.request(`/accounts/projects/${projectId}/mailboxes/${address}`, {
+            method: "PUT",
+            json: { room, queue },
+            action: "update mailbox",
+            responseType: "void",
+        });
+    }
+    async listMailboxes(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/mailboxes`, {
+            action: "list mailboxes",
+        });
+        const mailboxes = Array.isArray(data?.mailboxes) ? data.mailboxes : [];
+        return mailboxes.map((item) => {
+            if (!item || typeof item !== "object") {
+                throw new requirement_1.RoomException("Invalid mailbox payload");
+            }
+            const { address, room, queue } = item;
+            if (typeof address !== "string" || typeof room !== "string" || typeof queue !== "string") {
+                throw new requirement_1.RoomException("Invalid mailbox payload: missing fields");
+            }
+            return { address, room, queue };
+        });
+    }
+    async deleteMailbox(projectId, address) {
+        await this.request(`/accounts/projects/${projectId}/mailboxes/${address}`, {
+            method: "DELETE",
+            action: "delete mailbox",
+            responseType: "void",
+        });
+    }
+    async createService(projectId, service) {
+        const data = await this.request(`/accounts/projects/${projectId}/services`, {
+            method: "POST",
+            json: serializeServiceSpec(service),
+            action: "create service",
+        });
+        if (!data || typeof data !== "object" || typeof data.id !== "string") {
+            throw new requirement_1.RoomException("Invalid create service response payload");
+        }
+        return data.id;
+    }
+    async createRoomService(projectId, roomName, service) {
+        const data = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/services`, {
+            method: "POST",
+            json: serializeServiceSpec(service),
+            action: "create room service",
+        });
+        if (!data || typeof data !== "object" || typeof data.id !== "string") {
+            throw new requirement_1.RoomException("Invalid create room service response payload");
+        }
+        return data.id;
+    }
+    async updateRoomService(projectId, roomName, serviceId, service) {
+        await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/services/${serviceId}`, {
+            method: "PUT",
+            json: serializeServiceSpec(service),
+            action: "update room service",
+            responseType: "void",
+        });
+    }
+    async getRoomService(projectId, roomName, serviceId) {
+        const data = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/services/${serviceId}`, {
+            action: "fetch room service",
+        });
+        return data;
+    }
+    async listRoomServices(projectId, roomName) {
+        const data = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/services`, {
+            action: "list room services",
+        });
+        const services = Array.isArray(data?.services) ? data.services : [];
+        return services;
+    }
+    async deleteRoomService(projectId, roomName, serviceId) {
+        await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/services/${serviceId}`, {
+            method: "DELETE",
+            action: "delete room service",
+            responseType: "void",
+        });
+    }
+    async updateService(projectId, serviceId, service) {
+        if (!service.id) {
+            throw new requirement_1.RoomException("Service id must be set to update a service");
+        }
+        await this.request(`/accounts/projects/${projectId}/services/${serviceId}`, {
+            method: "PUT",
+            json: serializeServiceSpec(service),
+            action: "update service",
+            responseType: "void",
+        });
+    }
+    async getService(projectId, serviceId) {
+        const data = await this.request(`/accounts/projects/${projectId}/services/${serviceId}`, {
+            action: "fetch service",
+        });
+        return data;
+    }
+    async listServices(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/services`, {
+            action: "list services",
+        });
+        const services = Array.isArray(data?.services) ? data.services : [];
+        return services;
+    }
+    async deleteService(projectId, serviceId) {
+        await this.request(`/accounts/projects/${projectId}/services/${serviceId}`, {
+            method: "DELETE",
+            action: "delete service",
+            responseType: "void",
+        });
+    }
+    async createSecret(projectId, secret) {
+        await this.request(`/accounts/projects/${projectId}/secrets`, {
+            method: "POST",
+            json: this.toSecretPayload(secret),
+            action: "create secret",
+            responseType: "void",
+        });
+    }
+    async updateSecret(projectId, secret) {
+        if (!secret.id) {
+            throw new requirement_1.RoomException("Secret id is required to update a secret");
+        }
+        await this.request(`/accounts/projects/${projectId}/secrets/${secret.id}`, {
+            method: "PUT",
+            json: this.toSecretPayload(secret),
+            action: "update secret",
+            responseType: "void",
+        });
+    }
+    async deleteSecret(projectId, secretId) {
+        await this.request(`/accounts/projects/${projectId}/secrets/${secretId}`, {
+            method: "DELETE",
+            action: "delete secret",
+            responseType: "void",
+        });
+    }
+    async listSecrets(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/secrets`, {
+            action: "list secrets",
+        });
+        const secrets = Array.isArray(data?.secrets) ? data.secrets : [];
+        return secrets.map((item) => this.parseSecret(item));
+    }
+    async createRoom(params) {
+        const { projectId, name, ifNotExists = false, metadata, permissions } = params;
+        const payload = {
+            name,
+            if_not_exists: Boolean(ifNotExists),
+            metadata,
+        };
+        if (permissions) {
+            const serialized = {};
+            for (const [key, value] of Object.entries(permissions)) {
+                serialized[key] = value instanceof participant_token_1.ApiScope ? value.toJSON() : value;
+            }
+            payload["permissions"] = serialized;
+        }
+        const data = await this.request(`/accounts/projects/${projectId}/rooms`, {
+            method: "POST",
+            json: payload,
+            action: "create room",
+        });
+        return this.parseRoom(data);
+    }
+    async getRoom(projectId, name) {
+        const data = await this.request(`/accounts/projects/${projectId}/rooms/${name}`, {
+            action: "fetch room",
+        });
+        return this.parseRoom(data);
+    }
+    async updateRoom(projectId, roomId, name) {
+        await this.request(`/accounts/projects/${projectId}/rooms/${roomId}`, {
+            method: "PUT",
+            json: { name },
+            action: "update room",
+            responseType: "void",
+        });
+    }
+    async deleteRoom(projectId, roomId) {
+        await this.request(`/accounts/projects/${projectId}/rooms/${roomId}`, {
+            method: "DELETE",
+            action: "delete room",
+            responseType: "void",
+        });
+    }
+    async connectRoom(projectId, room) {
+        const data = await this.request(`/accounts/projects/${projectId}/rooms/${room}/connect`, {
+            method: "POST",
+            json: {},
+            action: "connect room",
+        });
+        return this.parseRoomConnectionInfo(data);
+    }
+    async createRoomGrant(params) {
+        const { projectId, roomId, userId, permissions } = params;
+        await this.request(`/accounts/projects/${projectId}/room-grants`, {
+            method: "POST",
+            json: {
+                room_id: roomId,
+                user_id: userId,
+                permissions: permissions.toJSON(),
+            },
+            action: "create room grant",
+            responseType: "void",
+        });
+    }
+    async createRoomGrantByEmail(params) {
+        const { projectId, roomId, email, permissions } = params;
+        await this.request(`/accounts/projects/${projectId}/room-grants`, {
+            method: "POST",
+            json: {
+                room_id: roomId,
+                email,
+                permissions: permissions.toJSON(),
+            },
+            action: "create room grant",
+            responseType: "void",
+        });
+    }
+    async updateRoomGrant(params) {
+        const { projectId, roomId, userId, permissions, grantId } = params;
+        const gid = grantId ?? "unused";
+        await this.request(`/accounts/projects/${projectId}/room-grants/${gid}`, {
+            method: "PUT",
+            json: {
+                room_id: roomId,
+                user_id: userId,
+                permissions: permissions.toJSON(),
+            },
+            action: "update room grant",
+            responseType: "void",
+        });
+    }
+    async deleteRoomGrant(projectId, roomId, userId) {
+        const room = this.encodePathComponent(roomId);
+        const user = this.encodePathComponent(userId);
+        await this.request(`/accounts/projects/${projectId}/room-grants/${room}/${user}`, {
+            method: "DELETE",
+            action: "delete room grant",
+            responseType: "void",
+        });
+    }
+    async getRoomGrant(projectId, roomId, userId) {
+        const room = this.encodePathComponent(roomId);
+        const user = this.encodePathComponent(userId);
+        const data = await this.request(`/accounts/projects/${projectId}/room-grants/${room}/${user}`, {
+            action: "fetch room grant",
+        });
+        return this.parseProjectRoomGrant(data);
+    }
+    async listRooms(projectId, options = {}) {
+        const { limit = 50, offset = 0, orderBy = "room_name" } = options;
+        const data = await this.request(`/accounts/projects/${projectId}/rooms`, {
+            query: { limit, offset, order_by: orderBy },
+            action: "list rooms",
+        });
+        const rooms = Array.isArray(data?.rooms) ? data.rooms : [];
+        return rooms.map((item) => this.parseRoom(item));
+    }
+    async listRoomGrants(projectId, options = {}) {
+        const { limit = 50, offset = 0, orderBy = "room_name" } = options;
+        const data = await this.request(`/accounts/projects/${projectId}/room-grants`, {
+            query: { limit, offset, order_by: orderBy },
+            action: "list room grants",
+        });
+        const grants = Array.isArray(data?.room_grants) ? data.room_grants : [];
+        return grants.map((item) => this.parseProjectRoomGrant(item));
+    }
+    async listRoomGrantsByUser(projectId, userId, options = {}) {
+        const { limit = 50, offset = 0 } = options;
+        const encodedUser = this.encodePathComponent(userId);
+        const data = await this.request(`/accounts/projects/${projectId}/room-grants/by-user/${encodedUser}`, {
+            query: { limit, offset },
+            action: "list room grants by user",
+        });
+        const grants = Array.isArray(data?.room_grants) ? data.room_grants : [];
+        return grants.map((item) => this.parseProjectRoomGrant(item));
+    }
+    async listRoomGrantsByRoom(projectId, roomId, options = {}) {
+        const { limit = 50, offset = 0 } = options;
+        const encodedRoom = this.encodePathComponent(roomId);
+        const data = await this.request(`/accounts/projects/${projectId}/room-grants/by-room/${encodedRoom}`, {
+            query: { limit, offset },
+            action: "list room grants by room",
+        });
+        const grants = Array.isArray(data?.room_grants) ? data.room_grants : [];
+        return grants.map((item) => this.parseProjectRoomGrant(item));
+    }
+    async listUniqueRoomsWithGrants(projectId, options = {}) {
+        const { limit = 50, offset = 0 } = options;
+        const data = await this.request(`/accounts/projects/${projectId}/room-grants/by-room`, {
+            query: { limit, offset },
+            action: "list unique rooms with grants",
+        });
+        const rooms = Array.isArray(data?.rooms) ? data.rooms : [];
+        return rooms.map((item) => this.parseProjectRoomGrantCount(item));
+    }
+    async listUniqueUsersWithGrants(projectId, options = {}) {
+        const { limit = 50, offset = 0 } = options;
+        const data = await this.request(`/accounts/projects/${projectId}/room-grants/by-user`, {
+            query: { limit, offset },
+            action: "list unique users with grants",
+        });
+        const users = Array.isArray(data?.users) ? data.users : [];
+        return users.map((item) => this.parseProjectUserGrantCount(item));
+    }
+    async createOAuthClient(projectId, params) {
+        const { grantTypes, responseTypes, redirectUris, scope, metadata = {} } = params;
+        const data = await this.request(`/accounts/projects/${projectId}/oauth/clients`, {
+            method: "POST",
+            json: { grant_types: grantTypes, response_types: responseTypes, redirect_uris: redirectUris, scope, metadata },
+            action: "create oauth client",
+        });
+        return this.parseOAuthClient(data);
+    }
+    async updateOAuthClient(projectId, clientId, params) {
+        const body = {};
+        if (params.grantTypes !== undefined)
+            body["grant_types"] = params.grantTypes;
+        if (params.responseTypes !== undefined)
+            body["response_types"] = params.responseTypes;
+        if (params.redirectUris !== undefined)
+            body["redirect_uris"] = params.redirectUris;
+        if (params.scope !== undefined)
+            body["scope"] = params.scope;
+        if (params.metadata !== undefined)
+            body["metadata"] = params.metadata;
+        return await this.request(`/accounts/projects/${projectId}/oauth/clients/${clientId}`, {
+            method: "PUT",
+            json: body,
+            action: "update oauth client",
+        });
+    }
+    async listOAuthClients(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/oauth/clients`, {
+            action: "list oauth clients",
+        });
+        const clients = Array.isArray(data?.clients) ? data.clients : [];
+        return clients.map((item) => this.parseOAuthClient(item));
+    }
+    async getOAuthClient(projectId, clientId) {
+        const data = await this.request(`/accounts/projects/${projectId}/oauth/clients/${clientId}`, {
+            action: "fetch oauth client",
+        });
+        return this.parseOAuthClient(data);
+    }
+    async deleteOAuthClient(projectId, clientId) {
+        await this.request(`/accounts/projects/${projectId}/oauth/clients/${clientId}`, {
+            method: "DELETE",
+            action: "delete oauth client",
+            responseType: "void",
+        });
+    }
+}
+exports.Meshagent = Meshagent;