@noatgnu/cupcake-vanilla 1.0.0 → 1.1.0

package/index.d.ts

@@ -1,6 +1,13 @@
 import * as i0 from '@angular/core';
-import { Observable } from 'rxjs';
-import { BaseApiService } from '@cupcake/core';
+import { OnInit, EventEmitter, OnDestroy } from '@angular/core';
+import { Observable, OperatorFunction } from 'rxjs';
+import { BaseApiService, WebSocketService, AuthService, WebSocketMessage, NotificationService as NotificationService$1, ToastService, User, LabGroupService, LabGroup, LabGroupQueryResponse, ResourceVisibility } from '@cupcake/core';
+export { WebSocketMessage } from '@cupcake/core';
+import * as _angular_forms from '@angular/forms';
+import { FormGroup, FormBuilder } from '@angular/forms';
+import { NgbActiveModal, NgbModal } from '@ng-bootstrap/ng-bootstrap';
+import { FavouriteMetadataOption as FavouriteMetadataOption$1, SyntaxType as SyntaxType$1, FavouriteMetadataOptionService as FavouriteMetadataOptionService$1, MetadataColumnService as MetadataColumnService$1, MetadataColumnTemplateService as MetadataColumnTemplateService$1, OntologySuggestion as OntologySuggestion$1, MetadataValidationConfig as MetadataValidationConfig$1, MetadataTable as MetadataTable$1, MetadataTableService as MetadataTableService$1, OntologyTypeConfig as OntologyTypeConfig$1, ColumnTypeConfig as ColumnTypeConfig$1, MetadataColumnTemplate as MetadataColumnTemplate$1, SdrfColumnConfig as SdrfColumnConfig$1, SdrfSyntaxService as SdrfSyntaxService$1 } from '@cupcake/vanilla';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
 
 interface BaseTimestampedModel {
     createdAt: string;
@@ -30,6 +37,7 @@ interface MetadataQueryParams {
 }
 
 declare enum OntologyType {
+    NONE = "",
     SPECIES = "species",
     TISSUE = "tissue",
     HUMAN_DISEASE = "human_disease",
@@ -50,6 +58,13 @@ declare enum TemplatePermissionLevel {
     ADMIN = "admin"
 }
 declare const TemplatePermissionLabels: Record<TemplatePermissionLevel, string>;
+declare enum ColumnType {
+    CHARACTERISTICS = "characteristics",
+    COMMENT = "comment",
+    FACTOR_VALUE = "factor_value",
+    SOURCE_NAME = "source_name",
+    SPECIAL = "special"
+}
 
 interface MetadataTable extends BaseTimestampedModel {
     id: number;
@@ -86,10 +101,46 @@ interface MetadataTableUpdateRequest {
     name?: string;
     description?: string;
     sampleCount?: number;
+    sampleCountConfirmed?: boolean;
     version?: string;
+    labGroup?: number;
     isLocked?: boolean;
     isPublished?: boolean;
 }
+interface SampleCountValidationRequest {
+    newSampleCount: number;
+}
+interface SampleCountValidationResult {
+    valid: boolean;
+    warnings: string[];
+    affectedModifiers: Array<{
+        modifierIndex: number;
+        columnName: string;
+        samples: string;
+        invalidIndices: number[];
+        value: string;
+    }>;
+    affectedPools: Array<{
+        poolName: string;
+        invalidPooledOnly: number[];
+        invalidPooledAndIndependent: number[];
+    }>;
+    samplesToRemove: number[];
+}
+interface SampleCountValidationResponse {
+    currentSampleCount: number;
+    newSampleCount: number;
+    validationResult: SampleCountValidationResult;
+}
+interface SampleCountConfirmationError {
+    sampleCount: string[];
+    sampleCountConfirmationDetails: {
+        currentSampleCount: number;
+        newSampleCount: number;
+        requiresConfirmation: true;
+        validationResult: SampleCountValidationResult;
+    };
+}
 interface MetadataTableQueryResponse {
     count: number;
     next?: string;
@@ -417,6 +468,7 @@ interface CellOntology {
 interface Schema {
     id: number;
     name: string;
+    displayName?: string;
     description?: string;
     category?: string;
     version?: string;
@@ -427,10 +479,10 @@ interface Schema {
 interface OntologySuggestion {
     id: string;
     value: string;
-    display_name: string;
+    displayName: string;
     description?: string;
-    ontology_type: string;
-    full_data?: any;
+    ontologyType: string;
+    fullData?: any;
 }
 interface OntologySuggestionResponse {
     count: number;
@@ -443,34 +495,34 @@ interface UnimodSpecification {
     accession: string;
     name: string;
     definition: string;
-    additional_data: Array<{
+    additionalData: Array<{
         id: string;
         description: string;
     }>;
-    general_properties: Record<string, string>;
+    generalProperties: Record<string, string>;
     specifications: Record<string, UnimodSpecification>;
-    delta_mono_mass: string;
-    delta_avge_mass: string;
-    delta_composition: string;
+    deltaMonoMass: string;
+    deltaAvgeMass: string;
+    deltaComposition: string;
     [key: string]: any;
 }
 interface UnimodFullData {
     accession: string;
     name: string;
     definition: string;
-    additional_data: Array<{
+    additionalData: Array<{
         id: string;
         description: string;
     }>;
-    general_properties: Record<string, string>;
+    generalProperties: Record<string, string>;
     specifications: Record<string, UnimodSpecification>;
-    delta_mono_mass: string;
-    delta_avge_mass: string;
-    delta_composition: string;
+    deltaMonoMass: string;
+    deltaAvgeMass: string;
+    deltaComposition: string;
     [key: string]: any;
 }
 declare function isUnimodFullData(suggestion: any): suggestion is {
-    full_data: UnimodFullData;
+    fullData: UnimodFullData;
 };
 declare class OntologyUtils {
     static getUnimodSpecifications(suggestion: any): (UnimodSpecification & {
@@ -482,8 +534,65 @@ declare class OntologyUtils {
     static formatUnimodName(data: UnimodFullData): string;
 }
 
+interface OntologyCustomFilter {
+    [ontologyType: string]: {
+        [filterKey: string]: string | number | boolean;
+    };
+}
+interface OntologyTypeConfig {
+    value: string;
+    label: string;
+    customFilters?: OntologyCustomFilter;
+}
+interface ColumnTypeConfig {
+    value: string;
+    label: string;
+}
+declare enum MSTermType {
+    INSTRUMENT = "instrument",
+    CLEAVAGE_AGENT = "cleavage agent",
+    DISSOCIATION_METHOD = "dissociation method",
+    SAMPLE_ATTRIBUTE = "sample attribute",
+    CELL_LINE = "cell line",
+    ENRICHMENT_PROCESS = "enrichment process",
+    FRACTIONATION_METHOD = "fractionation method",
+    DATA_ACQUISITION_METHOD = "proteomics data acquisition method",
+    REDUCTION_REAGENT = "reduction reagent",
+    ALKYLATION_REAGENT = "alkylation reagent",
+    MASS_ANALYZER_TYPE = "mass analyzer type",
+    ANCESTRAL_CATEGORY = "ancestral category",
+    SEX = "sex",
+    DEVELOPMENTAL_STAGE = "developmental stage"
+}
+declare const ONTOLOGY_TYPE_CONFIGS: OntologyTypeConfig[];
+declare const COLUMN_TYPE_CONFIGS: ColumnTypeConfig[];
+
+interface SdrfColumnConfig {
+    name: string;
+    type: string;
+    description: string;
+    category?: SdrfColumnCategory;
+    isRequired?: boolean;
+}
+declare enum SdrfColumnCategory {
+    CORE_SAMPLE = "Core Sample Metadata",
+    CHARACTERISTICS = "Characteristics",
+    ASSAY = "Assay Information",
+    COMMENTS = "Comments",
+    MODIFICATIONS = "Modifications & Enzymes",
+    MASS_TOLERANCES = "Mass Tolerances",
+    TECHNICAL_PARAMS = "Technical Parameters",
+    SAMPLE_PREP = "Sample Preparation",
+    FILE_PROJECT = "File & Project Information"
+}
+declare const OFFICIAL_SDRF_COLUMNS: SdrfColumnConfig[];
+declare function getSdrfColumnsByCategory(category?: SdrfColumnCategory): SdrfColumnConfig[];
+declare function getRequiredSdrfColumns(): SdrfColumnConfig[];
+declare function getSdrfColumnByName(name: string): SdrfColumnConfig | undefined;
+declare function isSdrfColumnRequired(name: string): boolean;
+
 type TaskStatus = 'QUEUED' | 'STARTED' | 'SUCCESS' | 'FAILURE' | 'CANCELLED';
-type TaskType = 'EXPORT_EXCEL' | 'EXPORT_SDRF' | 'IMPORT_SDRF' | 'IMPORT_EXCEL' | 'EXPORT_MULTIPLE_SDRF' | 'EXPORT_MULTIPLE_EXCEL' | 'VALIDATE_TABLE';
+type TaskType = 'EXPORT_EXCEL' | 'EXPORT_SDRF' | 'IMPORT_SDRF' | 'IMPORT_EXCEL' | 'EXPORT_MULTIPLE_SDRF' | 'EXPORT_MULTIPLE_EXCEL' | 'VALIDATE_TABLE' | 'REORDER_TABLE_COLUMNS' | 'REORDER_TEMPLATE_COLUMNS';
 interface AsyncTaskStatus {
     id: string;
     taskType: TaskType;
@@ -562,6 +671,13 @@ interface MetadataImportRequest {
     replaceExisting?: boolean;
     validateOntologies?: boolean;
 }
+interface ChunkedImportRequest {
+    metadataTableId: number;
+    chunkedUploadId: string;
+    replaceExisting?: boolean;
+    validateOntologies?: boolean;
+    createPools?: boolean;
+}
 interface MetadataValidationRequest {
     metadataTableId: number;
     validateSdrfFormat?: boolean;
@@ -633,25 +749,11 @@ interface ChunkedUploadCompletionRequest {
     replaceExisting?: boolean;
 }
 interface ChunkedUploadCompletionResponse {
-    message: string;
+    message?: string;
     filename?: string;
     warning?: string;
     error?: string;
-    createdColumns?: number;
-    createdPools?: number;
-    sampleRows?: number;
-    metadataColumns?: Array<{
-        id: number;
-        name: string;
-        type: string;
-        position: number;
-    }>;
-    samplePools?: Array<{
-        id: number;
-        name: string;
-        totalSamples: number;
-        isReference: boolean;
-    }>;
+    taskId?: string;
 }
 
 interface MetadataTableQueryParams {
@@ -726,6 +828,15 @@ declare class MetadataTableService extends BaseApiService {
     normalizeColumnPositions(id: number): Observable<{
         message: string;
     }>;
+    /**
+     * Start async reordering of table columns by schema
+     */
+    reorderColumnsBySchemaAsync(id: number, schemaIds?: number[]): Observable<{
+        taskId: string;
+        message: string;
+        metadataTableId: number;
+        schemaIds: number[];
+    }>;
     /**
      * Get all tables (admin only)
      */
@@ -760,6 +871,13 @@ declare class MetadataTableService extends BaseApiService {
         message: string;
         combinedColumn: any;
     }>;
+    validateSampleCountChange(id: number, request: SampleCountValidationRequest): Observable<SampleCountValidationResponse>;
+    updateSampleCount(id: number, newSampleCount: number, confirmed?: boolean): Observable<{
+        message: string;
+        oldSampleCount: number;
+        newSampleCount: number;
+        cleanupPerformed: boolean;
+    }>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MetadataTableService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MetadataTableService>;
 }
@@ -1011,6 +1129,15 @@ declare class MetadataTableTemplateService extends BaseApiService {
     normalizeColumnPositions(id: number): Observable<{
         message: string;
     }>;
+    /**
+     * Start async reordering of template columns by schema
+     */
+    reorderColumnsBySchemaAsync(id: number, schemaIds?: number[]): Observable<{
+        taskId: string;
+        message: string;
+        templateId: number;
+        schemaIds: number[];
+    }>;
     /**
      * Apply this template to a metadata table
      */
@@ -1064,10 +1191,7 @@ declare class MetadataTableTemplateService extends BaseApiService {
         name: string;
         description?: string;
         sampleCount: number;
-    }): Observable<{
-        message: string;
-        table: MetadataTable;
-    }>;
+    }): Observable<MetadataTable>;
     /**
      * Create a new metadata table directly from schema definitions
      */
@@ -1076,16 +1200,14 @@ declare class MetadataTableTemplateService extends BaseApiService {
         name: string;
         description?: string;
         sampleCount: number;
-    }): Observable<{
-        message: string;
-        table: MetadataTable;
-    }>;
+    }): Observable<MetadataTable>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MetadataTableTemplateService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MetadataTableTemplateService>;
 }
 
 interface FavouriteMetadataOptionQueryParams {
     search?: string;
+    name?: string;
     type?: string;
     userId?: number;
     labGroupId?: number;
@@ -1280,6 +1402,56 @@ declare class MetadataManagementService extends BaseApiService {
     static ɵprov: i0.ɵɵInjectableDeclaration<MetadataManagementService>;
 }
 
+declare class Websocket extends WebSocketService {
+    constructor(authService: AuthService);
+    getMetadataTableUpdates(): Observable<WebSocketMessage>;
+    getLabGroupUpdates(): Observable<WebSocketMessage>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Websocket, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Websocket>;
+}
+
+declare class AdminWebSocketService extends WebSocketService {
+    constructor(authService: AuthService);
+    getAdminNotifications(): Observable<WebSocketMessage>;
+    getSystemNotifications(): Observable<WebSocketMessage>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdminWebSocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdminWebSocketService>;
+}
+
+declare enum NotificationType {
+    SYSTEM = "system",
+    METADATA_TABLE = "metadata_table",
+    LAB_GROUP = "lab_group",
+    FILE_UPLOAD = "file_upload",
+    DATA_PROCESSING = "data_processing",
+    ASYNC_TASK = "async_task",
+    USER = "user"
+}
+declare class NotificationService extends NotificationService$1 {
+    private websocketService;
+    private adminWebSocketService;
+    private isConnected;
+    private isAdminConnected;
+    readonly isWebSocketConnected: i0.Signal<boolean>;
+    readonly isAdminWebSocketConnected: i0.Signal<boolean>;
+    constructor(websocketService: Websocket, adminWebSocketService: AdminWebSocketService, toastService: ToastService);
+    private initializeWebSocket;
+    private setupNotificationHandlers;
+    private handleWebSocketMessage;
+    private createNotificationFromWebSocket;
+    private getAsyncTaskTitle;
+    private getAsyncTaskLevel;
+    private handleAdminWebSocketMessage;
+    connect(): void;
+    connectAdmin(): void;
+    disconnect(): void;
+    disconnectAdmin(): void;
+    subscribeToMetadataTable(tableId: number): void;
+    createVanillaNotification(type: NotificationType, title: string, message: string, level?: 'info' | 'success' | 'warning' | 'error', autoClose?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}
+
 declare class OntologySearchService extends BaseApiService {
     /**
      * Get ontology suggestions across all sources for SDRF validation
@@ -1433,23 +1605,6 @@ declare class AsyncExportService extends BaseApiService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AsyncExportService>;
 }
 
-declare class AsyncImportService extends BaseApiService {
-    /**
-     * Calculate SHA256 hash of a file
-     */
-    private calculateSHA256;
-    sdrfFile(request: MetadataImportRequest): Observable<AsyncTaskCreateResponse>;
-    excelFile(request: MetadataImportRequest): Observable<AsyncTaskCreateResponse>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncImportService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AsyncImportService>;
-}
-
-declare class AsyncValidationService extends BaseApiService {
-    metadataTable(request: MetadataValidationRequest): Observable<AsyncTaskCreateResponse>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncValidationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AsyncValidationService>;
-}
-
 declare class ChunkedUploadService extends BaseApiService {
     /**
      * Initialize or continue a chunked upload
@@ -1463,6 +1618,10 @@ declare class ChunkedUploadService extends BaseApiService {
      * Complete the chunked upload and process the file
      */
     completeUpload(uploadId: string, request?: ChunkedUploadCompletionRequest): Observable<ChunkedUploadCompletionResponse>;
+    /**
+     * Complete the chunked upload by uploading the entire file at once
+     */
+    completeUploadWithFile(request: ChunkedUploadRequest): Observable<ChunkedUploadCompletionResponse>;
     /**
      * Delete/cancel a chunked upload
      */
@@ -1482,10 +1641,835 @@ declare class ChunkedUploadService extends BaseApiService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ChunkedUploadService>;
 }
 
+declare class AsyncImportService extends BaseApiService {
+    private chunkedUploadService;
+    constructor(chunkedUploadService: ChunkedUploadService);
+    sdrfFile(request: MetadataImportRequest): Observable<AsyncTaskCreateResponse>;
+    excelFile(request: MetadataImportRequest): Observable<AsyncTaskCreateResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncImportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AsyncImportService>;
+}
+
+declare class AsyncValidationService extends BaseApiService {
+    metadataTable(request: MetadataValidationRequest): Observable<AsyncTaskCreateResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncValidationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AsyncValidationService>;
+}
+
+interface ChunkedFileImportRequest {
+    file: File;
+    metadataTableId: number;
+    replaceExisting?: boolean;
+    validateOntologies?: boolean;
+    createPools?: boolean;
+}
+interface ChunkedImportProgress {
+    uploadProgress: number;
+    phase: 'uploading' | 'processing' | 'completed' | 'failed';
+    taskId?: string;
+}
+declare class ChunkedImportService extends BaseApiService {
+    private chunkedUploadService;
+    constructor(chunkedUploadService: ChunkedUploadService);
+    /**
+     * Import SDRF file using chunked upload for better performance with large files
+     */
+    importSdrfFileChunked(request: ChunkedFileImportRequest): Observable<AsyncTaskCreateResponse>;
+    /**
+     * Import Excel file using chunked upload for better performance with large files
+     */
+    importExcelFileChunked(request: ChunkedFileImportRequest): Observable<AsyncTaskCreateResponse>;
+    /**
+     * Generic chunked import that auto-detects file type
+     */
+    importFileChunked(request: ChunkedFileImportRequest): Observable<AsyncTaskCreateResponse>;
+    /**
+     * Upload file using chunked upload with metadata processing
+     */
+    private uploadFileChunked;
+    /**
+     * Trigger async import processing after chunked upload completion
+     * This uses the existing async-import endpoints but with chunked upload completion
+     */
+    private triggerAsyncImport;
+    /**
+     * Validate file type
+     */
+    private validateFileType;
+    /**
+     * Get file extension from filename
+     */
+    private getFileExtension;
+    /**
+     * Create progress observable for UI updates
+     */
+    createProgressObservable(request: ChunkedFileImportRequest, onProgress?: (progress: ChunkedImportProgress) => void): Observable<AsyncTaskCreateResponse>;
+    /**
+     * Queue chunked file import task using completed chunked upload
+     * This uses the new backend endpoint that processes already uploaded chunks
+     */
+    processChunkedUpload(request: ChunkedImportRequest): Observable<AsyncTaskCreateResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChunkedImportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChunkedImportService>;
+}
+
+interface AgeFormat {
+    years?: number;
+    months?: number;
+    days?: number;
+    isRange?: boolean;
+    rangeStart?: AgeFormat;
+    rangeEnd?: AgeFormat;
+}
+interface ModificationParameters {
+    NT?: string;
+    AC?: string;
+    CF?: string;
+    MT?: string;
+    PP?: string;
+    TA?: string;
+    MM?: string;
+    TS?: string;
+}
+interface CleavageAgentDetails {
+    NT?: string;
+    AC?: string;
+    CS?: string;
+}
+interface SpikedCompound {
+    SP?: string;
+    CT?: string;
+    QY?: string;
+    PS?: string;
+    AC?: string;
+    CN?: string;
+    CV?: string;
+    CS?: string;
+    CF?: string;
+}
+interface PooledSample {
+    value: 'not pooled' | 'pooled' | string;
+    sourceNames?: string[];
+}
+interface SyntheticPeptide {
+    value: 'synthetic' | 'not synthetic';
+}
+interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings?: string[];
+}
+type SyntaxType = 'age' | 'modification' | 'cleavage' | 'spiked_compound' | 'pooled_sample' | 'synthetic_peptide';
+declare class SdrfSyntaxService {
+    private readonly SPECIAL_COLUMN_PATTERNS;
+    private readonly MODIFICATION_KEYS;
+    private readonly CLEAVAGE_KEYS;
+    private readonly SPIKED_COMPOUND_KEYS;
+    private readonly POOLED_SAMPLE_VALUES;
+    private readonly SYNTHETIC_PEPTIDE_VALUES;
+    /**
+     * Detects if a column requires special SDRF syntax handling
+     */
+    detectSpecialSyntax(columnName: string, columnType: string): SyntaxType | null;
+    /**
+     * Parses a value based on the syntax type
+     */
+    parseValue(syntaxType: SyntaxType, value: string): any;
+    /**
+     * Formats parsed data back to string format
+     */
+    formatValue(syntaxType: SyntaxType, data: any): string;
+    /**
+     * Validates parsed data
+     */
+    validateValue(syntaxType: SyntaxType, data: any): ValidationResult;
+    private parseAgeFormat;
+    private parseSingleAge;
+    private formatAgeFormat;
+    private formatSingleAge;
+    private parseKeyValuePairs;
+    private formatKeyValuePairs;
+    private validateAgeFormat;
+    private validateSingleAge;
+    private validateModificationParameters;
+    private validateCleavageAgentDetails;
+    private validateSpikedCompound;
+    getPooledSampleValues(): string[];
+    getSyntheticPeptideValues(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdrfSyntaxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdrfSyntaxService>;
+}
+
+interface ElectronAPI {
+    platform: string;
+    isElectron: boolean;
+    getAppVersion(): Promise<string>;
+    getElectronVersion(): Promise<string>;
+    minimize(): void;
+    maximize(): void;
+    close(): void;
+    isMaximized(): Promise<boolean>;
+    showOpenDialog(options?: any): Promise<any>;
+    showSaveDialog(options?: any): Promise<any>;
+    showMessageBox(options: any): Promise<any>;
+    downloadFile(url: string, filename?: string): Promise<string>;
+    getBackendPort(): Promise<number>;
+    isBackendReady(): Promise<boolean>;
+    onBackendStatusChange(callback: (status: any) => void): () => void;
+    onWindowStateChange(callback: (state: 'maximized' | 'unmaximized') => void): () => void;
+}
+declare global {
+    interface Window {
+        electronAPI?: ElectronAPI;
+    }
+}
+declare class ElectronService {
+    private electronAPI;
+    constructor();
+    get isElectron(): boolean;
+    get platform(): string;
+    getAppVersion(): Promise<string>;
+    getElectronVersion(): Promise<string>;
+    minimize(): void;
+    maximize(): void;
+    close(): void;
+    isMaximized(): Promise<boolean>;
+    showOpenDialog(options?: any): Promise<any>;
+    showSaveDialog(options?: any): Promise<any>;
+    showMessageBox(options: any): Promise<any>;
+    downloadFile(url: string, filename?: string): Promise<string>;
+    getBackendPort(): Promise<number>;
+    isBackendReady(): Promise<boolean>;
+    onBackendStatusChange(): Observable<any>;
+    onWindowStateChange(): Observable<'maximized' | 'unmaximized'>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElectronService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ElectronService>;
+}
+
+declare class SdrfAgeInput implements OnInit {
+    value: string;
+    valueChange: EventEmitter<string>;
+    private fb;
+    private sdrfSyntax;
+    ageForm: FormGroup;
+    isRange: boolean;
+    ngOnInit(): void;
+    private parseAndSetValue;
+    private updateValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdrfAgeInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdrfAgeInput, "ccv-sdrf-age-input", never, { "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class SdrfModificationInput implements OnInit {
+    value: string;
+    templateId: number | null;
+    columnId: number | null;
+    valueChange: EventEmitter<string>;
+    searchType: i0.WritableSignal<"icontains" | "istartswith">;
+    private fb;
+    private sdrfSyntax;
+    private metadataColumnService;
+    private metadataColumnTemplateService;
+    modificationForm: FormGroup;
+    modificationTypes: string[];
+    positions: string[];
+    selectedUnimodData: i0.WritableSignal<UnimodFullData | null>;
+    availableSpecifications: i0.WritableSignal<(UnimodSpecification & {
+        specNumber: string;
+    })[]>;
+    selectedSpecification: i0.WritableSignal<string | null>;
+    showSpecifications: i0.WritableSignal<boolean>;
+    showHiddenSpecifications: i0.WritableSignal<boolean>;
+    hiddenSpecificationCount: i0.WritableSignal<number>;
+    ngOnInit(): void;
+    private parseAndSetValue;
+    private getStringValue;
+    private updateValue;
+    searchModificationTerms: OperatorFunction<string, readonly OntologySuggestion[]>;
+    formatOntologySuggestion: (suggestion: OntologySuggestion) => string;
+    onOntologySuggestionSelected: (event: any) => void;
+    formatTargetAminoAcids(value: string): string;
+    onTargetAminoAcidChange(event: any): void;
+    onSpecificationSelected(specNumber: string): void;
+    private mapUnimodPosition;
+    private mapClassificationToType;
+    getSpecificationDisplay(spec: UnimodSpecification & {
+        specNumber: string;
+    }): string;
+    onSearchTypeChange(type: 'icontains' | 'istartswith'): void;
+    private updateAvailableSpecifications;
+    toggleHiddenSpecifications(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdrfModificationInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdrfModificationInput, "ccv-sdrf-modification-input", never, { "value": { "alias": "value"; "required": false; }; "templateId": { "alias": "templateId"; "required": false; }; "columnId": { "alias": "columnId"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class SdrfSpikedCompoundInput implements OnInit {
+    value: string;
+    valueChange: EventEmitter<string>;
+    private fb;
+    private sdrfSyntax;
+    spikedForm: FormGroup;
+    compoundTypes: string[];
+    ngOnInit(): void;
+    private parseAndSetValue;
+    private getStringValue;
+    private updateValue;
+    get showProteinFields(): boolean;
+    get showPeptideFields(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdrfSpikedCompoundInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdrfSpikedCompoundInput, "ccv-sdrf-spiked-compound-input", never, { "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class SdrfCleavageInput implements OnInit {
+    value: string;
+    templateId: number | null;
+    columnId: number | null;
+    valueChange: EventEmitter<string>;
+    searchType: i0.WritableSignal<"icontains" | "istartswith">;
+    private fb;
+    private sdrfSyntax;
+    private metadataColumnService;
+    private metadataColumnTemplateService;
+    cleavageForm: FormGroup;
+    ngOnInit(): void;
+    private parseAndSetValue;
+    private getStringValue;
+    private updateValue;
+    searchCleavageTerms: OperatorFunction<string, readonly OntologySuggestion[]>;
+    formatOntologySuggestion: (suggestion: OntologySuggestion) => string;
+    onOntologySuggestionSelected: (event: any) => void;
+    onSearchTypeChange(type: 'icontains' | 'istartswith'): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdrfCleavageInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdrfCleavageInput, "ccv-sdrf-cleavage-input", never, { "value": { "alias": "value"; "required": false; }; "templateId": { "alias": "templateId"; "required": false; }; "columnId": { "alias": "columnId"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+interface MetadataValueEditConfig {
+    columnId?: number;
+    columnName: string;
+    columnType: string;
+    ontologyType?: string;
+    enableTypeahead?: boolean;
+    currentValue?: string;
+    context: 'template' | 'table' | 'pool' | 'favorite_management';
+    templateId?: number;
+    tableId?: number;
+    poolId?: number;
+    customOntologyFilters?: Record<string, any>;
+    enableMultiSampleEdit?: boolean;
+    sampleData?: {
+        index: number;
+        value: string;
+        sourceName?: string;
+    }[];
+    maxSampleCount?: number;
+}
+declare class MetadataValueEditModal implements OnInit {
+    private fb;
+    private activeModal;
+    private authService;
+    private favouriteMetadataOptionService;
+    private metadataColumnService;
+    private metadataColumnTemplateService;
+    private labGroupService;
+    config: MetadataValueEditConfig;
+    valueSaved: EventEmitter<string | {
+        value: string;
+        sampleIndices: number[];
+    }>;
+    editForm: FormGroup;
+    isLoading: i0.WritableSignal<boolean>;
+    isLoadingSuggestions: i0.WritableSignal<boolean>;
+    searchType: i0.WritableSignal<"icontains" | "istartswith">;
+    isLoadingFavorites: i0.WritableSignal<boolean>;
+    userFavorites: i0.WritableSignal<FavouriteMetadataOption$1[]>;
+    labGroupFavorites: i0.WritableSignal<FavouriteMetadataOption$1[]>;
+    globalFavorites: i0.WritableSignal<FavouriteMetadataOption$1[]>;
+    selectedFavorite: i0.WritableSignal<FavouriteMetadataOption$1 | null>;
+    currentUser: i0.WritableSignal<User | null>;
+    userLabGroups: i0.WritableSignal<number[]>;
+    activeFavoritesTab: 'user' | 'lab_group' | 'global';
+    private sdrfSyntaxService;
+    specialSyntaxType: i0.WritableSignal<SyntaxType$1 | null>;
+    showSpecialInput: i0.WritableSignal<boolean>;
+    specialInputValue: i0.WritableSignal<string>;
+    selectedSampleIndices: i0.WritableSignal<Set<number>>;
+    showSamplePanel: i0.WritableSignal<boolean>;
+    constructor(fb: FormBuilder, activeModal: NgbActiveModal, authService: AuthService, favouriteMetadataOptionService: FavouriteMetadataOptionService$1, metadataColumnService: MetadataColumnService$1, metadataColumnTemplateService: MetadataColumnTemplateService$1, labGroupService: LabGroupService);
+    ngOnInit(): void;
+    onCancel(): void;
+    onClose(): void;
+    get title(): string;
+    get hasOntologyType(): boolean;
+    get ontologyTypeLabel(): string;
+    get isFromFavoriteManagement(): boolean;
+    searchOntology: (text$: Observable<string>) => Observable<OntologySuggestion$1[]>;
+    formatSuggestion: (suggestion: OntologySuggestion$1) => string;
+    inputFormatter: (suggestion: OntologySuggestion$1) => string;
+    onSuggestionSelected: (event: any) => void;
+    onSearchTypeChange(type: 'icontains' | 'istartswith'): void;
+    clearValue(): void;
+    loadFavoriteOptions(): void;
+    selectFavorite(favorite: FavouriteMetadataOption$1): void;
+    onFavoriteSelected(event: Event, favoritesList: FavouriteMetadataOption$1[]): void;
+    setActiveFavoritesTab(tab: 'user' | 'lab_group' | 'global'): void;
+    setInitialActiveFavoritesTab(): void;
+    addToFavorites(scope?: 'user' | 'lab_group' | 'global'): void;
+    get hasFavorites(): boolean;
+    getFavoriteDisplayValue(favorite: FavouriteMetadataOption$1): string;
+    getFavoriteTooltip(favorite: FavouriteMetadataOption$1): string;
+    hasCustomDisplayValue(favorite: FavouriteMetadataOption$1): boolean;
+    getSelectedFavoriteInfo(): string;
+    loadUserLabGroups(): void;
+    onSpecialInputChange(value: string): void;
+    toggleSpecialInput(): void;
+    getSpecialInputTitle(): string;
+    get hasMultiSampleEdit(): boolean;
+    get sampleData(): {
+        index: number;
+        value: string;
+        sourceName?: string;
+    }[];
+    toggleSampleSelection(sampleIndex: number): void;
+    selectAllSamples(): void;
+    clearSampleSelection(): void;
+    get selectedSampleCount(): number;
+    get totalSampleCount(): number;
+    isSampleSelected(sampleIndex: number): boolean;
+    onSubmit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataValueEditModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataValueEditModal, "ccv-metadata-value-edit-modal", never, { "config": { "alias": "config"; "required": false; }; }, { "valueSaved": "valueSaved"; }, never, never, true, never>;
+}
+
+interface ExcelExportOptions {
+    includeLabGroups: 'none' | 'selected' | 'all';
+    selectedLabGroupIds: number[];
+    includePools: boolean;
+}
+declare class ExcelExportModalComponent implements OnInit {
+    activeModal: NgbActiveModal;
+    labGroupService: LabGroupService;
+    isLoadingLabGroups: i0.WritableSignal<boolean>;
+    availableLabGroups: i0.WritableSignal<LabGroup[]>;
+    includeLabGroups: i0.WritableSignal<"none" | "selected" | "all">;
+    selectedLabGroupIds: i0.WritableSignal<number[]>;
+    includePools: i0.WritableSignal<boolean>;
+    showLabGroupSelection: i0.Signal<boolean>;
+    canConfirm: i0.Signal<boolean>;
+    ngOnInit(): void;
+    private loadLabGroups;
+    onLabGroupToggle(labGroupId: number, checked: boolean): void;
+    isLabGroupSelected(labGroupId: number): boolean;
+    onIncludeLabGroupsChange(value: 'none' | 'selected' | 'all'): void;
+    selectAllLabGroups(): void;
+    deselectAllLabGroups(): void;
+    confirm(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExcelExportModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExcelExportModalComponent, "ccv-excel-export-modal", never, {}, {}, never, never, true, never>;
+}
+
+interface ValidationResults {
+    success: boolean;
+    metadata_table_id: number;
+    metadata_table_name: string;
+    validation_timestamp: string;
+    errors: string[];
+    warnings: string[];
+}
+declare class ValidationResultsModal {
+    results?: ValidationResults;
+    activeModal: NgbActiveModal;
+    formatTimestamp(timestamp: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationResultsModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ValidationResultsModal, "ccv-validation-results-modal", never, { "results": { "alias": "results"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MetadataValidationModal {
+    config?: MetadataValidationConfig$1;
+    private fb;
+    private asyncTaskService;
+    private toastService;
+    activeModal: NgbActiveModal;
+    isValidating: i0.WritableSignal<boolean>;
+    validationError: i0.WritableSignal<string | null>;
+    validationForm: _angular_forms.FormGroup<{
+        validate_sdrf_format: _angular_forms.FormControl<boolean | null>;
+    }>;
+    onSubmit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataValidationModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataValidationModal, "ccv-metadata-validation-modal", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MetadataTableEditModal implements OnInit {
+    private fb;
+    private activeModal;
+    private modalService;
+    private metadataTableService;
+    private labGroupService;
+    table?: MetadataTable$1;
+    isCreateMode: boolean;
+    tableSaved: EventEmitter<MetadataTable$1>;
+    editForm: FormGroup;
+    isLoading: i0.WritableSignal<boolean>;
+    availableLabGroups: i0.WritableSignal<LabGroup[]>;
+    isLoadingLabGroups: i0.WritableSignal<boolean>;
+    constructor(fb: FormBuilder, activeModal: NgbActiveModal, modalService: NgbModal, metadataTableService: MetadataTableService$1, labGroupService: LabGroupService);
+    ngOnInit(): void;
+    loadLabGroups(): void;
+    onSubmit(): void;
+    private performCreate;
+    private performUpdate;
+    private handleSampleCountConfirmation;
+    private formatAffectedData;
+    private isSampleCountConfirmationError;
+    onCancel(): void;
+    get title(): string;
+    get hasChanges(): boolean;
+    isFieldInvalid(fieldName: string): boolean;
+    getFieldError(fieldName: string): string;
+    private getFieldDisplayName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataTableEditModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataTableEditModal, "ccv-metadata-table-edit-modal", never, { "table": { "alias": "table"; "required": false; }; "isCreateMode": { "alias": "isCreateMode"; "required": false; }; }, { "tableSaved": "tableSaved"; }, never, never, true, never>;
+}
+
+declare class AsyncTaskUIService implements OnDestroy {
+    private destroy$;
+    private tasksSubject;
+    private isSubscribed;
+    private metadataTableRefreshSubject;
+    private taskCompletedSubject;
+    private exportTaskCompletedSubject;
+    private readonly sessionId;
+    private initiatedTasks;
+    private libraryAsyncTaskService;
+    private asyncExportService;
+    private asyncImportService;
+    private asyncValidationService;
+    private toastService;
+    private websocket;
+    private modalService;
+    private electronService;
+    tasks$: Observable<AsyncTaskStatus[]>;
+    activeTasks$: Observable<AsyncTaskStatus[]>;
+    metadataTableRefresh$: Observable<number>;
+    taskCompleted$: Observable<AsyncTaskStatus>;
+    exportTaskCompleted$: Observable<AsyncTaskStatus>;
+    constructor();
+    ngOnDestroy(): void;
+    private initializeService;
+    startRealtimeUpdates(): void;
+    stopRealtimeUpdates(): void;
+    getTasks(): Observable<AsyncTaskStatus[]>;
+    getTask(taskId: string): Observable<AsyncTaskStatus>;
+    cancelTask(taskId: string): Observable<{
+        message: string;
+    }>;
+    private generateSessionId;
+    private isTaskInitiatedByThisTab;
+    /**
+     * Mark a task as initiated by this tab for tracking purposes
+     */
+    monitorTask(taskId: string): void;
+    queueExcelExport(request: MetadataExportRequest): Observable<AsyncTaskCreateResponse>;
+    queueSdrfExport(request: MetadataExportRequest): Observable<AsyncTaskCreateResponse>;
+    queueSdrfImport(request: MetadataImportRequest): Observable<AsyncTaskCreateResponse>;
+    queueExcelImport(request: MetadataImportRequest): Observable<AsyncTaskCreateResponse>;
+    queueBulkSdrfExport(request: BulkExportRequest): Observable<AsyncTaskCreateResponse>;
+    queueBulkExcelExport(request: BulkExcelExportRequest): Observable<AsyncTaskCreateResponse>;
+    downloadTaskResult(taskId: string): void;
+    validateMetadataTable(validationRequest: MetadataValidationRequest): Observable<AsyncTaskCreateResponse>;
+    private handleTaskUpdate;
+    private showTaskProgressNotification;
+    private showTaskCompletionNotification;
+    getTaskDisplayName(taskType: string): string;
+    getTaskStatusClass(status: string): string;
+    formatDuration(duration: number | null): string;
+    canCancelTask(status: string): boolean;
+    canDownloadResult(task: AsyncTaskStatus): boolean;
+    private isImportTask;
+    private isExportTask;
+    private handleExportTaskCompletion;
+    private handleValidationTaskCompletion;
+    private showValidationResultsModal;
+    private handleImportTaskCompletion;
+    private handleReorderTaskCompletion;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncTaskUIService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AsyncTaskUIService>;
+}
+
+declare class MetadataTableTemplates implements OnInit {
+    private fb;
+    private metadataTableTemplateService;
+    private labGroupService;
+    private modalService;
+    private toastService;
+    private asyncTaskService;
+    searchForm: FormGroup;
+    private searchParams;
+    private labGroupParams;
+    isLoading: i0.WritableSignal<boolean>;
+    selectedLabGroup: i0.WritableSignal<LabGroup | null>;
+    currentPage: i0.WritableSignal<number>;
+    pageSize: i0.WritableSignal<number>;
+    totalItems: i0.WritableSignal<number>;
+    labGroupsCurrentPage: i0.WritableSignal<number>;
+    labGroupsPageSize: i0.WritableSignal<number>;
+    labGroupsTotalItems: i0.WritableSignal<number>;
+    templatesData: i0.WritableSignal<MetadataTableTemplateQueryResponse>;
+    labGroupsData: i0.WritableSignal<LabGroupQueryResponse>;
+    hasTemplates: i0.Signal<boolean>;
+    hasLabGroups: i0.Signal<boolean>;
+    showTemplatesPagination: i0.Signal<boolean>;
+    showLabGroupsPagination: i0.Signal<boolean>;
+    availableSchemas: i0.WritableSignal<any[]>;
+    isLoadingSchemas: i0.WritableSignal<boolean>;
+    constructor(fb: FormBuilder, metadataTableTemplateService: MetadataTableTemplateService, labGroupService: LabGroupService, modalService: NgbModal, toastService: ToastService, asyncTaskService: AsyncTaskUIService);
+    ngOnInit(): void;
+    private loadInitialData;
+    private loadLabGroupsWithParams;
+    private setupSearch;
+    private loadTemplatesWithParams;
+    onLabGroupChange(event: Event): void;
+    private findLabGroupById;
+    getLabGroupName(labGroupId: number | undefined): string;
+    onPageChange(page: number): void;
+    onLabGroupsPageChange(page: number): void;
+    createTemplate(): void;
+    editTemplate(template: MetadataTableTemplate): void;
+    deleteTemplate(template: MetadataTableTemplate): void;
+    duplicateTemplate(template: MetadataTableTemplate): void;
+    private openTemplateModal;
+    private handleTemplateSave;
+    private refreshTemplates;
+    private loadAvailableSchemas;
+    createTemplateWithCustomSchemas(): void;
+    private openSchemaSelectionModal;
+    private handleSchemaTemplateCreation;
+    createTableFromTemplate(template: MetadataTableTemplate): void;
+    private openTableCreationModal;
+    private handleTableCreation;
+    /**
+     * Reorder template columns by schema selection
+     */
+    reorderTemplateColumns(template: MetadataTableTemplate): void;
+    /**
+     * Perform the actual template column reordering with async task monitoring
+     */
+    private performTemplateColumnReorder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataTableTemplates, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataTableTemplates, "ccv-metadata-table-templates", never, {}, {}, never, never, true, never>;
+}
+
+declare class MetadataTableTemplateEditModal implements OnInit {
+    private fb;
+    private activeModal;
+    private modalService;
+    private metadataTableTemplateService;
+    private toastService;
+    template: MetadataTableTemplate | null;
+    labGroups: LabGroup[];
+    isEdit: boolean;
+    templateSaved: EventEmitter<Partial<MetadataTableTemplate>>;
+    editForm: FormGroup;
+    isLoading: i0.WritableSignal<boolean>;
+    _templateColumns: i0.WritableSignal<MetadataColumn[]>;
+    templateColumns: i0.Signal<MetadataColumn[]>;
+    visibilityOptions: {
+        value: ResourceVisibility;
+        label: string;
+    }[];
+    constructor(fb: FormBuilder, activeModal: NgbActiveModal, modalService: NgbModal, metadataTableTemplateService: MetadataTableTemplateService, toastService: ToastService);
+    ngOnInit(): void;
+    private populateForm;
+    onSubmit(): void;
+    private markFormGroupTouched;
+    onCancel(): void;
+    onClose(): void;
+    getFieldError(fieldName: string): string;
+    get title(): string;
+    addColumn(): void;
+    addColumnWithAutoReorder(): void;
+    editColumn(column: MetadataColumn): void;
+    duplicateColumn(column: MetadataColumn): void;
+    removeColumn(column: MetadataColumn): void;
+    onColumnDrop(event: CdkDragDrop<MetadataColumn[]>): void;
+    private openColumnModal;
+    private handleColumnSave;
+    private handleColumnSaveWithAutoReorder;
+    private reloadTemplateColumns;
+    private generateTempId;
+    private getNextPositionForSameType;
+    private getNextPositionForNameType;
+    private normalizeColumnPositions;
+    private enforceGrouping;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataTableTemplateEditModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataTableTemplateEditModal, "ccv-metadata-table-template-edit-modal", never, { "template": { "alias": "template"; "required": false; }; "labGroups": { "alias": "labGroups"; "required": false; }; "isEdit": { "alias": "isEdit"; "required": false; }; }, { "templateSaved": "templateSaved"; }, never, never, true, never>;
+}
+
+declare class ColumnEditModal implements OnInit {
+    private fb;
+    private activeModal;
+    private modalService;
+    private metadataColumnTemplateService;
+    private sdrfSyntaxService;
+    column: MetadataColumn | null;
+    templateId: number | null;
+    isEdit: boolean;
+    columnSaved: EventEmitter<Partial<MetadataColumn>>;
+    editForm: FormGroup;
+    isLoading: i0.WritableSignal<boolean>;
+    showAdvancedMode: i0.WritableSignal<boolean>;
+    selectedOntologyConfig: OntologyTypeConfig$1 | null;
+    columnTypes: ColumnTypeConfig$1[];
+    ontologyTypes: OntologyTypeConfig$1[];
+    templateFilter: string;
+    selectedTemplateId: number | string;
+    selectedTemplate: MetadataColumnTemplate$1 | null;
+    templates: MetadataColumnTemplate$1[];
+    isLoadingTemplates: boolean;
+    currentTemplatePage: number;
+    templatePageSize: number;
+    totalTemplates: number;
+    totalTemplatePages: number;
+    Math: Math;
+    officialSdrfColumns: SdrfColumnConfig$1[];
+    showOfficialColumns: boolean;
+    selectedOfficialColumn: SdrfColumnConfig$1 | null;
+    availableOfficialColumns: SdrfColumnConfig$1[];
+    showTemplateSwap: boolean;
+    showCreateCustomTemplate: boolean;
+    constructor(fb: FormBuilder, activeModal: NgbActiveModal, modalService: NgbModal, metadataColumnTemplateService: MetadataColumnTemplateService$1, sdrfSyntaxService: SdrfSyntaxService$1);
+    ngOnInit(): void;
+    private populateForm;
+    onSubmit(): void;
+    private markFormGroupTouched;
+    onCancel(): void;
+    onClose(): void;
+    getFieldError(fieldName: string): string;
+    get title(): string;
+    get hasOntologyType(): boolean;
+    get hasTypeaheadEnabled(): boolean;
+    openValueEditModal(): void;
+    private loadColumnTemplates;
+    onTemplateFilterChange(): void;
+    clearTemplateFilter(): void;
+    onTemplatePageChange(page: number): void;
+    onTemplateSelectionChange(): void;
+    clearTemplate(): void;
+    getOntologyTypeLabel(ontologyType: string): string;
+    toggleOfficialColumns(): void;
+    selectOfficialColumn(column: SdrfColumnConfig$1): void;
+    private filterOfficialColumns;
+    private getDefaultOntologyTypeForColumn;
+    private shouldEnableTypeaheadForColumn;
+    private isColumnMandatory;
+    showTemplateSwapOptions(): void;
+    swapToTemplate(template: MetadataColumnTemplate$1): void;
+    showCreateCustomTemplateOption(): void;
+    createCustomTemplate(): void;
+    cancelTemplateSwap(): void;
+    toggleAdvancedMode(): void;
+    onOntologyTypeChange(event: Event): void;
+    private getCorrectedColumnType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnEditModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnEditModal, "ccv-column-edit-modal", never, { "column": { "alias": "column"; "required": false; }; "templateId": { "alias": "templateId"; "required": false; }; "isEdit": { "alias": "isEdit"; "required": false; }; }, { "columnSaved": "columnSaved"; }, never, never, true, never>;
+}
+
+interface TemplateSchemaSelectionResult {
+    name: string;
+    description: string;
+    schemaIds: number[];
+    labGroupId?: number;
+    visibility: ResourceVisibility;
+    isDefault: boolean;
+}
+declare class TemplateSchemaSelectionModal {
+    private fb;
+    activeModal: NgbActiveModal;
+    availableSchemas: any[];
+    labGroups: any[];
+    templateCreated: EventEmitter<TemplateSchemaSelectionResult>;
+    templateForm: FormGroup;
+    selectedSchemas: i0.WritableSignal<Set<number>>;
+    selectedSchemasCount: i0.Signal<number>;
+    constructor(fb: FormBuilder, activeModal: NgbActiveModal);
+    toggleSchema(schemaId: number): void;
+    onSchemaCheckChange(event: Event, schemaId: number): void;
+    isSchemaSelected(schemaId: number): boolean;
+    getSelectedSchemas(): number[];
+    removeSchema(schemaId: number): void;
+    getSchemaDisplayName(schemaId: number): string;
+    private updateDescription;
+    canCreateTemplate(): boolean;
+    onCreateTemplate(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateSchemaSelectionModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TemplateSchemaSelectionModal, "ccv-template-schema-selection-modal", never, { "availableSchemas": { "alias": "availableSchemas"; "required": false; }; "labGroups": { "alias": "labGroups"; "required": false; }; }, { "templateCreated": "templateCreated"; }, never, never, true, never>;
+}
+
+interface TableCreationData {
+    name: string;
+    templateId: number;
+    sampleCount?: number;
+    description?: string;
+    labGroupId?: number;
+}
+declare class TableCreationModalComponent implements OnInit {
+    private fb;
+    activeModal: NgbActiveModal;
+    template: MetadataTableTemplate;
+    labGroups: LabGroup[];
+    selectedLabGroupId?: number;
+    tableCreated: EventEmitter<TableCreationData>;
+    tableForm: FormGroup;
+    isCreating: boolean;
+    errorMessage: string | null;
+    constructor(fb: FormBuilder, activeModal: NgbActiveModal);
+    ngOnInit(): void;
+    onSubmit(): void;
+    onClose(): void;
+    setCreatingState(isCreating: boolean): void;
+    setErrorMessage(message: string | null): void;
+    getFieldError(fieldName: string): string | null;
+    private getFieldLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCreationModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableCreationModalComponent, "ccv-table-creation-modal", never, { "template": { "alias": "template"; "required": false; }; "labGroups": { "alias": "labGroups"; "required": false; }; "selectedLabGroupId": { "alias": "selectedLabGroupId"; "required": false; }; }, { "tableCreated": "tableCreated"; }, never, never, true, never>;
+}
+
+interface SchemaSelectionResult {
+    selectedSchemaIds: number[];
+}
+declare class SchemaSelectionModal implements OnInit, OnDestroy {
+    activeModal: NgbActiveModal;
+    private schemaService;
+    private toastService;
+    private destroy$;
+    title: string;
+    description: string;
+    isLoading: i0.WritableSignal<boolean>;
+    availableSchemas: i0.WritableSignal<Schema[]>;
+    selectedSchemaIds: i0.WritableSignal<Set<number>>;
+    searchTerm: i0.WritableSignal<string>;
+    constructor(activeModal: NgbActiveModal, schemaService: SchemaService, toastService: ToastService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private loadAvailableSchemas;
+    get filteredSchemas(): Schema[];
+    toggleSchemaSelection(schemaId: number): void;
+    isSchemaSelected(schemaId: number): boolean;
+    selectAll(): void;
+    clearSelection(): void;
+    onCancel(): void;
+    onConfirm(): void;
+    getBadgeClass(category?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaSelectionModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SchemaSelectionModal, "ccv-schema-selection-modal", never, {}, {}, never, never, true, never>;
+}
+
 declare class CupcakeVanilla {
     static ɵfac: i0.ɵɵFactoryDeclaration<CupcakeVanilla, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CupcakeVanilla, "ccv-cupcake-vanilla", never, {}, {}, never, never, true, never>;
 }
 
-export { AsyncExportService, AsyncImportService, AsyncTaskService, AsyncValidationService, ChunkedUploadService, CupcakeVanilla, FavouriteMetadataOptionService, MetadataColumnService, MetadataColumnTemplateService, MetadataColumnTemplateShareService, MetadataManagementService, MetadataTableService, MetadataTableTemplateService, OntologySearchService, OntologyType, OntologyTypeLabels, OntologyUtils, SDRFDefaultsService, SamplePoolService, SchemaService, TASK_STATUS_COLORS, TASK_STATUS_LABELS, TASK_TYPE_LABELS, TemplatePermissionLabels, TemplatePermissionLevel, isUnimodFullData };
-export type { ApiResponse, AsyncTaskCreateResponse, AsyncTaskQueryParams, AsyncTaskStatus, BaseTimestampedModel, BulkExcelExportRequest, BulkExportRequest, CellOntology, ChEBICompound, ChunkedUploadCompletionRequest, ChunkedUploadCompletionResponse, ChunkedUploadRequest, ChunkedUploadResponse, ChunkedUploadStatus, DownloadUrlResponse, FavouriteMetadataOption, FavouriteMetadataOptionCreateRequest, FavouriteMetadataOptionQueryParams, FavouriteMetadataOptionUpdateRequest, HumanDisease, MSUniqueVocabularies, MetadataColumn, MetadataColumnCreateRequest, MetadataColumnModifier, MetadataColumnQueryParams, MetadataColumnTemplate, MetadataColumnTemplateCreateRequest, MetadataColumnTemplateQueryParams, MetadataColumnTemplateShare, MetadataColumnTemplateShareCreateRequest, MetadataColumnTemplateShareQueryParams, MetadataColumnTemplateUpdateRequest, MetadataColumnUpdateRequest, MetadataExportRequest, MetadataImportRequest, MetadataQueryParams, MetadataTable, MetadataTableCreateRequest, MetadataTableQueryParams, MetadataTableQueryResponse, MetadataTableTemplate, MetadataTableTemplateCreateRequest, MetadataTableTemplateQueryParams, MetadataTableTemplateQueryResponse, MetadataTableTemplateUpdateRequest, MetadataTableUpdateRequest, MetadataValidationConfig, MetadataValidationRequest, MondoDisease, NCBITaxonomy, OntologySuggestion, OntologySuggestionResponse, PSIMSOntology, PaginatedResponse, SamplePool, SamplePoolCreateRequest, SamplePoolQueryParams, SamplePoolUpdateRequest, Schema, SchemaQueryParams, Species, SubcellularLocation, TaskListItem, TaskResult, TaskStatus, TaskType, Tissue, UberonAnatomy, Unimod, UnimodFullData, UnimodSpecification };
+export { AdminWebSocketService, AsyncExportService, AsyncImportService, AsyncTaskService, AsyncTaskUIService, AsyncValidationService, COLUMN_TYPE_CONFIGS, ChunkedImportService, ChunkedUploadService, ColumnEditModal, ColumnType, CupcakeVanilla, ElectronService, ExcelExportModalComponent, FavouriteMetadataOptionService, MSTermType, MetadataColumnService, MetadataColumnTemplateService, MetadataColumnTemplateShareService, MetadataManagementService, MetadataTableEditModal, MetadataTableService, MetadataTableTemplateEditModal, MetadataTableTemplateService, MetadataTableTemplates, MetadataValidationModal, MetadataValueEditModal, NotificationService, NotificationType, OFFICIAL_SDRF_COLUMNS, ONTOLOGY_TYPE_CONFIGS, OntologySearchService, OntologyType, OntologyTypeLabels, OntologyUtils, SDRFDefaultsService, SamplePoolService, SchemaSelectionModal, SchemaService, SdrfAgeInput, SdrfCleavageInput, SdrfColumnCategory, SdrfModificationInput, SdrfSpikedCompoundInput, SdrfSyntaxService, TASK_STATUS_COLORS, TASK_STATUS_LABELS, TASK_TYPE_LABELS, TableCreationModalComponent, TemplatePermissionLabels, TemplatePermissionLevel, TemplateSchemaSelectionModal, ValidationResultsModal, Websocket, getRequiredSdrfColumns, getSdrfColumnByName, getSdrfColumnsByCategory, isSdrfColumnRequired, isUnimodFullData };
+export type { AgeFormat, ApiResponse, AsyncTaskCreateResponse, AsyncTaskQueryParams, AsyncTaskStatus, BaseTimestampedModel, BulkExcelExportRequest, BulkExportRequest, CellOntology, ChEBICompound, ChunkedFileImportRequest, ChunkedImportProgress, ChunkedImportRequest, ChunkedUploadCompletionRequest, ChunkedUploadCompletionResponse, ChunkedUploadRequest, ChunkedUploadResponse, ChunkedUploadStatus, CleavageAgentDetails, ColumnTypeConfig, DownloadUrlResponse, ElectronAPI, ExcelExportOptions, FavouriteMetadataOption, FavouriteMetadataOptionCreateRequest, FavouriteMetadataOptionQueryParams, FavouriteMetadataOptionUpdateRequest, HumanDisease, MSUniqueVocabularies, MetadataColumn, MetadataColumnCreateRequest, MetadataColumnModifier, MetadataColumnQueryParams, MetadataColumnTemplate, MetadataColumnTemplateCreateRequest, MetadataColumnTemplateQueryParams, MetadataColumnTemplateShare, MetadataColumnTemplateShareCreateRequest, MetadataColumnTemplateShareQueryParams, MetadataColumnTemplateUpdateRequest, MetadataColumnUpdateRequest, MetadataExportRequest, MetadataImportRequest, MetadataQueryParams, MetadataTable, MetadataTableCreateRequest, MetadataTableQueryParams, MetadataTableQueryResponse, MetadataTableTemplate, MetadataTableTemplateCreateRequest, MetadataTableTemplateQueryParams, MetadataTableTemplateQueryResponse, MetadataTableTemplateUpdateRequest, MetadataTableUpdateRequest, MetadataValidationConfig, MetadataValidationRequest, MetadataValueEditConfig, ModificationParameters, MondoDisease, NCBITaxonomy, OntologyCustomFilter, OntologySuggestion, OntologySuggestionResponse, OntologyTypeConfig, PSIMSOntology, PaginatedResponse, PooledSample, SampleCountConfirmationError, SampleCountValidationRequest, SampleCountValidationResponse, SampleCountValidationResult, SamplePool, SamplePoolCreateRequest, SamplePoolQueryParams, SamplePoolUpdateRequest, Schema, SchemaQueryParams, SchemaSelectionResult, SdrfColumnConfig, Species, SpikedCompound, SubcellularLocation, SyntaxType, SyntheticPeptide, TableCreationData, TaskListItem, TaskResult, TaskStatus, TaskType, TemplateSchemaSelectionResult, Tissue, UberonAnatomy, Unimod, UnimodFullData, UnimodSpecification, ValidationResult, ValidationResults };