openvsx-webui-test 0.17.2 → 0.18.0-dev.1

package/src/extension-registry-service.ts

@@ -12,7 +12,10 @@ import {
     Extension, UserData, ExtensionCategory, ExtensionReviewList, PersonalAccessToken, SearchResult, NewReview,
     SuccessResult, ErrorResult, CsrfTokenJson, isError, Namespace, NamespaceDetails, MembershipRole, SortBy,
     SortOrder, UrlString, NamespaceMembershipList, PublisherInfo, SearchEntry, RegistryVersion,
-    LoginProviders
+    LoginProviders, ScanResultJson, ScanCounts, ScanResultsResponse, ScanFilterOptions,
+    FilesResponse, FileDecisionCountsJson, ScanDecisionRequest, ScanDecisionResponse,
+    FileDecisionRequest, FileDecisionResponse, FileDecisionDeleteRequest, FileDecisionDeleteResponse,
+    Tier, TierList, Customer, CustomerList, UsageStatsList,
 } from './extension-registry-types';
 import { createAbsoluteURL, addQuery } from './utils';
 import { sendRequest, ErrorResponse } from './server-request';
@@ -209,6 +212,22 @@ export class ExtensionRegistryService {
         });
     }
 
+    async deleteUserReview(abortController: AbortController, extension: Extension, user: UserData): Promise<Readonly<SuccessResult | ErrorResult>> {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers: Record<string, string> = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.serverUrl, 'admin', 'extension', extension.namespace, extension.name, 'review', user.provider || 'github', user.loginName, 'delete']),
+            headers
+        });
+    }
+
     getUser(abortController: AbortController): Promise<Readonly<UserData | ErrorResult>> {
         return sendRequest({
             abortController,
@@ -470,6 +489,26 @@ export interface AdminService {
     getPublisherInfo(abortController: AbortController, provider: string, login: string): Promise<Readonly<PublisherInfo>>
     revokePublisherContributions(abortController: AbortController, provider: string, login: string): Promise<Readonly<SuccessResult | ErrorResult>>
     revokeAccessTokens(abortController: AbortController, provider: string, login: string): Promise<Readonly<SuccessResult | ErrorResult>>
+    getAllScans(abortController: AbortController, params?: { size?: number; offset?: number; status?: string | string[]; publisher?: string; namespace?: string; name?: string; validationType?: string[]; threatScannerName?: string[]; dateStartedFrom?: string; dateStartedTo?: string; enforcement?: 'enforced' | 'notEnforced' | 'all' }): Promise<Readonly<ScanResultsResponse>>
+    getScan(abortController: AbortController, scanId: string): Promise<Readonly<ScanResultJson>>
+    getScanCounts(abortController: AbortController, params?: { dateStartedFrom?: string; dateStartedTo?: string; enforcement?: 'enforced' | 'notEnforced' | 'all'; threatScannerName?: string[]; validationType?: string[] }): Promise<Readonly<ScanCounts>>
+    getScanFilterOptions(abortController: AbortController): Promise<Readonly<ScanFilterOptions>>
+    // Files API
+    getFiles(abortController: AbortController, params?: { size?: number; offset?: number; decision?: string; publisher?: string; namespace?: string; name?: string; dateDecidedFrom?: string; dateDecidedTo?: string; sortBy?: string; sortOrder?: 'asc' | 'desc' }): Promise<Readonly<FilesResponse>>;
+    getFileCounts(abortController: AbortController, params?: { dateDecidedFrom?: string; dateDecidedTo?: string }): Promise<Readonly<FileDecisionCountsJson>>
+    // Decision APIs
+    makeScanDecision(abortController: AbortController, request: ScanDecisionRequest): Promise<Readonly<ScanDecisionResponse>>
+    makeFileDecision(abortController: AbortController, request: FileDecisionRequest): Promise<Readonly<FileDecisionResponse>>
+    deleteFileDecisions(abortController: AbortController, request: FileDecisionDeleteRequest): Promise<Readonly<FileDecisionDeleteResponse>>
+    getTiers(abortController: AbortController): Promise<Readonly<TierList>>;
+    createTier(abortController: AbortController, tier: Tier): Promise<Readonly<Tier>>;
+    updateTier(abortController: AbortController, name: string, tier: Tier): Promise<Readonly<Tier>>;
+    deleteTier(abortController: AbortController, name: string): Promise<Readonly<SuccessResult | ErrorResult>>;
+    getCustomers(abortController: AbortController): Promise<Readonly<CustomerList>>;
+    createCustomer(abortController: AbortController, customer: Customer): Promise<Readonly<Customer>>;
+    updateCustomer(abortController: AbortController, name: string, customer: Customer): Promise<Readonly<Customer>>;
+    deleteCustomer(abortController: AbortController, name: string): Promise<Readonly<SuccessResult | ErrorResult>>;
+    getUsageStats(abortController: AbortController, customerName: string, date: Date): Promise<Readonly<UsageStatsList>>;
 }
 
 export interface AdminServiceConstructor {
@@ -593,6 +632,338 @@ export class AdminServiceImpl implements AdminService {
             headers
         });
     }
+
+    getAllScans(abortController: AbortController, params?: { size?: number; offset?: number; status?: string | string[]; publisher?: string; namespace?: string; name?: string; validationType?: string[]; threatScannerName?: string[]; dateStartedFrom?: string; dateStartedTo?: string; enforcement?: 'enforced' | 'notEnforced' | 'all'; adminDecision?: string[] }): Promise<Readonly<ScanResultsResponse>> {
+        const query: { key: string, value: string | number }[] = [];
+        if (params) {
+            if (params.size !== undefined)
+                query.push({ key: 'size', value: params.size });
+            if (params.offset !== undefined)
+                query.push({ key: 'offset', value: params.offset });
+            if (params.status) {
+                const statusValue = Array.isArray(params.status) ? params.status.join(',') : params.status;
+                query.push({ key: 'status', value: statusValue });
+            }
+            if (params.publisher)
+                query.push({ key: 'publisher', value: params.publisher });
+            if (params.namespace)
+                query.push({ key: 'namespace', value: params.namespace });
+            if (params.name)
+                query.push({ key: 'name', value: params.name });
+            if (params.validationType && params.validationType.length > 0)
+                query.push({ key: 'validationType', value: params.validationType.join(',') });
+            if (params.threatScannerName && params.threatScannerName.length > 0)
+                query.push({ key: 'threatScannerName', value: params.threatScannerName.join(',') });
+            if (params.dateStartedFrom)
+                query.push({ key: 'dateStartedFrom', value: params.dateStartedFrom });
+            if (params.dateStartedTo)
+                query.push({ key: 'dateStartedTo', value: params.dateStartedTo });
+            if (params.enforcement)
+                query.push({ key: 'enforcement', value: params.enforcement });
+            if (params.adminDecision && params.adminDecision.length > 0)
+                query.push({ key: 'adminDecision', value: params.adminDecision.join(',') });
+        }
+        const endpoint = createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans'], query);
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint
+        });
+    }
+
+    getScan(abortController: AbortController, scanId: string): Promise<Readonly<ScanResultJson>> {
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', scanId])
+        });
+    }
+
+    getScanCounts(abortController: AbortController, params?: { dateStartedFrom?: string; dateStartedTo?: string; enforcement?: 'enforced' | 'notEnforced' | 'all'; threatScannerName?: string[]; validationType?: string[] }): Promise<Readonly<ScanCounts>> {
+        const query: { key: string, value: string | number }[] = [];
+        if (params) {
+            if (params.dateStartedFrom)
+                query.push({ key: 'dateStartedFrom', value: params.dateStartedFrom });
+            if (params.dateStartedTo)
+                query.push({ key: 'dateStartedTo', value: params.dateStartedTo });
+            if (params.enforcement)
+                query.push({ key: 'enforcement', value: params.enforcement });
+            if (params.threatScannerName && params.threatScannerName.length > 0) {
+                query.push({ key: 'threatScannerName', value: params.threatScannerName.join(',') });
+            }
+            if (params.validationType && params.validationType.length > 0) {
+                query.push({ key: 'validationType', value: params.validationType.join(',') });
+            }
+        }
+        const endpoint = createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'counts'], query);
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint
+        });
+    }
+
+    getScanFilterOptions(abortController: AbortController): Promise<Readonly<ScanFilterOptions>> {
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'filterOptions'])
+        });
+    }
+
+    getFiles(abortController: AbortController, params?: { size?: number; offset?: number; decision?: string; publisher?: string; namespace?: string; name?: string; dateDecidedFrom?: string; dateDecidedTo?: string; sortBy?: string; sortOrder?: 'asc' | 'desc' }): Promise<Readonly<FilesResponse>> {
+        const query: { key: string, value: string | number }[] = [];
+        if (params) {
+            if (params.size !== undefined)
+                query.push({ key: 'size', value: params.size });
+            if (params.offset !== undefined)
+                query.push({ key: 'offset', value: params.offset });
+            if (params.decision)
+                query.push({ key: 'decision', value: params.decision });
+            if (params.publisher)
+                query.push({ key: 'publisher', value: params.publisher });
+            if (params.namespace)
+                query.push({ key: 'namespace', value: params.namespace });
+            if (params.name)
+                query.push({ key: 'name', value: params.name });
+            if (params.dateDecidedFrom)
+                query.push({ key: 'dateDecidedFrom', value: params.dateDecidedFrom });
+            if (params.dateDecidedTo)
+                query.push({ key: 'dateDecidedTo', value: params.dateDecidedTo });
+            if (params.sortBy)
+                query.push({ key: 'sortBy', value: params.sortBy });
+            if (params.sortOrder)
+                query.push({ key: 'sortOrder', value: params.sortOrder });
+        }
+        const endpoint = createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files'], query);
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint
+        });
+    }
+
+    getFileCounts(abortController: AbortController, params?: { dateDecidedFrom?: string; dateDecidedTo?: string }): Promise<Readonly<FileDecisionCountsJson>> {
+        const query: { key: string, value: string | number }[] = [];
+        if (params) {
+            if (params.dateDecidedFrom)
+                query.push({ key: 'dateDecidedFrom', value: params.dateDecidedFrom });
+            if (params.dateDecidedTo)
+                query.push({ key: 'dateDecidedTo', value: params.dateDecidedTo });
+        }
+        const endpoint = createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'counts'], query);
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint
+        });
+    }
+
+    async makeScanDecision(abortController: AbortController, request: ScanDecisionRequest): Promise<Readonly<ScanDecisionResponse>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'decisions']),
+            headers,
+            payload: request
+        });
+    }
+
+    async makeFileDecision(abortController: AbortController, request: FileDecisionRequest): Promise<Readonly<FileDecisionResponse>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'decisions']),
+            headers,
+            payload: request
+        });
+    }
+
+    async deleteFileDecisions(abortController: AbortController, request: FileDecisionDeleteRequest): Promise<Readonly<FileDecisionDeleteResponse>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+
+        return sendRequest({
+            abortController,
+            method: 'DELETE',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'decisions']),
+            headers,
+            payload: request
+        });
+    }
+
+    async getTiers(abortController: AbortController): Promise<Readonly<TierList>> {
+        return sendRequest({
+            abortController,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers']),
+            credentials: true
+        }, false);
+    }
+
+    async createTier(abortController: AbortController, tier: Tier): Promise<Readonly<Tier>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            payload: tier,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers', 'create']),
+            headers
+        }, false);
+    }
+
+    async updateTier(abortController: AbortController, name: string, tier: Tier): Promise<Readonly<Tier>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'PUT',
+            payload: tier,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers', name]),
+            headers
+        }, false);
+    }
+
+    async deleteTier(abortController: AbortController, name: string): Promise<SuccessResult | ErrorResult> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'DELETE',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'tiers', name]),
+            headers
+        }, false);
+    }
+
+    async getCustomers(abortController: AbortController): Promise<Readonly<CustomerList>> {
+        return sendRequest({
+            abortController,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers']),
+            credentials: true
+        }, false);
+    }
+
+    async createCustomer(abortController: AbortController, customer: Customer): Promise<Readonly<Customer>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            payload: customer,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', 'create']),
+            headers
+        }, false);
+    }
+
+    async updateCustomer(abortController: AbortController, name: string, customer: Customer): Promise<Readonly<Customer>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'PUT',
+            payload: customer,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name]),
+            headers
+        }, false);
+    }
+
+    async deleteCustomer(abortController: AbortController, name: string): Promise<SuccessResult | ErrorResult> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'DELETE',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', name]),
+            headers
+        }, false);
+    }
+
+    /**
+     * Get usage stats for a customer within an optional date range.
+     */
+    async getUsageStats(
+        abortController: AbortController,
+        customerName: string,
+        date: Date,
+    ): Promise<Readonly<UsageStatsList>> {
+        const query: { key: string, value: string | number }[] = [];
+        query.push({ key: 'date', value: date.toISOString() });
+
+        return sendRequest({
+            abortController,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'ratelimit', 'customers', customerName, 'usage'], query),
+            credentials: true
+        }, false);
+    }
 }
 
 export interface ExtensionFilter {

package/src/extension-registry-types.ts

@@ -78,6 +78,8 @@ export interface Extension {
     // key: version, value: url
     allVersions: { [version: string]: UrlString };
     active?: boolean;
+    reviewStatus?: 'published' | 'under_review' | 'rejected';
+    reviewMessage?: string;
 
     averageRating?: number;
     downloadCount: number;
@@ -258,3 +260,208 @@ export interface LoginProviders {
 export type MembershipRole = 'contributor' | 'owner';
 export type SortBy = 'relevance' | 'timestamp' | 'rating' | 'downloadCount';
 export type SortOrder = 'asc' | 'desc';
+
+// Scan and file decision types (used by admin scan UI)
+export interface ScanResultJson {
+    id: string;
+    namespace: string;
+    extensionName: string;
+    version: string;
+    displayName: string;
+    publisher: string;
+    extensionIcon?: string;
+    downloadUrl?: string;
+    publisherUrl?: string;
+    status: string;
+    dateScanStarted: string;
+    dateScanEnded?: string;
+    errorMessage?: string;
+    dateQuarantined?: string;
+    dateRejected?: string;
+    threats?: Array<{
+        id: string;
+        fileName: string;
+        fileHash: string;
+        type: string;
+        severity?: string;
+        reason: string;
+        fileExtension: string;
+        dateDetected: string;
+        ruleName: string;
+        enforcedFlag?: boolean;
+    }>;
+    validationFailures?: Array<{
+        id: string;
+        type: string;
+        ruleName: string;
+        reason: string;
+        dateDetected: string;
+        enforcedFlag: boolean;
+    }>;
+    adminDecision?: {
+        decision: string;
+        decidedBy: string;
+        dateDecided: string;
+    };
+}
+
+export interface ScanCounts {
+    STARTED: number;
+    VALIDATING: number;
+    SCANNING: number;
+    PASSED: number;
+    QUARANTINED: number;
+    AUTO_REJECTED: number;
+    ERROR: number;
+    ALLOWED: number;
+    BLOCKED: number;
+    NEEDS_REVIEW: number;
+}
+
+export interface ScanResultsResponse {
+    success?: string;
+    warning?: string;
+    error?: string;
+    offset: number;
+    totalSize: number;
+    scans: ScanResultJson[];
+}
+
+export interface ScanFilterOptions {
+    validationTypes: string[];
+    threatScannerNames: string[];
+}
+
+export interface FileDecisionJson {
+    id: string;
+    fileName: string;
+    fileHash: string;
+    fileType: string;
+    decision: string;
+    decidedBy: string;
+    dateDecided: string;
+    displayName: string;
+    namespace: string;
+    extensionName: string;
+    publisher: string;
+    version: string;
+    scanId?: string;
+}
+
+export interface FilesResponse {
+    success?: string;
+    warning?: string;
+    error?: string;
+    offset: number;
+    totalSize: number;
+    files: FileDecisionJson[];
+}
+
+export interface FileDecisionCountsJson {
+    allowed: number;
+    blocked: number;
+    total: number;
+}
+
+export interface ScanDecisionRequest {
+    scanIds: string[];
+    decision: string;
+}
+
+export interface ScanDecisionResult {
+    scanId: string;
+    success: boolean;
+    error?: string;
+}
+
+export interface ScanDecisionResponse {
+    processed: number;
+    successful: number;
+    failed: number;
+    results: ScanDecisionResult[];
+}
+
+export interface FileDecisionRequest {
+    fileHashes: string[];
+    decision: string;
+}
+
+export interface FileDecisionResult {
+    fileHash: string;
+    success: boolean;
+    error?: string;
+}
+
+export interface FileDecisionResponse {
+    processed: number;
+    successful: number;
+    failed: number;
+    results: FileDecisionResult[];
+}
+
+export interface FileDecisionDeleteRequest {
+    fileIds: string[];
+}
+
+export interface FileDecisionDeleteResult {
+    fileId: string;
+    success: boolean;
+    error?: string;
+}
+
+export interface FileDecisionDeleteResponse {
+    processed: number;
+    successful: number;
+    failed: number;
+    results: FileDecisionDeleteResult[];
+}
+
+export enum TierType {
+    FREE = 'FREE',
+    SAFETY = 'SAFETY',
+    NON_FREE = 'NON_FREE'
+}
+
+export enum RefillStrategy {
+    GREEDY = 'GREEDY',
+    INTERVAL = 'INTERVAL'
+}
+
+export interface Tier {
+    name: string;
+    description?: string;
+    tierType: TierType;
+    capacity: number;
+    duration: number;
+    refillStrategy: RefillStrategy;
+}
+
+export interface TierList {
+    tiers: Tier[];
+}
+
+export enum EnforcementState {
+    EVALUATION = 'EVALUATION',
+    ENFORCEMENT = 'ENFORCEMENT'
+}
+
+export interface Customer {
+    name: string;
+    tier?: Tier;
+    state: EnforcementState;
+    cidrBlocks: string[];
+}
+
+export interface CustomerList {
+    customers: Customer[];
+}
+
+export interface UsageStats {
+    windowStart: number; // epoch seconds in UTC
+    duration: number; // in seconds
+    count: number;
+}
+
+export interface UsageStatsList {
+    stats: UsageStats[];
+}

package/src/hooks/scan-admin/index.ts

@@ -0,0 +1,48 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+// Core hooks
+export { useTabNavigation, TAB_DEFINITIONS } from './use-tab-navigation';
+export type { UseTabNavigationReturn, TabIndex, TabName } from './use-tab-navigation';
+
+export { useScanFilters } from './use-scan-filters';
+export type { UseScanFiltersReturn } from './use-scan-filters';
+
+export { usePagination } from './use-pagination';
+export type { UsePaginationReturn } from './use-pagination';
+
+export { useSearch } from './use-search';
+export type { UseSearchReturn } from './use-search';
+
+export { useDialogs } from './use-dialogs';
+export type { UseDialogsReturn } from './use-dialogs';
+
+// Tab-specific hooks
+export { useScansTab } from './use-scans-tab';
+export type { UseScansTabReturn } from './use-scans-tab';
+
+export { useQuarantinedTab } from './use-quarantined-tab';
+export type { UseQuarantinedTabReturn } from './use-quarantined-tab';
+
+export { useAutoRejectedTab } from './use-auto-rejected-tab';
+export type { UseAutoRejectedTabReturn } from './use-auto-rejected-tab';
+
+export { useFileListTab, useAllowListTab, useBlockListTab } from './use-file-list-tab';
+export type { UseFileListTabReturn, UseAllowListTabReturn, UseBlockListTabReturn } from './use-file-list-tab';
+
+// URL sync hook
+export { useUrlSync } from './use-url-sync';
+export type { UseUrlSyncReturn } from './use-url-sync';
+
+// Component-specific hooks
+export { useScanCardState } from './use-scan-card-state';