c3-components 0.14.1 → 0.14.2

package/index.d.ts

@@ -1,5 +1,864 @@
+import { HttpHeaders, HttpContext, HttpParams, HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { TemplateRef, OnDestroy, ElementRef, ViewContainerRef, AfterViewInit, Signal, ComponentRef, ChangeDetectorRef, OnInit, SimpleChanges, PipeTransform, InjectionToken } from '@angular/core';
+import * as i4 from '@angular/cdk/overlay';
+import { Overlay } from '@angular/cdk/overlay';
+import * as i3 from '@angular/common';
+import * as i10 from '@angular/material/dialog';
+import { MatDialogRef, MatDialogContainer, MatDialogState, MatDialogConfig, MatDialog } from '@angular/material/dialog';
+import * as i8 from '@angular/forms';
+import { ValidatorFn, FormControl, FormBuilder } from '@angular/forms';
+import { ComponentType } from '@angular/cdk/portal';
+import { Observable, BehaviorSubject } from 'rxjs';
+import * as i5 from '@angular/material/button';
+import * as i11 from '@angular/material/form-field';
+import * as i12 from '@angular/material/icon';
+import * as i13 from '@angular/material/input';
+import * as i14 from '@angular/material/toolbar';
+import * as c3_components from 'c3-components';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer } from '@angular/platform-browser';
+import { AutoAnimationPlugin, AutoAnimateOptions } from '@formkit/auto-animate';
+import * as i7 from '@angular/material/tooltip';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { MatTreeFlattener, MatTreeFlatDataSource } from '@angular/material/tree';
+import * as i4$1 from '@angular/router';
+import * as i5$1 from '@angular/material/core';
+
+interface HttpClientOptions {
+    headers?: HttpHeaders | {
+        [header: string]: string | string[];
+    };
+    context?: HttpContext;
+    observe?: 'body';
+    params?: HttpParams | {
+        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+    };
+    reportProgress?: boolean;
+    responseType: 'blob';
+    withCredentials?: boolean;
+}
+
+declare class C3DropdownComponent {
+    readonly panelClass: i0.InputSignal<string | string[] | Set<string> | {
+        [key: string]: any;
+    } | undefined>;
+    readonly isOpen: i0.WritableSignal<boolean>;
+    readonly template: i0.Signal<TemplateRef<any>>;
+    private readonly _changeDetectorRef;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3DropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3DropdownComponent, "c3-dropdown", never, { "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}
+
+declare const MAT_DROPDOWN_VALUE_ACCESSOR: any;
 /**
- * Generated bundle index. Do not edit.
+ * @description The C3DropdownTrigger directive is used to display or hide a dropdown menu
+ * C3DropdownComponent when an item is clicked.
+ * @selector [c3Dropdown]
+ * @exportAs c3DropdownTrigger
+ * @input c3Dropdown - A reference to an instance of C3DropdownComponent.
+ * @input c3DropdownDisabled - A boolean indicating whether the directive should be disabled.
+ * @input c3DropdownClass - A string, an array of strings, a set of strings or a
+ * object representing the CSS classes to be applied to the dropdown menu.
  */
-/// <amd-module name="c3-components" />
-export * from './public-api';
+declare class C3DropdownTrigger implements OnDestroy {
+    private _element;
+    private _overlay;
+    private _viewContainerRef;
+    private overlayRef?;
+    private _closingActionsSubscription;
+    private _destroyed;
+    /** The dropdown menu instance */
+    readonly dropdown: i0.ModelSignal<C3DropdownComponent>;
+    /** Whether the dropdown is disabled. */
+    readonly dropdownDisabled: i0.InputSignal<boolean>;
+    /** Classes to be passed to the dropdown menu. Supports the same syntax as `ngClass`. */
+    readonly dropdownClass: i0.InputSignal<string | string[] | Set<string> | {
+        [key: string]: any;
+    }>;
+    constructor(_element: ElementRef<HTMLElement>, _overlay: Overlay, _viewContainerRef: ViewContainerRef);
+    onClick(): void;
+    ngOnDestroy(): void;
+    show(): void;
+    close(): void;
+    private _getOverlayConfig;
+    /** Returns a stream that emits whenever an action that should close the menu occurs. */
+    private _menuClosingActions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3DropdownTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3DropdownTrigger, "[c3DropdownTrigger]", never, { "dropdown": { "alias": "c3DropdownTrigger"; "required": true; "isSignal": true; }; "dropdownDisabled": { "alias": "dropdownDisabled"; "required": false; "isSignal": true; }; "dropdownClass": { "alias": "dropdownClass"; "required": false; "isSignal": true; }; }, { "dropdown": "c3DropdownTriggerChange"; }, never, never, false, never>;
+}
+
+declare class C3DropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3DropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<C3DropdownModule, [typeof C3DropdownComponent, typeof C3DropdownTrigger], [typeof i3.CommonModule, typeof i4.OverlayModule], [typeof C3DropdownComponent, typeof C3DropdownTrigger]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<C3DropdownModule>;
+}
+
+interface AlertConfig {
+    text: string;
+    width?: string;
+    acceptText?: string;
+}
+declare class C3AlertDialogComponent {
+    dialogRef: MatDialogRef<C3AlertDialogComponent>;
+    data: AlertConfig;
+    constructor(dialogRef: MatDialogRef<C3AlertDialogComponent>, data: AlertConfig);
+    onNoClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3AlertDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3AlertDialogComponent, "AlertDialogComponent", never, {}, {}, never, never, false, never>;
+}
+
+interface ConfirmConfig {
+    text: string;
+    placeholder?: string;
+    reject?: {
+        color?: string;
+        text?: string;
+    };
+    accept?: {
+        color?: string;
+        text: string;
+    };
+    width?: string;
+}
+declare class ConfirmDialogComponent {
+    dialogRef: MatDialogRef<ConfirmDialogComponent>;
+    data: ConfirmConfig;
+    constructor(dialogRef: MatDialogRef<ConfirmDialogComponent>, data: ConfirmConfig);
+    onNoClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialogComponent, "ConfirmDialogComponent", never, {}, {}, never, never, false, never>;
+}
+
+interface PromptConfig {
+    text: string;
+    defaultValue?: string;
+    placeholder?: string;
+    multiline?: boolean;
+    validators?: ValidatorFn | ValidatorFn[];
+    required?: boolean;
+    reject?: {
+        color: string;
+        text: string;
+    };
+    accept?: {
+        color: string;
+        text: string;
+    };
+    width?: string;
+    maxWidth?: string;
+}
+declare class C3PromptDialogComponent {
+    dialogRef: MatDialogRef<C3PromptDialogComponent>;
+    data: PromptConfig;
+    private _fb;
+    result: FormControl;
+    constructor(dialogRef: MatDialogRef<C3PromptDialogComponent>, data: PromptConfig, _fb: FormBuilder);
+    onNoClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3PromptDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3PromptDialogComponent, "PrompDialogComponent", never, {}, {}, never, never, false, never>;
+}
+
+declare class C3DialogEmbedChildComponent<C> implements AfterViewInit {
+    dialogRef: MatDialogRef<C3DialogEmbedChildComponent<C>>;
+    data: {
+        component?: ComponentType<C>;
+        templateRef?: TemplateRef<any>;
+        inputs?: Partial<Record<keyof C, unknown>>;
+        classActions?: string;
+        classContainer?: string;
+        classContent?: string;
+        toolbar?: {
+            title: string;
+            closeBtn?: boolean;
+            closeColor?: string;
+            color?: string;
+        };
+        actions?: {
+            label: string;
+            apperance?: 'basic' | 'raised' | 'stroked' | 'flat';
+            class?: string;
+            action: () => void;
+        }[];
+    };
+    private _cdr;
+    readonly target: Signal<ViewContainerRef>;
+    createdComponent: i0.WritableSignal<ComponentRef<C> | null>;
+    constructor(dialogRef: MatDialogRef<C3DialogEmbedChildComponent<C>>, data: {
+        component?: ComponentType<C>;
+        templateRef?: TemplateRef<any>;
+        inputs?: Partial<Record<keyof C, unknown>>;
+        classActions?: string;
+        classContainer?: string;
+        classContent?: string;
+        toolbar?: {
+            title: string;
+            closeBtn?: boolean;
+            closeColor?: string;
+            color?: string;
+        };
+        actions?: {
+            label: string;
+            apperance?: 'basic' | 'raised' | 'stroked' | 'flat';
+            class?: string;
+            action: () => void;
+        }[];
+    }, _cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    /**
+     * Retourne la référence du composant créé (s’il y en a un),
+     * utile pour le service ou l’appelant.
+     */
+    createdComponentInstance(): ComponentRef<C> | null;
+    private _getInputProperties;
+    private _setInputs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3DialogEmbedChildComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3DialogEmbedChildComponent<any>, "C3DialogEmbedChildComponent", never, {}, {}, never, never, false, never>;
+}
+
+type C3CreateDialogFromComponentConfig<C> = MatDialogConfig<Partial<Record<keyof C, unknown>>> & {
+    component: ComponentType<C>;
+    toolbar?: {
+        title: string;
+        closeBtn?: boolean;
+        closeColor?: string;
+        color?: string;
+    };
+    classActions?: string;
+    classContainer?: string;
+    classContent?: string;
+    actions?: {
+        label: string;
+        class?: string;
+        apperance?: 'basic' | 'raised' | 'stroked' | 'flat';
+        action: () => void;
+    }[];
+};
+type C3CreateDialogFromComponentResult<C> = {
+    _containerInstance: MatDialogContainer;
+    rootComponentRef: ComponentRef<C3DialogEmbedChildComponent<C>> | null;
+    rootComponentInstance: C3DialogEmbedChildComponent<C>;
+    componentRef: ComponentRef<C> | null;
+    componentInstance: C | undefined;
+    id: string;
+    disableClose: boolean;
+    close: (dialogResult?: C) => void;
+    afterClosed: () => Observable<C | null>;
+    afterOpened: () => Observable<void>;
+    beforeClosed: () => Observable<C | null>;
+    backdropClick: () => Observable<MouseEvent>;
+    getState: () => MatDialogState;
+    keydownEvents: () => Observable<KeyboardEvent>;
+    updateSize: () => void;
+    updatePosition: () => void;
+    addPanelClass: (className: string) => void;
+    removePanelClass: (className: string) => void;
+    afterComponentMounted: () => Observable<C3CreateDialogFromComponentResult<C>>;
+};
+declare class C3DialogService {
+    #private;
+    private readonly _injector;
+    /**
+     * Opens a confirm dialog and returns a promise that resolves to a boolean indicating whether the user accepted or rejected the confirmation.
+     *
+     * @param {ConfirmConfig} data Configuration options for the confirm dialog. See ConfirmConfig below.
+     * @returns {C3ExtendedPromise<boolean>} A promise that resolves to `true` if the user accepted the confirmation, and `false` otherwise.
+     */
+    confirm(data: ConfirmConfig): Promise<boolean>;
+    /**
+     * Opens a prompt dialog and returns a promise that resolves to the value entered by the user, or `false` if the user cancelled the prompt.
+     *
+     * @param {PromptConfig} data Configuration options for the prompt dialog. See PromptConfig below.
+     * @returns {C3ExtendedPromise<false | T>} A promise that resolves to the value entered by the user, or `false` if the user cancelled the prompt.
+     */
+    prompt(data: PromptConfig): Promise<false | string>;
+    /**
+     * Opens a dialog with the provided component and inputs.
+     * @param {C3CreateDialogFromComponentConfig<C>} config Configuration options for the dialog. See MatDialogConfig below.
+     * @returns {MatDialogRef<C> & {component: ComponentRef<C> | undefined}} The dialog reference.
+     */
+    createDialogFromComponent<C>({ component, toolbar, data, classContainer, classContent, classActions, actions, ...config }: C3CreateDialogFromComponentConfig<C>): C3CreateDialogFromComponentResult<C>;
+    /**
+       * Ouvre un dialog à partir d'un TemplateRef.
+       * @param templateRef Le TemplateRef à afficher dans la boîte de dialogue.
+       * @param config (optionnel) Configuration pour le MatDialog (dimensions, position, etc.).
+       */
+    createDialogFromTemplate(templateRef: TemplateRef<any>, config?: MatDialogConfig): C3CreateDialogFromComponentResult<unknown>;
+    alert(text: string, data?: AlertConfig): Observable<any>;
+    private createC3DialogResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<C3DialogService>;
+}
+
+declare class C3DialogTemplateComponent {
+    readonly templateRef: i0.Signal<TemplateRef<any> | undefined>;
+    readonly dialogRef: i0.WritableSignal<C3CreateDialogFromComponentResult<unknown> | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3DialogTemplateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3DialogTemplateComponent, "c3-dialog-template", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class C3OpenDialogDirective {
+    readonly template: i0.InputSignal<C3DialogTemplateComponent | undefined>;
+    readonly config: i0.InputSignal<MatDialogConfig<any> | undefined>;
+    private readonly _dialog;
+    private openDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3OpenDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3OpenDialogDirective, "[c3-dialog]", never, { "template": { "alias": "c3-dialog"; "required": false; "isSignal": true; }; "config": { "alias": "c3-dialog-config"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class C3DialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3DialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<C3DialogModule, [typeof C3AlertDialogComponent, typeof ConfirmDialogComponent, typeof C3PromptDialogComponent, typeof C3DialogEmbedChildComponent, typeof C3DialogTemplateComponent, typeof C3OpenDialogDirective], [typeof i3.CommonModule, typeof i8.FormsModule, typeof i5.MatButtonModule, typeof i10.MatDialogModule, typeof i11.MatFormFieldModule, typeof i12.MatIconModule, typeof i13.MatInputModule, typeof i14.MatToolbarModule, typeof i8.ReactiveFormsModule], [typeof C3DialogTemplateComponent, typeof C3OpenDialogDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<C3DialogModule>;
+}
+
+interface C3FileViewerConfig {
+    btnContainerClass?: string;
+    btnClass?: string;
+    btnSubClass?: string;
+    zoomFactor?: number;
+    containerBackgroundColor?: string;
+    wheelZoom?: boolean;
+    allowFullscreen?: boolean;
+    allowKeyboardNavigation?: boolean;
+    customClient?: HttpClient['get'];
+    minHeight?: number | string;
+    minWidth?: number | string;
+    width?: number | string;
+    maxHeight?: number | string;
+    height?: number | string;
+    maxWidth?: number | string;
+    btnShow?: {
+        zoomIn?: boolean;
+        zoomOut?: boolean;
+        rotateClockwise?: boolean;
+        rotateCounterClockwise?: boolean;
+        next?: boolean;
+        prev?: boolean;
+        reset?: boolean;
+        download?: boolean;
+    };
+    btnIcons?: {
+        zoomIn?: MultiBtn['btn'];
+        zoomOut?: MultiBtn['btn'];
+        rotateClockwise?: MultiBtn['btn'];
+        rotateCounterClockwise?: MultiBtn['btn'];
+        next?: MultiBtn['btn'];
+        prev?: MultiBtn['btn'];
+        fullscreen?: MultiBtn['btn'];
+        reset?: MultiBtn['btn'];
+        download?: MultiBtn['btn'];
+    };
+    customBtns?: Array<{
+        name: string;
+        icon: MultiBtn['btn'];
+    }>;
+}
+interface MultiBtn {
+    btn: {
+        classes?: string;
+        text?: string;
+    };
+}
+
+declare class CustomFileEvent {
+    name: string;
+    fileUrl: string;
+    constructor(name: string, fileUrl: string);
+}
+
+type VariantFile = {
+    size: number;
+    fileName: string;
+    contentType: string;
+    location: string;
+};
+interface FileMetadata {
+    name: string;
+    size?: number;
+    type: string;
+    lastModified?: Date;
+    created?: Date;
+    extension?: string;
+    location: string;
+    objectUrl?: Observable<string>;
+    metadata?: Record<string, any>;
+    alternativeVersions?: VariantFile[];
+}
+
+declare class C3FileViewer {
+    private _config;
+    private client;
+    get config(): C3FileViewerConfig;
+    set config(value: C3FileViewerConfig);
+    config$: BehaviorSubject<C3FileViewerConfig>;
+    fullscreen$: BehaviorSubject<Boolean>;
+    customFile$: BehaviorSubject<any>;
+    index$: BehaviorSubject<number>;
+    loading: boolean;
+    currentIndex: number;
+    get currentFile(): FileMetadata;
+    style: {
+        transform: string;
+        msTransform: string;
+        oTransform: string;
+        webkitTransform: string;
+        minHeight: string;
+        maxHeight: string;
+        height: string;
+        minWidth: string;
+        maxWidth: string;
+        width: string;
+    };
+    styleHeight: string;
+    hovered: boolean;
+    set files(newFiles: FileMetadata[]);
+    get files(): FileMetadata[];
+    private _files;
+    filesObjectUrl: Array<FileMetadata & {
+        objectUrl?: Observable<string>;
+    }>;
+    private locationBlobMap;
+    private scale;
+    private rotation;
+    private translateX;
+    private translateY;
+    private prevX;
+    private prevY;
+    constructor({ config, files, client }: {
+        config?: C3FileViewerConfig;
+        files?: FileMetadata[];
+        client: HttpClient;
+    });
+    createObjectURL(file: FileMetadata | VariantFile): Observable<string> | undefined;
+    getFile(location: string): Observable<Blob>;
+    previousImage(event: KeyboardEvent | MouseEvent): void;
+    nextImage(event: KeyboardEvent | MouseEvent): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    scrollZoom(evt: WheelEvent): boolean;
+    rotateClockwise(): void;
+    rotateCounterClockwise(): void;
+    onLoaded(): void;
+    onLoadStart(): void;
+    imageNotFound(file: FileMetadata): void;
+    onDragOver(evt: DragEvent): void;
+    onDragStart(evt: DragEvent): void;
+    toggleFullscreen(): void;
+    reset(): void;
+    getOriginalName(file?: FileMetadata): any;
+    private canNavigate;
+    private updateStyle;
+    private valueToCss;
+    private mergeConfig;
+    download(file?: FileMetadata): void;
+    private downloadFromUrl;
+    private downloadWithClient;
+}
+
+declare class C3FileViewerComponent implements OnInit {
+    moduleConfig: C3FileViewerConfig;
+    _http: HttpClient;
+    readonly screenHeightOccupied: i0.InputSignal<number | undefined>;
+    readonly fileViewer: i0.InputSignal<C3FileViewer>;
+    readonly indexChange: i0.OutputEmitterRef<number>;
+    readonly configChange: i0.OutputEmitterRef<C3FileViewerConfig>;
+    readonly customFileEvent: i0.OutputEmitterRef<CustomFileEvent>;
+    constructor(moduleConfig: C3FileViewerConfig, _http: HttpClient);
+    ngOnInit(): void;
+    onMouseOver(): void;
+    onMouseLeave(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    next(event: KeyboardEvent): void;
+    previous(event: KeyboardEvent): void;
+    defineStyleHeight(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileViewerComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileViewerComponent, "c3-file-viewer", never, { "screenHeightOccupied": { "alias": "screenHeightOccupied"; "required": false; "isSignal": true; }; "fileViewer": { "alias": "fileViewer"; "required": true; "isSignal": true; }; }, { "indexChange": "indexChange"; "configChange": "configChange"; "customFileEvent": "customFileEvent"; }, never, never, false, never>;
+}
+
+declare class C3FileViewerDialogComponent {
+    private _dialog;
+    readonly fileViewer: i0.InputSignal<C3FileViewer>;
+    readonly dialogConfig: i0.InputSignal<Partial<MatDialogConfig<any>>>;
+    constructor(_dialog: MatDialog);
+    openDialog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileViewerDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileViewerDialogComponent, "c3-file-viewer-dialog", never, { "fileViewer": { "alias": "fileViewer"; "required": true; "isSignal": true; }; "dialogConfig": { "alias": "dialogConfig"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class C3FileViewerDialog {
+    fileViewer: C3FileViewer;
+    constructor(fileViewer: C3FileViewer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileViewerDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileViewerDialog, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class FullScreenDirective {
+    private el;
+    readonly fullscreenState: i0.InputSignal<Boolean | null>;
+    readonly fullscreenStateSetter: i0.InputSignal<Boolean | null>;
+    private _fullscreenState;
+    constructor(el: ElementRef);
+    private defineState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullScreenDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FullScreenDirective, "[C3FullScreen], [c3-full-screen]", never, { "fullscreenState": { "alias": "c3Screenfull"; "required": false; "isSignal": true; }; "fullscreenStateSetter": { "alias": "c3-full-screen"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class C3FileViewerActionsComponent {
+    readonly fileViewer: i0.InputSignal<C3FileViewer>;
+    get config(): c3_components.C3FileViewerConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileViewerActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileViewerActionsComponent, "c3-file-viewer-actions", never, { "fileViewer": { "alias": "fileViewer"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class C3FileViewerImageComponent {
+    readonly fileViewer: i0.InputSignal<C3FileViewer>;
+    readonly dragstart: i0.OutputEmitterRef<DragEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileViewerImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileViewerImageComponent, "c3-file-viewer-image, [c3-file-viewer-image]", never, { "fileViewer": { "alias": "fileViewer"; "required": true; "isSignal": true; }; }, { "dragstart": "dragstart"; }, never, never, false, never>;
+}
+
+declare class C3FileViewerPdfComponent {
+    readonly fileViewer: i0.InputSignal<C3FileViewer>;
+    readonly dragstart: i0.OutputEmitterRef<DragEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileViewerPdfComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileViewerPdfComponent, "c3-file-viewer-pdf", never, { "fileViewer": { "alias": "fileViewer"; "required": true; "isSignal": true; }; }, { "dragstart": "dragstart"; }, never, never, false, never>;
+}
+
+declare class C3FileViewerVideoComponent {
+    readonly fileViewer: i0.InputSignal<C3FileViewer>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileViewerVideoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileViewerVideoComponent, "c3-file-viewer-video", never, { "fileViewer": { "alias": "fileViewer"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class C3FileViewerDefaultComponent {
+    readonly fileViewer: i0.InputSignal<C3FileViewer>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileViewerDefaultComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileViewerDefaultComponent, "c3-file-viewer-default", never, { "fileViewer": { "alias": "fileViewer"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class C3SafeUrlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(url: string | null): _angular_platform_browser.SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3SafeUrlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<C3SafeUrlPipe, "c3SafeUrl", true>;
+}
+
+declare class C3FileViewerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileViewerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<C3FileViewerModule, [typeof FullScreenDirective, typeof C3FileViewerComponent, typeof C3FileViewerActionsComponent, typeof C3FileViewerImageComponent, typeof C3FileViewerPdfComponent, typeof C3FileViewerVideoComponent, typeof C3FileViewerDialogComponent, typeof C3FileViewerDialog, typeof C3FileViewerDefaultComponent], [typeof i3.CommonModule, typeof C3SafeUrlPipe, typeof i10.MatDialogModule, typeof i12.MatIconModule, typeof i5.MatButtonModule], [typeof FullScreenDirective, typeof C3FileViewerComponent, typeof C3FileViewerDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<C3FileViewerModule>;
+}
+
+type C3FileCardSize = '16' | '32' | '64' | '128' | '256';
+declare class C3FileDisplayCardComponent {
+    readonly fileObjectUrl: i0.InputSignal<(FileMetadata & {
+        objectUrl?: Observable<string>;
+    }) | null>;
+    readonly displayFn: i0.InputSignal<(file: FileMetadata) => string>;
+    readonly deletable: i0.InputSignal<boolean>;
+    readonly size: i0.InputSignal<C3FileCardSize>;
+    readonly onDelete: i0.OutputEmitterRef<void>;
+    readonly onDownload: i0.OutputEmitterRef<void>;
+    readonly getFileType: i0.Signal<"image" | "application" | "video" | "unknown">;
+    readonly getFileObjectUrl: i0.Signal<Observable<string> | null>;
+    readonly getFileName: i0.Signal<string>;
+    readonly getDisplayName: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileDisplayCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileDisplayCardComponent, "c3-file-display-card", never, { "fileObjectUrl": { "alias": "fileObjectUrl"; "required": true; "isSignal": true; }; "displayFn": { "alias": "displayFn"; "required": false; "isSignal": true; }; "deletable": { "alias": "deletable"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "onDelete": "onDelete"; "onDownload": "onDownload"; }, never, never, true, never>;
+}
+
+declare class C3FileDisplayGridComponent {
+    readonly files: i0.InputSignal<(FileMetadata & {
+        location: string;
+    })[]>;
+    readonly config: i0.InputSignal<C3FileViewerConfig | undefined>;
+    readonly cardSize: i0.InputSignal<C3FileCardSize>;
+    readonly displayFn: i0.InputSignal<(file: FileMetadata & {
+        location: string;
+    }) => string>;
+    readonly deletable: i0.InputSignal<boolean>;
+    readonly onDelete: i0.OutputEmitterRef<FileMetadata>;
+    readonly dialog: i0.Signal<C3FileViewerDialogComponent | undefined>;
+    fileViewer: C3FileViewer;
+    constructor();
+    openDialog($event: MouseEvent, index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileDisplayGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileDisplayGridComponent, "c3-file-display-grid", never, { "files": { "alias": "files"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "cardSize": { "alias": "cardSize"; "required": false; "isSignal": true; }; "displayFn": { "alias": "displayFn"; "required": false; "isSignal": true; }; "deletable": { "alias": "deletable"; "required": false; "isSignal": true; }; }, { "onDelete": "onDelete"; }, never, never, true, never>;
+}
+
+declare class C3FileDisplayListColumnDefDirective {
+    readonly title: i0.InputSignal<string>;
+    readonly classList: i0.InputSignal<string[]>;
+    private readonly _table;
+    readonly headerCellDef: i0.Signal<C3FileDisplayListHeaderCellDefDirective | undefined>;
+    readonly cellDef: i0.Signal<C3FileDisplayListCellDefDirective | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileDisplayListColumnDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3FileDisplayListColumnDefDirective, "[c3FileDisplayListColumnDef]", never, { "title": { "alias": "c3FileDisplayListColumnDef"; "required": true; "isSignal": true; }; "classList": { "alias": "classList"; "required": false; "isSignal": true; }; }, {}, ["headerCellDef", "cellDef"], never, true, never>;
+}
+declare class C3FileDisplayListHeaderCellDefDirective {
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileDisplayListHeaderCellDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3FileDisplayListHeaderCellDefDirective, "[c3FileDisplayListHeaderCellDef]", never, {}, {}, never, never, true, never>;
+}
+declare class C3FileDisplayListCellDefDirective {
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileDisplayListCellDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3FileDisplayListCellDefDirective, "[c3FileDisplayListCellDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class C3FileDisplayListComponent {
+    readonly files: i0.InputSignal<(FileMetadata & {
+        location: string;
+    })[]>;
+    readonly config: i0.InputSignal<C3FileViewerConfig | undefined>;
+    readonly displayFn: i0.InputSignal<(file: FileMetadata & {
+        location: string;
+    }) => string>;
+    readonly columns: i0.InputSignal<string[]>;
+    readonly deletable: i0.InputSignal<boolean>;
+    readonly onDelete: i0.OutputEmitterRef<FileMetadata>;
+    readonly dialog: i0.Signal<C3FileViewerDialogComponent | undefined>;
+    private readonly _columnDefs;
+    private readonly _viewContainer;
+    fileViewer: C3FileViewer;
+    constructor();
+    openDialog($event: MouseEvent, index: number): void;
+    getColumnDef(columnName: string): C3FileDisplayListColumnDefDirective | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileDisplayListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileDisplayListComponent, "c3-file-display-list", never, { "files": { "alias": "files"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "displayFn": { "alias": "displayFn"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "deletable": { "alias": "deletable"; "required": false; "isSignal": true; }; }, { "onDelete": "onDelete"; }, ["_columnDefs"], ["*"], true, never>;
+}
+
+declare class C3FileDisplayIconComponent {
+    readonly fileType: i0.InputSignal<string>;
+    readonly displayedIcon: i0.Signal<"image" | "play_circle" | "picture_as_pdf" | "description" | "content_copy">;
+    readonly color: i0.Signal<"text-primary" | "text-secondary" | "text-error" | "text-success" | "text-gray">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileDisplayIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FileDisplayIconComponent, "c3-file-display-icon", never, { "fileType": { "alias": "fileType"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class C3FileDisplayerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FileDisplayerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<C3FileDisplayerModule, never, [typeof i3.CommonModule, typeof C3FileDisplayGridComponent, typeof C3FileDisplayListComponent, typeof C3FileDisplayCardComponent, typeof C3FileDisplayIconComponent, typeof C3FileDisplayListColumnDefDirective, typeof C3FileDisplayListHeaderCellDefDirective, typeof C3FileDisplayListCellDefDirective], [typeof C3FileDisplayGridComponent, typeof C3FileDisplayListComponent, typeof C3FileDisplayCardComponent, typeof C3FileDisplayIconComponent, typeof C3FileDisplayListColumnDefDirective, typeof C3FileDisplayListHeaderCellDefDirective, typeof C3FileDisplayListCellDefDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<C3FileDisplayerModule>;
+}
+
+declare const C3_FILE_DISPLAY_LIST: InjectionToken<any>;
+
+declare class C3ExpansionHeaderComponent {
+    title: i0.InputSignal<string | undefined>;
+    isExpanded: i0.InputSignal<boolean>;
+    toggleExpand: i0.OutputEmitterRef<void>;
+    get hostClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3ExpansionHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3ExpansionHeaderComponent, "c3-expansion-header", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "isExpanded": { "alias": "isExpanded"; "required": false; "isSignal": true; }; }, { "toggleExpand": "toggleExpand"; }, never, ["*"], false, never>;
+}
+
+declare class C3AutoAnimateDirective implements AfterViewInit {
+    private el;
+    readonly options: i0.InputSignal<AutoAnimationPlugin | Partial<AutoAnimateOptions> | undefined>;
+    constructor(el: ElementRef);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3AutoAnimateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3AutoAnimateDirective, "[c3AutoAnimate]", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class C3ExpansionComponent implements OnDestroy {
+    headerClass: i0.InputSignal<string>;
+    isExpanded: i0.ModelSignal<boolean>;
+    get hostClass(): string;
+    readonly _elementRef: ElementRef<any>;
+    readonly header: i0.Signal<C3ExpansionHeaderComponent | undefined>;
+    private expandSubsciption;
+    constructor();
+    ngOnDestroy(): void;
+    toggleExpand(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3ExpansionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3ExpansionComponent, "c3-expansion", never, { "headerClass": { "alias": "headerClass"; "required": false; "isSignal": true; }; "isExpanded": { "alias": "isExpanded"; "required": false; "isSignal": true; }; }, { "isExpanded": "isExpandedChange"; }, ["header"], ["c3-expansion-header", "*"], false, [{ directive: typeof C3AutoAnimateDirective; inputs: { "options": "options"; }; outputs: {}; }]>;
+}
+
+declare class C3ExpansionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3ExpansionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<C3ExpansionModule, [typeof C3ExpansionComponent, typeof C3ExpansionHeaderComponent], [typeof i3.CommonModule, typeof C3AutoAnimateDirective, typeof i5.MatButtonModule, typeof i12.MatIconModule, typeof i7.MatTooltipModule, typeof i5.MatButtonModule, typeof i14.MatToolbarModule], [typeof C3ExpansionComponent, typeof C3ExpansionHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<C3ExpansionModule>;
+}
+
+declare class C3SelectOnFocusDirective {
+    onFocus(target: HTMLInputElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3SelectOnFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3SelectOnFocusDirective, "[c3SelectOnFocus]", never, {}, {}, never, never, true, never>;
+}
+
+interface TreeType<T> {
+    id: number;
+    level: number;
+    name: string;
+    ancestorId?: number;
+    ancestor?: TreeType<T>;
+    children: TreeType<T>[];
+    rawData: T;
+}
+interface FileNode<RawData> extends TreeType<RawData> {
+    expandable: boolean;
+}
+declare class C3TreeComponent<RawData, T extends TreeType<RawData> = TreeType<RawData>> {
+    readonly treeData: i0.ModelSignal<T[]>;
+    readonly isLoading: i0.ModelSignal<boolean>;
+    readonly treeDataSelected: i0.OutputEmitterRef<T>;
+    private _transformer;
+    constructor();
+    hasChild: (_: number, node: T) => boolean;
+    treeControl: FlatTreeControl<FileNode<RawData>, FileNode<RawData>>;
+    treeFlattener: MatTreeFlattener<TreeType<RawData>, FileNode<RawData>, FileNode<RawData>>;
+    dataSource: MatTreeFlatDataSource<TreeType<RawData>, FileNode<RawData>, FileNode<RawData>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3TreeComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3TreeComponent<any, any>, "c3-tree", never, { "treeData": { "alias": "treeData"; "required": true; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; }, { "treeData": "treeDataChange"; "isLoading": "isLoadingChange"; "treeDataSelected": "treeDataSelected"; }, never, ["*"], true, never>;
+}
+
+declare class C3FlowingMenuItemComponent {
+    readonly menuTpl: i0.Signal<TemplateRef<any> | undefined>;
+    readonly contentTpl: i0.Signal<TemplateRef<any> | undefined>;
+    readonly active: i0.WritableSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FlowingMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FlowingMenuItemComponent, "c3-flowing-menu-item", never, {}, {}, never, ["[menu-title]", "c3-flowing-menu-item-content"], false, never>;
+}
+
+declare class C3FlowingMenuComponent {
+    readonly c3FlowingMenu: i0.Signal<readonly C3FlowingMenuItemComponent[]>;
+    private readonly targetContentRef;
+    readonly selectedIndex: i0.ModelSignal<number>;
+    constructor();
+    selectMenu(index: number): void;
+    private updateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FlowingMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FlowingMenuComponent, "c3-flowing-menu", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; }, ["c3FlowingMenu"], never, false, never>;
+}
+
+declare class C3FlowingMenuItemContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FlowingMenuItemContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3FlowingMenuItemContentComponent, "c3-flowing-menu-item-content", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class C3FlowingMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3FlowingMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<C3FlowingMenuModule, [typeof C3FlowingMenuComponent, typeof C3FlowingMenuItemComponent, typeof C3FlowingMenuItemContentComponent], [typeof i3.CommonModule], [typeof C3FlowingMenuComponent, typeof C3FlowingMenuItemComponent, typeof C3FlowingMenuItemContentComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<C3FlowingMenuModule>;
+}
+
+declare class C3TraceCardComponent {
+    readonly align: i0.WritableSignal<"left" | "right">;
+    get alignLeft(): boolean;
+    get alignRight(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3TraceCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3TraceCardComponent, "c3-trace-card", never, {}, {}, never, ["c3-trace-card-content", "c3-trace-card-title"], false, never>;
+}
+
+declare class C3TraceCardTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3TraceCardTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3TraceCardTitleComponent, "c3-trace-card-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class C3TraceCardContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3TraceCardContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3TraceCardContentComponent, "c3-trace-card-content", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class C3TraceCardAlignLeftDirective {
+    private readonly c3CardTitle;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3TraceCardAlignLeftDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3TraceCardAlignLeftDirective, "c3-trace-card[align-left]", never, {}, {}, never, never, true, never>;
+}
+
+declare class C3TraceCardAlignRightDirective {
+    private readonly c3CardTitle;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3TraceCardAlignRightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3TraceCardAlignRightDirective, "c3-trace-card[align-right]", never, {}, {}, never, never, true, never>;
+}
+
+declare class C3TraceCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3TraceCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<C3TraceCardModule, [typeof C3TraceCardComponent, typeof C3TraceCardTitleComponent, typeof C3TraceCardContentComponent], [typeof i3.CommonModule, typeof C3TraceCardAlignLeftDirective, typeof C3TraceCardAlignRightDirective], [typeof C3TraceCardComponent, typeof C3TraceCardTitleComponent, typeof C3TraceCardContentComponent, typeof C3TraceCardAlignLeftDirective, typeof C3TraceCardAlignRightDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<C3TraceCardModule>;
+}
+
+/**
+ * A directive that prevents the default action and stops event propagation on click events.
+ */
+declare class C3PreventClickDirective {
+    /**
+     * HostListener for the 'click' event.
+     * @param {MouseEvent} event - The MouseEvent object representing the click event.
+     */
+    onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3PreventClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3PreventClickDirective, "[c3-prevent-click]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A directive that prevents the default action and stops event propagation on specified keyboard events.
+ */
+declare class C3PreventKeyboardEventDirective {
+    /**
+     * The keyboard key to prevent the default action and stop event propagation for. Defaults to 'enter'.
+     */
+    readonly key: i0.InputSignal<string>;
+    /**
+     * HostListener for the 'keydown' event.
+     * @param {KeyboardEvent} event - The KeyboardEvent object representing the keydown event.
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3PreventKeyboardEventDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3PreventKeyboardEventDirective, "[c3-prevent-keyboard-event]", never, { "key": { "alias": "key"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class C3StopPropagationDirective {
+    onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3StopPropagationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<C3StopPropagationDirective, "[c3-stop-click-propagation]", never, {}, {}, never, never, true, never>;
+}
+
+declare class C3MenuService {
+    selectedElement: HTMLElement | null;
+    currentRouteChange: Observable<string>;
+    readonly currentRoute: i0.WritableSignal<string>;
+    readonly isHeadless: i0.WritableSignal<boolean>;
+    private readonly _router;
+    private readonly _ar;
+    constructor();
+    setSelectedItem(element: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3MenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<C3MenuService>;
+}
+
+declare class C3MenuComponent {
+    readonly _c3Menu: C3MenuService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3MenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3MenuComponent, "c3-menu", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class C3NavItemComponent {
+    readonly route: i0.InputSignal<string>;
+    readonly itemTitle: i0.InputSignal<string>;
+    readonly check: i0.InputSignal<string | null>;
+    readonly isExternal: i0.InputSignal<boolean>;
+    private readonly element;
+    private readonly _menu;
+    private readonly destroyRef;
+    private readonly currentRouteChangeSubscription;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3NavItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<C3NavItemComponent, "c3-nav-item", never, { "route": { "alias": "route"; "required": true; "isSignal": true; }; "itemTitle": { "alias": "itemTitle"; "required": true; "isSignal": true; }; "check": { "alias": "check"; "required": false; "isSignal": true; }; "isExternal": { "alias": "isExternal"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class C3MenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<C3MenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<C3MenuModule, [typeof C3MenuComponent, typeof C3NavItemComponent], [typeof i3.CommonModule, typeof i4$1.RouterModule, typeof i5$1.MatRippleModule], [typeof C3MenuComponent, typeof C3NavItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<C3MenuModule>;
+}
+
+export { C3AlertDialogComponent, C3AutoAnimateDirective, C3DialogEmbedChildComponent, C3DialogModule, C3DialogService, C3DialogTemplateComponent, C3DropdownComponent, C3DropdownModule, C3DropdownTrigger, C3ExpansionComponent, C3ExpansionHeaderComponent, C3ExpansionModule, C3FileDisplayCardComponent, C3FileDisplayGridComponent, C3FileDisplayIconComponent, C3FileDisplayListCellDefDirective, C3FileDisplayListColumnDefDirective, C3FileDisplayListComponent, C3FileDisplayListHeaderCellDefDirective, C3FileDisplayerModule, C3FileViewer, C3FileViewerComponent, C3FileViewerDialog, C3FileViewerDialogComponent, C3FileViewerModule, C3FlowingMenuComponent, C3FlowingMenuItemComponent, C3FlowingMenuItemContentComponent, C3FlowingMenuModule, C3MenuComponent, C3MenuModule, C3NavItemComponent, C3OpenDialogDirective, C3PreventClickDirective, C3PreventKeyboardEventDirective, C3PromptDialogComponent, C3SafeUrlPipe, C3SelectOnFocusDirective, C3StopPropagationDirective, C3TraceCardAlignLeftDirective, C3TraceCardAlignRightDirective, C3TraceCardComponent, C3TraceCardContentComponent, C3TraceCardModule, C3TraceCardTitleComponent, C3TreeComponent, C3_FILE_DISPLAY_LIST, ConfirmDialogComponent, CustomFileEvent, FullScreenDirective, MAT_DROPDOWN_VALUE_ACCESSOR };
+export type { AlertConfig, C3CreateDialogFromComponentConfig, C3CreateDialogFromComponentResult, C3FileCardSize, C3FileViewerConfig, ConfirmConfig, FileMetadata, FileNode, HttpClientOptions, PromptConfig, TreeType, VariantFile };