@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/src/omadaClient/network.ts

@@ -1,284 +0,0 @@
-import type { OmadaApiResponse, PaginatedResult } from '../types/index.js';
-
-import type { RequestHandler } from './request.js';
-import type { SiteOperations } from './site.js';
-
-/**
- * Network-related operations for the Omada API.
- * Covers internet, LAN, WLAN, firewall, and port forwarding configurations.
- */
-export class NetworkOperations {
-    constructor(
-        private readonly request: RequestHandler,
-        private readonly site: SiteOperations,
-        private readonly buildPath: (path: string, version?: string) => string
-    ) {}
-
-    /**
-     * Get internet configuration info for a site.
-     * OperationId: getInternet
-     */
-    public async getInternetInfo(siteId?: string): Promise<unknown> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/internet`);
-        const response = await this.request.get<OmadaApiResponse<unknown>>(path);
-        return this.request.ensureSuccess(response);
-    }
-
-    /**
-     * Get port forwarding status for a specific type (User or UPnP).
-     * OperationId: getPortForwardStatus
-     *
-     * @param type - Port forwarding type: 'User' or 'UPnP'
-     * @param siteId - Optional site ID (uses default if not provided)
-     * @param page - Page number (required by API, default: 1)
-     * @param pageSize - Page size (required by API, range: 1-1000, default: 10)
-     */
-    public async getPortForwardingStatus(type: 'User' | 'UPnP', siteId?: string, page = 1, pageSize = 10): Promise<PaginatedResult<unknown>> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/insight/port-forwarding/${encodeURIComponent(type)}`);
-
-        const response = await this.request.get<OmadaApiResponse<PaginatedResult<unknown>>>(path, {
-            page,
-            pageSize,
-        });
-
-        return this.request.ensureSuccess(response);
-    }
-
-    /**
-     * Get LAN network list (v2 API) with pagination.
-     * OperationId: getLanNetworkListV2
-     */
-    public async getLanNetworkList(siteId?: string): Promise<unknown[]> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/lan-networks`, 'v2');
-        return await this.request.fetchPaginated<unknown>(path);
-    }
-
-    /**
-     * Get LAN profile list with pagination.
-     * OperationId: getLanProfileList
-     */
-    public async getLanProfileList(siteId?: string): Promise<unknown[]> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/lan-profiles`);
-        return await this.request.fetchPaginated<unknown>(path);
-    }
-
-    /**
-     * Get WLAN group list.
-     * OperationId: getWlanGroupList
-     */
-    public async getWlanGroupList(siteId?: string): Promise<unknown[]> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/wireless-network/wlans`);
-        const response = await this.request.get<OmadaApiResponse<unknown[]>>(path);
-        return this.request.ensureSuccess(response);
-    }
-
-    /**
-     * Get SSID list for a specific WLAN group.
-     * OperationId: getSsidList
-     *
-     * @param wlanId - WLAN group ID (can be obtained from getWlanGroupList)
-     */
-    public async getSsidList(wlanId: string, siteId?: string): Promise<unknown[]> {
-        if (!wlanId) {
-            throw new Error('A wlanId must be provided. Use omada_read at path /wifi/groups to get available WLAN group IDs.');
-        }
-
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/wireless-network/wlans/${encodeURIComponent(wlanId)}/ssids`);
-        return await this.request.fetchPaginated<unknown>(path);
-    }
-
-    /**
-     * Get detailed information for a specific SSID.
-     * OperationId: getSsidDetail
-     *
-     * @param wlanId - WLAN group ID (can be obtained from getWlanGroupList)
-     * @param ssidId - SSID ID (can be obtained from getSsidList)
-     */
-    public async getSsidDetail(wlanId: string, ssidId: string, siteId?: string): Promise<unknown> {
-        if (!wlanId) {
-            throw new Error('A wlanId must be provided. Use omada_read at path /wifi/groups to get available WLAN group IDs.');
-        }
-        if (!ssidId) {
-            throw new Error('An ssidId must be provided. Use omada_read at path /wifi/ssids to get available SSID IDs.');
-        }
-
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(
-            `/sites/${encodeURIComponent(resolvedSiteId)}/wireless-network/wlans/${encodeURIComponent(wlanId)}/ssids/${encodeURIComponent(ssidId)}`
-        );
-        const response = await this.request.get<OmadaApiResponse<unknown>>(path);
-        return this.request.ensureSuccess(response);
-    }
-
-    /**
-     * Get firewall settings for a site.
-     * OperationId: getFirewallSetting
-     */
-    public async getFirewallSetting(siteId?: string): Promise<unknown> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/firewall`);
-        const response = await this.request.get<OmadaApiResponse<unknown>>(path);
-        return this.request.ensureSuccess(response);
-    }
-
-    /**
-     * List every SSID on the site, flattened across WLAN groups.
-     * OperationId: listAllSsids — returns [{wlanId, wlanName, ssidList:[{ssidId, ssidName}]}].
-     */
-    public async listAllSsids(siteId?: string): Promise<WlanSimpleInfo[]> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/wireless-network/ssids`);
-        const response = await this.request.get<OmadaApiResponse<WlanSimpleInfo[]>>(path);
-        return this.request.ensureSuccess(response);
-    }
-
-    /**
-     * List time-range profiles for the site.
-     * OperationId: listTimeRangeProfiles — returns [{profileId, name, dayMode, ...}].
-     */
-    public async listTimeRangeProfiles(siteId?: string): Promise<TimeRangeProfileInfo[]> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/time-range-profiles`);
-        const response = await this.request.get<OmadaApiResponse<TimeRangeProfileInfo[]>>(path);
-        return this.request.ensureSuccess(response);
-    }
-
-    /**
-     * Create a time-range profile. The API returns no profileId — callers must
-     * re-list and match by name to obtain the created profile's id.
-     * OperationId: createSitesTimeRangeProfiles
-     */
-    public async createTimeRangeProfile(profile: CreateTimeRangeProfile, siteId?: string): Promise<void> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(`/sites/${encodeURIComponent(resolvedSiteId)}/time-range-profiles`);
-        const response = await this.request.post<OmadaApiResponse<unknown>>(path, profile);
-        this.request.ensureSuccess(response);
-    }
-
-    /**
-     * Update the WLAN-schedule config of a single SSID.
-     * OperationId: updateSitesWirelessNetworkWlansSsidsUpdateWlanSchedule
-     * Omada has no direct SSID on/off — the WLAN schedule (action 0 = radio off
-     * during the scheduled period) is the controller's sanctioned mechanism.
-     */
-    public async updateSsidWlanSchedule(
-        wlanId: string,
-        ssidId: string,
-        schedule: { wlanScheduleEnable: boolean; action?: number; scheduleId?: string },
-        siteId?: string
-    ): Promise<void> {
-        const resolvedSiteId = this.site.resolveSiteId(siteId);
-        const path = this.buildPath(
-            `/sites/${encodeURIComponent(resolvedSiteId)}/wireless-network/wlans/${encodeURIComponent(wlanId)}/ssids/${encodeURIComponent(ssidId)}/update-wlan-schedule`
-        );
-        const response = await this.request.patch<OmadaApiResponse<unknown>>(path, schedule);
-        this.request.ensureSuccess(response);
-    }
-
-    /**
-     * Enable or disable an SSID (e.g. the guest network) by name or ssidId.
-     *
-     * Omada 6.x exposes no direct enable flag on an SSID; the sanctioned lever is
-     * the per-SSID WLAN schedule. Disabling applies an always-on "radio off"
-     * schedule (a 24/7 time-range profile is created once and reused); enabling
-     * simply turns the schedule off again. Fully reversible, and unlike a MAC
-     * filter it actually stops the SSID from broadcasting.
-     */
-    public async setSsidEnabled(ssid: string, enabled: boolean, siteId?: string): Promise<SsidEnableResult> {
-        const wlans = await this.listAllSsids(siteId);
-        const needle = ssid.trim().toLowerCase();
-        let match: { wlanId: string; ssidId: string; ssidName: string } | undefined;
-        for (const wlan of wlans) {
-            for (const s of wlan.ssidList ?? []) {
-                if (s.ssidId === ssid || s.ssidName.toLowerCase() === needle) {
-                    match = { wlanId: wlan.wlanId, ssidId: s.ssidId, ssidName: s.ssidName };
-                    break;
-                }
-            }
-            if (match) break;
-        }
-        if (!match) {
-            const available = wlans.flatMap((w) => (w.ssidList ?? []).map((s) => s.ssidName)).join(', ');
-            throw new Error(`SSID '${ssid}' not found. Available SSIDs: ${available || '(none)'}`);
-        }
-
-        if (enabled) {
-            await this.updateSsidWlanSchedule(match.wlanId, match.ssidId, { wlanScheduleEnable: false }, siteId);
-            return { ...match, enabled: true, method: 'wlan-schedule disabled' };
-        }
-
-        const scheduleId = await this.ensureAlwaysProfile(siteId);
-        await this.updateSsidWlanSchedule(
-            match.wlanId,
-            match.ssidId,
-            { wlanScheduleEnable: true, action: 0, scheduleId },
-            siteId
-        );
-        return { ...match, enabled: false, method: 'wlan-schedule radio-off 24/7', scheduleId };
-    }
-
-    /**
-     * Find-or-create the 24/7 time-range profile used to switch SSIDs off.
-     * Created once per site under a fixed name, then reused forever.
-     */
-    private async ensureAlwaysProfile(siteId?: string): Promise<string> {
-        const existing = await this.listTimeRangeProfiles(siteId);
-        const found = existing.find((p) => p.name === ALWAYS_PROFILE_NAME);
-        if (found) {
-            return found.profileId;
-        }
-
-        await this.createTimeRangeProfile(
-            {
-                name: ALWAYS_PROFILE_NAME,
-                dayMode: 0, // Every Day
-                timeList: [{ dayType: 1, startTimeH: 0, startTimeM: 0, endTimeH: 24, endTimeM: 0 }],
-            },
-            siteId
-        );
-
-        // The create endpoint returns no id — re-list and match by name.
-        const after = await this.listTimeRangeProfiles(siteId);
-        const created = after.find((p) => p.name === ALWAYS_PROFILE_NAME);
-        if (!created) {
-            throw new Error(`Time-range profile '${ALWAYS_PROFILE_NAME}' was created but not found on re-list`);
-        }
-        return created.profileId;
-    }
-}
-
-/** Fixed name of the reusable 24/7 profile that backs omada_setSsidEnabled(false). */
-export const ALWAYS_PROFILE_NAME = 'mcp-always (24/7, used by omada_setSsidEnabled)';
-
-export interface WlanSimpleInfo {
-    wlanId: string;
-    wlanName: string;
-    ssidList?: Array<{ ssidId: string; ssidName: string }>;
-}
-
-export interface TimeRangeProfileInfo {
-    profileId: string;
-    name: string;
-    dayMode?: number;
-}
-
-export interface CreateTimeRangeProfile {
-    name: string;
-    dayMode: number;
-    timeList: Array<{ dayType: number; startTimeH: number; startTimeM: number; endTimeH: number; endTimeM: number }>;
-}
-
-export interface SsidEnableResult {
-    wlanId: string;
-    ssidId: string;
-    ssidName: string;
-    enabled: boolean;
-    method: string;
-    scheduleId?: string;
-}

package/src/omadaClient/request.ts

@@ -1,365 +0,0 @@
-import type { Dispatcher } from 'undici';
-import type { OmadaApiResponse, PaginatedResult } from '../types/index.js';
-import { logger } from '../utils/logger.js';
-import { createTlsDispatcher, tlsAwareFetch, type FetchInitWithDispatcher } from '../utils/tlsDispatcher.js';
-
-import type { AuthManager } from './auth.js';
-
-const DEFAULT_PAGE_SIZE = 200;
-
-/** An error the Omada controller reported, with its structured errorCode when it gave one. */
-export class OmadaApiError extends Error {
-    constructor(
-        message: string,
-        readonly errorCode?: number
-    ) {
-        super(message);
-        this.name = 'OmadaApiError';
-    }
-}
-
-export interface RequestOptions {
-    method?: string;
-    url: string;
-    params?: Record<string, unknown>;
-    data?: unknown;
-    headers?: Record<string, string>;
-}
-
-export interface RequestHandlerConfig {
-    baseUrl: string;
-    timeout?: number;
-    strictSsl?: boolean;
-}
-
-/**
- * HTTP request handler for Omada API calls with authentication and retry logic.
- */
-export class RequestHandler {
-    private readonly baseUrl: string;
-    private readonly timeout: number;
-    /** Per-client undici dispatcher; set only when strictSsl is disabled (H2). */
-    private readonly dispatcher?: Dispatcher;
-
-    constructor(
-        config: RequestHandlerConfig,
-        private readonly auth: AuthManager
-    ) {
-        this.baseUrl = config.baseUrl;
-        this.timeout = config.timeout ?? 30000;
-        this.dispatcher = createTlsDispatcher(config.strictSsl, config.baseUrl);
-    }
-
-    /**
-     * Make a GET request to the Omada API.
-     */
-    public async get<T>(path: string, params?: Record<string, unknown>): Promise<T> {
-        return await this.request<T>({ method: 'GET', url: path, params });
-    }
-
-    /**
-     * Make a PATCH request to the Omada API.
-     */
-    public async patch<T>(path: string, data?: unknown): Promise<T> {
-        return await this.request<T>({ method: 'PATCH', url: path, data });
-    }
-
-    /**
-     * Make a PUT request to the Omada API.
-     */
-    public async put<T>(path: string, data?: unknown): Promise<T> {
-        return await this.request<T>({ method: 'PUT', url: path, data });
-    }
-
-    /**
-     * Make a POST request to the Omada API.
-     */
-    public async post<T>(path: string, data?: unknown): Promise<T> {
-        return await this.request<T>({ method: 'POST', url: path, data });
-    }
-
-    /**
-     * Make an arbitrary HTTP request to the Omada API.
-     */
-    public async request<T>(config: RequestOptions, retry = true): Promise<T> {
-        const accessToken = await this.auth.getAccessToken();
-
-        const method = (config.method ?? 'GET').toUpperCase();
-        const url = new URL(config.url, this.baseUrl);
-
-        // Add query parameters
-        if (config.params) {
-            for (const [key, value] of Object.entries(config.params)) {
-                if (value !== undefined && value !== null) {
-                    url.searchParams.set(key, String(value));
-                }
-            }
-        }
-
-        const headers: Record<string, string> = {
-            'Content-Type': 'application/json',
-            Accept: 'application/json',
-            Authorization: `AccessToken=${accessToken}`,
-            ...(config.headers ?? {}),
-        };
-
-        logger.info('Omada request', {
-            method,
-            url: config.url,
-            params: config.params,
-            siteId: config.params?.siteId ?? undefined,
-        });
-
-        logger.debug('Omada request details', {
-            method,
-            url: config.url,
-            headers: this.sanitizeHeaders(headers),
-            params: config.params ?? null,
-            data: this.sanitizePayload(config.data),
-        });
-
-        try {
-            // For self-signed certificates we relax TLS validation for THIS client
-            // only, via a per-instance undici dispatcher (H2). Node's global fetch
-            // ignores the legacy `agent` option, and toggling the process-global
-            // NODE_TLS_REJECT_UNAUTHORIZED env var would disable validation for every
-            // concurrent outbound request in the process.
-            const init: FetchInitWithDispatcher = {
-                method,
-                headers,
-                body: config.data ? JSON.stringify(config.data) : undefined,
-                signal: AbortSignal.timeout(this.timeout),
-            };
-            if (this.dispatcher) {
-                init.dispatcher = this.dispatcher;
-            }
-
-            // tlsAwareFetch: dispatcher requests use undici's own fetch (pairing rule).
-            const response = await tlsAwareFetch(url.toString(), init);
-
-            logger.info('Omada response', {
-                method,
-                url: config.url,
-                status: response.status,
-            });
-
-            // Parse response body
-            const responseData = (await response.json()) as T;
-
-            logger.debug('Omada response payload', {
-                method,
-                url: config.url,
-                status: response.status,
-                data: this.sanitizePayload(responseData),
-            });
-
-            // Check if the response data indicates an authentication error
-            const errorCode = (responseData as { errorCode?: number } | undefined)?.errorCode;
-            const errorMsg = (responseData as { msg?: string } | undefined)?.msg;
-
-            if (retry && (this.isAuthErrorCode(errorCode) || this.isTokenExpiredMessage(errorMsg))) {
-                logger.warn('Omada authentication error in response, retrying with fresh token', {
-                    method,
-                    url: config.url,
-                    errorCode,
-                    message: errorMsg,
-                });
-                this.auth.clearToken();
-                return this.request<T>(config, false);
-            }
-
-            // Handle HTTP errors after checking for auth errors in body
-            if (!response.ok && !this.isAuthErrorCode(errorCode)) {
-                logger.error('Omada request failed', {
-                    method,
-                    url: config.url,
-                    status: response.status,
-                    statusText: response.statusText,
-                    errorCode,
-                    message: errorMsg,
-                });
-                // Surface the controller's own structured errorCode/msg when present
-                // (safe diagnostic data — the controller's description, not an internal
-                // hostname/header) so a rejected request explains itself instead of
-                // collapsing to a bare HTTP status like "400 ".
-                const parts = [`${response.status} ${response.statusText}`.trim()];
-                if (errorMsg) {
-                    parts.push(`- ${errorMsg}`);
-                }
-                if (errorCode !== undefined && errorCode !== 0) {
-                    parts.push(`(errorCode ${errorCode})`);
-                }
-                throw new OmadaApiError(`Omada API request failed: ${parts.join(' ')}`, errorCode);
-            }
-
-            return responseData;
-        } catch (error) {
-            logger.error('Omada request failed', {
-                method,
-                url: config.url,
-                message: error instanceof Error ? error.message : String(error),
-            });
-
-            if (!retry) {
-                throw error;
-            }
-
-            // Check if it's a network/timeout error that might be auth-related
-            const isNetworkError = error instanceof TypeError ||
-                (error instanceof Error && error.name === 'AbortError');
-
-            if (isNetworkError) {
-                throw error;
-            }
-
-            throw error;
-        }
-    }
-
-    /**
-     * Fetch all pages of a paginated API endpoint.
-     */
-    public async fetchPaginated<T>(path: string, params: Record<string, unknown> = {}): Promise<T[]> {
-        const records: T[] = [];
-        let page = 1;
-        let totalRows: number | undefined;
-
-        // Fetch sequential pages because OpenAPI requires explicit pagination parameters.
-        do {
-            const response = await this.get<OmadaApiResponse<PaginatedResult<T>>>(path, {
-                ...params,
-                page,
-                pageSize: DEFAULT_PAGE_SIZE,
-            });
-
-            const result = this.ensureSuccess(response);
-            const pageData = result.data ?? [];
-            totalRows = result.totalRows ?? totalRows;
-
-            records.push(...pageData);
-            page += 1;
-
-            if (pageData.length === 0) {
-                break;
-            }
-        } while (!totalRows || records.length < totalRows);
-
-        return records;
-    }
-
-    /**
-     * Ensure an Omada API response indicates success.
-     * @throws {Error} If the response contains an error code
-     */
-    public ensureSuccess<T>(response: OmadaApiResponse<T>): T {
-        if (response.errorCode !== 0) {
-            logger.error('Omada API error', {
-                errorCode: response.errorCode,
-                message: response.msg,
-            });
-            throw new OmadaApiError(response.msg ?? 'Omada API request failed', response.errorCode);
-        }
-
-        return (response.result ?? ({} as T)) as T;
-    }
-
-    /**
-     * Check if an error code indicates an authentication error.
-     */
-    private isAuthErrorCode(errorCode?: number): boolean {
-        if (errorCode === undefined) {
-            return false;
-        }
-
-        return [-44106, -44111, -44112, -44113, -44114, -44116].includes(errorCode);
-    }
-
-    /**
-     * Check if an error message indicates token expiration.
-     */
-    private isTokenExpiredMessage(message?: string): boolean {
-        if (!message) {
-            return false;
-        }
-
-        const lowerMsg = message.toLowerCase();
-        return (
-            lowerMsg.includes('access token has expired') ||
-            lowerMsg.includes('token has expired') ||
-            lowerMsg.includes('token expired') ||
-            lowerMsg.includes('re-initiate the refreshtoken')
-        );
-    }
-
-    /**
-     * Sanitize HTTP headers for logging, masking sensitive values.
-     */
-    private sanitizeHeaders(headers: Record<string, string> | undefined): Record<string, unknown> | undefined {
-        if (!headers) {
-            return undefined;
-        }
-
-        const sanitized: Record<string, unknown> = {};
-        for (const [key, value] of Object.entries(headers)) {
-            sanitized[key] = this.isSensitiveKey(key) ? this.maskValue(value) : value;
-        }
-
-        return sanitized;
-    }
-
-    /**
-     * Sanitize a payload for logging, masking sensitive values.
-     */
-    private sanitizePayload(payload: unknown): unknown {
-        if (!payload || typeof payload !== 'object') {
-            return payload;
-        }
-
-        if (Array.isArray(payload)) {
-            return payload.map((item) => this.sanitizePayload(item));
-        }
-
-        const sanitized: Record<string, unknown> = {};
-        for (const [key, value] of Object.entries(payload)) {
-            sanitized[key] = this.isSensitiveKey(key) ? this.maskValue(value) : this.sanitizePayload(value);
-        }
-
-        return sanitized;
-    }
-
-    /**
-     * Check if a key name indicates sensitive data.
-     */
-    private isSensitiveKey(key: string): boolean {
-        const normalized = key.toLowerCase();
-        return (
-            normalized.includes('authorization') ||
-            normalized.includes('token') ||
-            normalized.includes('secret') ||
-            normalized.includes('password') ||
-            normalized.includes('client_id')
-        );
-    }
-
-    /**
-     * Mask a sensitive value for logging.
-     */
-    private maskValue(value: unknown): unknown {
-        if (typeof value === 'string') {
-            if (value.length <= 8) {
-                return '********';
-            }
-            return `${value.slice(0, 4)}…${value.slice(-4)}`;
-        }
-
-        if (Array.isArray(value)) {
-            return value.map(() => '********');
-        }
-
-        if (typeof value === 'object' && value !== null) {
-            return '[masked-object]';
-        }
-
-        return '********';
-    }
-}

package/src/omadaClient/security.ts

@@ -1,51 +0,0 @@
-import type { OmadaApiResponse, PaginatedResult, GetThreatListOptions, ThreatInfo } from '../types/index.js';
-import type { RequestHandler } from './request.js';
-
-/**
- * Security-related operations for the Omada API.
- * Handles threat management and security features.
- */
-export class SecurityOperations {
-    constructor(
-        private readonly request: RequestHandler,
-        private readonly buildPath: (path: string) => string
-    ) {}
-
-    /**
-     * Get the global view threat management list.
-     * operationId: getGlobalThreatList
-     *
-     * @param options - Threat list query options
-     * @returns Paginated list of threat information
-     */
-    async getThreatList(options: GetThreatListOptions): Promise<PaginatedResult<ThreatInfo>> {
-        const params: Record<string, unknown> = {
-            archived: options.archived,
-            page: options.page,
-            pageSize: options.pageSize,
-            'filters.startTime': options.startTime,
-            'filters.endTime': options.endTime,
-        };
-
-        if (options.siteList) {
-            params.siteList = options.siteList;
-        }
-
-        if (options.severity !== undefined) {
-            params['filters.severity'] = options.severity;
-        }
-
-        if (options.sortTime) {
-            params['sorts.time'] = options.sortTime;
-        }
-
-        if (options.searchKey) {
-            params.searchKey = options.searchKey;
-        }
-
-        const path = this.buildPath('/security/threat-management');
-
-        const response = await this.request.get<OmadaApiResponse<PaginatedResult<ThreatInfo>>>(path, params);
-        return this.request.ensureSuccess(response);
-    }
-}