@dataclouder/ngx-core 0.1.30 → 0.1.31

package/index.d.ts

@@ -1,5 +1,833 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, SimpleChanges, OnDestroy, InjectionToken, WritableSignal, Type, Provider, PipeTransform } from '@angular/core';
+import { FormGroup, FormArray } from '@angular/forms';
+import { MenuItem, FilterMetadata } from 'primeng/api';
+import { ActivatedRoute, Router } from '@angular/router';
+import { Table } from 'primeng/table';
+import { DynamicDialogRef, DialogService } from 'primeng/dynamicdialog';
+import { HttpErrorResponse } from '@angular/common/http';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as _dataclouder_ngx_core from '@dataclouder/ngx-core';
+
+declare class EmptyStateComponent {
+    headingText: string;
+    subHeadingText: string;
+    readonly mainIconSrcString: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateComponent, "dc-empty-state", never, { "headingText": { "alias": "headingText"; "required": false; }; "subHeadingText": { "alias": "subHeadingText"; "required": false; }; "mainIconSrcString": { "alias": "mainIconSrcString"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface SortOption {
+    label: string;
+    value: string;
+}
+declare const availibleFilters: {
+    name: string;
+    code: string;
+}[];
+declare enum OptionValue {
+    Newest = "newest",
+    Oldest = "oldest",
+    Alphabetical = "alphabetical",
+    ReverseAlphabetical = "reverseAlphabetical"
+}
+declare const sortOptions: SortOption[];
+declare const sortTypes: ({
+    name: string;
+    code: string;
+    sort: {
+        createdDate: number;
+        takenCount?: undefined;
+    };
+} | {
+    name: string;
+    code: string;
+    sort: {
+        takenCount: number;
+        createdDate?: undefined;
+    };
+})[];
+interface ICustomFilter {
+    name: string;
+    field: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'select';
+    options?: {
+        label: string;
+        value: any;
+    }[];
+    defaultValue?: any;
+}
+interface FiltersConfig {
+    page?: number;
+    rowsPerPage?: number;
+    sort?: {
+        [key: string]: number;
+    };
+    filters?: {
+        [key: string]: any;
+    };
+    text?: string;
+    returnProps?: Record<string, 0 | 1>;
+}
+interface IFilterQueryResponse<T> {
+    rows: T[];
+    count: number;
+    skip: number;
+}
+interface ListFilterBarOptions {
+    showCreateButton?: boolean;
+    showViewButton?: boolean;
+    showActions?: boolean;
+}
+
+interface PColumn {
+    field: string;
+    header: string;
+    type?: 'text' | 'image' | 'tags' | 'actions';
+}
+declare class QuickTableComponent {
+    readonly columns: i0.InputSignal<PColumn[]>;
+    readonly tableData: i0.InputSignal<any[]>;
+    readonly actions: i0.InputSignal<MenuItem[]>;
+    readonly onAction: i0.OutputEmitterRef<OnActionEvent>;
+    _columns: i0.WritableSignal<PColumn[]>;
+    _tableData: i0.WritableSignal<any[]>;
+    _actions: i0.WritableSignal<MenuItem[]>;
+    filters: i0.WritableSignal<{
+        [s: string]: FilterMetadata | FilterMetadata[];
+    }>;
+    globalFilterFields: i0.WritableSignal<string[]>;
+    tableRef: Table;
+    tableColumns: any[];
+    constructor();
+    private initializeTableColumns;
+    selectItem(item: any, action: MenuItem): void;
+    onGlobalFilter(event: Event): void;
+    getFilterType(column: PColumn): string;
+    private initializeFilters;
+    onFilterLocal(event: any): void;
+    filterOutsideTable(type: 'tags' | 'text', column: string, value: string[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuickTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuickTableComponent, "app-quick-table", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "tableData": { "alias": "tableData"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+}
+
+interface OnActionEvent {
+    action?: string;
+    item?: any;
+    menuItem?: MenuItem;
+}
 /**
- * Generated bundle index. Do not edit.
+ * Abstract base class for implementing pagination functionality.
+ * Provides common pagination logic, state management, and navigation handling.
+ * Child classes must implement the loadData method and define columns.
  */
-/// <amd-module name="@dataclouder/ngx-core" />
-export * from './public-api';
+declare abstract class PaginationBase {
+    /**
+     * Available actions for items.
+     * Must be implemented by child classes.
+     */
+    readonly actions: i0.InputSignal<MenuItem[]>;
+    /**
+     * Event emitted when an action is performed on an item.
+     * Emits an object containing the item and the action that was triggered.
+     */
+    readonly onAction: i0.OutputEmitterRef<OnActionEvent>;
+    /** Current first record index for the paginator */
+    first: number;
+    /** Number of rows to display per page */
+    rows: number;
+    /** Total number of records available */
+    totalRecords: number;
+    /** Current view mode, either cards or table */
+    viewMode: 'cards' | 'table';
+    /** Loading state indicator */
+    isLoading: boolean;
+    /** Available button actions for items */
+    buttonActions: MenuItem[];
+    /**
+     * Columns configuration for the table view.
+     * Must be implemented by child classes.
+     */
+    protected abstract columns: PColumn[];
+    /**
+     * Configuration for filtering, sorting, and pagination.
+     * Includes current page, rows per page, sorting criteria, and applied filters.
+     */
+    filterConfig: FiltersConfig;
+    protected route: ActivatedRoute;
+    protected router: Router;
+    /**
+     * Creates an instance of PaginationBase.
+     * @param route - The ActivatedRoute for accessing route parameters
+     * @param router - The Router for navigation
+     */
+    constructor();
+    /**
+     * Initializes pagination based on URL query parameters.
+     * Sets the current page from the 'page' query parameter if available.
+     * @private
+     */
+    private initializePagination;
+    /**
+     * Handles pagination events from the paginator component.
+     * Updates the filter configuration, loads new data, and updates the URL.
+     * @param pageEvent - The page event containing page number and rows per page
+     */
+    onPageChange(pageEvent: any): Promise<void>;
+    /**
+     * Updates the 'page' query parameter in the URL.
+     * @param newPage - The new page number to set in the URL
+     * @private
+     */
+    private updatePageParam;
+    /**
+     * Loads data for the current page configuration.
+     * Must be implemented by child classes to fetch data from the appropriate source.
+     * @returns A promise that resolves when data loading is complete
+     */
+    protected abstract loadData(): Promise<void>;
+    /**
+     * Handle actions triggered from the table or card view
+     * @param param0 Object containing the item and action that was triggered
+     */
+    doAction(actionEvent: OnActionEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PaginationBase, never, never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+}
+
+declare class DCFilterBarComponent implements OnInit, OnChanges {
+    private readonly fb;
+    readonly items: i0.InputSignal<MenuItem[]>;
+    readonly options: i0.InputSignal<ListFilterBarOptions>;
+    customFilters: ICustomFilter[];
+    readonly onFilterAction: i0.OutputEmitterRef<any>;
+    readonly onChangeSort: i0.OutputEmitterRef<any>;
+    readonly onNew: i0.OutputEmitterRef<any>;
+    customFiltersForm: FormGroup;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private buildCustomFiltersForm;
+    availibleFilters: {
+        name: string;
+        code: string;
+    }[];
+    sortOptions: SortOption[];
+    isSearchVisible: boolean;
+    isFilterVisible: boolean;
+    placeholder: string;
+    filter: FiltersConfig;
+    selectedFilters: (typeof availibleFilters)[];
+    selectedSort: SortOption | null;
+    dateRange: Date[];
+    changeFilter(event: any): void;
+    changeSort(event: any): void;
+    createNew(): void;
+    search(text?: string): void;
+    clearFilters(): void;
+    applyFilters(): void;
+    doItemAction(filterEvent: OnActionEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DCFilterBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DCFilterBarComponent, "dc-filter-bar", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "customFilters": { "alias": "customFilters"; "required": false; }; }, { "onFilterAction": "onFilterAction"; "onChangeSort": "onChangeSort"; "onNew": "onNew"; }, never, never, true, never>;
+}
+
+declare class ConfirmComponent implements OnInit {
+    private dynamicDialogConfig;
+    ref: DynamicDialogRef<any>;
+    title: string;
+    message: string;
+    warning: string;
+    oneBotton: boolean;
+    acceptText: string;
+    cancelText: string;
+    piIcon: string;
+    onEnter(_event: any): void;
+    onEscapte(_event: any): void;
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    cancel(): void;
+    confirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmComponent, "app-confirm", never, { "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "warning": { "alias": "warning"; "required": false; }; "oneBotton": { "alias": "oneBotton"; "required": false; }; "acceptText": { "alias": "acceptText"; "required": false; }; "cancelText": { "alias": "cancelText"; "required": false; }; "piIcon": { "alias": "piIcon"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DCProgressToastComponent implements OnChanges, OnDestroy {
+    private messageService;
+    private cdr;
+    visible: boolean;
+    readonly progress: i0.InputSignal<number>;
+    readonly processCompleted: i0.OutputEmitterRef<void>;
+    readonly processClosed: i0.OutputEmitterRef<void>;
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private showConfirm;
+    private onComplete;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DCProgressToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DCProgressToastComponent, "dc-progress-toast", never, { "visible": { "alias": "visible"; "required": false; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, { "processCompleted": "processCompleted"; "processClosed": "processClosed"; }, never, never, true, never>;
+}
+
+/**
+ * Service for managing a loading/progress bar component in the application.
+ *
+ * This service provides methods to control the visibility, progress state, and appearance
+ * of a loading bar. It supports both determinate (with specific progress percentage)
+ * and indeterminate modes, as well as different color options.
+ */
+declare class LoadingBarService {
+    /** Flag indicating whether the loading bar is currently visible */
+    isShowing: boolean;
+    /** Current progress value (0-100) for determinate mode */
+    progress: number;
+    /** The current display mode of the loading bar */
+    mode: 'indeterminate' | 'determinate';
+    /** The color of the loading bar (can be a theme color name or hex value) */
+    color: string;
+    /** Interval reference for the fake progress animation */
+    private progressInterval;
+    constructor();
+    /**
+     * Shows the loading bar in determinate mode with 0% progress.
+     * Use this method when starting a process with known progress states.
+     */
+    showProgressBar(): void;
+    /**
+     * Shows the loading bar in indeterminate mode.
+     * Use this method when the progress of a process cannot be determined.
+     */
+    showIndeterminate(): void;
+    /**
+     * Shows the loading bar in determinate mode with a specific progress value.
+     *
+     * @param progress The progress value to display (0-100)
+     */
+    showProgressBarWithProgress(progress: number): void;
+    /**
+     * Hides the loading bar and resets its state.
+     * Call this method when a process completes or when you want to hide the loading bar.
+     */
+    hideProgressBar(): void;
+    /**
+     * Shows a success state (green color, 100% progress) and then automatically hides the loading bar after a delay.
+     * Use this method to indicate successful completion of a process with visual feedback.
+     */
+    successAndHide(): void;
+    errorAndHide(): void;
+    infoAndHide(): void;
+    /**
+     * Demonstrates the loading bar by simulating progress from 0% to 100% over 5 seconds.
+     * This is a test/demo method to visualize how the loading bar works.
+     */
+    testProgressBar(): void;
+    /**
+     * Animates the progress bar from 0 to 100 over a specified time period
+     * use when you dont know the duration of the process
+     * if your process finish before the time ends call successAndHide()
+     * @param durationInSeconds The total duration of the animation in seconds (default: 20)
+     */
+    fakeProgressWithTime(durationInSeconds?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingBarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingBarService>;
+}
+
+declare class LoadingBarComponent {
+    loadingBarService: LoadingBarService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingBarComponent, "dc-loading-bar", never, {}, {}, never, never, true, never>;
+}
+
+type IExtensionable = Record<string, any>;
+interface IAuditable {
+    createdBy: string;
+    updatedBy: string;
+    authorEmail: string;
+    generatedByIA: boolean;
+    prompt?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+interface ILearnable {
+    level: number;
+    takenCount: number;
+    tags: string[];
+    avgRating?: number;
+    ratingsCount?: number;
+    estimatedDuration?: number;
+    successRate?: number;
+}
+interface IManageable {
+    isPublic: boolean;
+    status?: 'draft' | 'review' | 'published' | 'archived';
+}
+interface IReactable {
+    reactionsCount?: {
+        [reactionType: string]: number;
+    };
+}
+
+declare class DcAuditableViewerComponent {
+    data: i0.InputSignal<IAuditable>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DcAuditableViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DcAuditableViewerComponent, "dc-auditable-viewer", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DcExtensionsViewerComponent {
+    data: i0.InputSignal<IExtensionable>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DcExtensionsViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DcExtensionsViewerComponent, "dc-extensions-viewer", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DcLearnableViewerComponent {
+    data: i0.InputSignal<ILearnable>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DcLearnableViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DcLearnableViewerComponent, "dc-learnable-viewer", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DcManageableViewerComponent {
+    data: i0.InputSignal<IManageable>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DcManageableViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DcManageableViewerComponent, "dc-manageable-viewer", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DcReactionsViewerComponent {
+    data: i0.InputSignal<IReactable>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DcReactionsViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DcReactionsViewerComponent, "dc-reactions-viewer", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Interface for HTTP error responses
+ */
+interface HttpCoreError {
+    error_message: string;
+    explanation: string;
+    status?: number;
+    code?: string;
+}
+/**
+ * Interface for deleted data response
+ */
+interface DeletedData {
+    acknowledged: boolean;
+    deletedCount: number;
+}
+/**
+ * Configuration for HttpCoreService
+ */
+interface HttpCoreConfig {
+    primaryUrl: string;
+    secondaryUrl?: string;
+    defaultHost?: 'primary' | 'secondary';
+    errorHandler?: (error: HttpErrorResponse) => void;
+}
+/**
+ * Injection token for HttpCoreService configuration
+ */
+declare const HTTP_CORE_CONFIG: InjectionToken<HttpCoreConfig>;
+/**
+ * Modern HTTP service for Angular applications
+ * Provides methods for making HTTP requests with proper error handling and response transformation
+ */
+declare class HttpCoreService {
+    private httpClient;
+    private isLoading;
+    private lastError;
+    private config;
+    constructor(config: HttpCoreConfig | null);
+    /**
+     * Set the configuration for the service
+     * This allows for manual configuration when not using dependency injection
+     */
+    setConfig(config: HttpCoreConfig): void;
+    /**
+     * Get the loading state as a signal
+     */
+    loading(): i0.WritableSignal<boolean>;
+    /**
+     * Get the last error as a signal
+     */
+    error(): i0.WritableSignal<HttpCoreError>;
+    /**
+     * Make a POST request to the specified service
+     * @param service The service endpoint
+     * @param data The data to send
+     * @param host The host to use (primary or secondary)
+     * @returns A promise with the response
+     */
+    post<T = any>(service: string, data: any, host?: "primary" | "secondary"): Promise<T>;
+    /**
+     * Make a POST request to a specific URL
+     * @param baseUrl The base URL
+     * @param service The service endpoint
+     * @param data The data to send
+     * @returns A promise with the response
+     */
+    postToUrl<T = any>(baseUrl: string, service: string, data: any): Promise<T>;
+    /**
+     * Make a PUT request to the specified service
+     * @param service The service endpoint
+     * @param data The data to send
+     * @param host The host to use (primary or secondary)
+     * @returns A promise with the response
+     */
+    put<T = any>(service: string, data: any, host?: "primary" | "secondary"): Promise<T>;
+    /**
+     * Make a PUT request to a specific URL
+     * @param baseUrl The base URL
+     * @param service The service endpoint
+     * @param data The data to send
+     * @returns A promise with the response
+     */
+    putToUrl<T = any>(baseUrl: string, service: string, data: any): Promise<T>;
+    /**
+     * Make a GET request to the specified service
+     * @param service The service endpoint
+     * @param host The host to use (primary or secondary)
+     * @param skipErrorHandling Whether to skip error handling
+     * @returns A promise with the response
+     */
+    get<T = any>(service: string, host?: "primary" | "secondary", skipErrorHandling?: boolean): Promise<T>;
+    /**
+     * Make a GET request to a specific URL
+     * @param baseUrl The base URL
+     * @param service The service endpoint
+     * @param skipErrorHandling Whether to skip error handling
+     * @returns A promise with the response
+     */
+    getFromUrl<T = any>(baseUrl: string, service: string, skipErrorHandling?: boolean): Promise<T>;
+    /**
+     * Make a DELETE request to the specified service
+     * @param service The service endpoint
+     * @param host The host to use (primary or secondary)
+     * @returns A promise with the response
+     */
+    delete<T = DeletedData>(service: string, host?: "primary" | "secondary"): Promise<T>;
+    /**
+     * Make a DELETE request to a specific URL
+     * @param baseUrl The base URL
+     * @param service The service endpoint
+     * @returns A promise with the response
+     */
+    deleteFromUrl<T = DeletedData>(baseUrl: string, service: string): Promise<T>;
+    /**
+     * Get an observable for a GET request
+     * @param service The service endpoint
+     * @param host The host to use (primary or secondary)
+     * @returns An observable with the response
+     */
+    getObservable<T = any>(service: string, host?: "primary" | "secondary"): Observable<T>;
+    /**
+     * Get an observable for a POST request
+     * @param service The service endpoint
+     * @param data The data to send
+     * @param skipErrorHandling Whether to skip error handling
+     * @param host The host to use (primary or secondary)
+     * @returns An observable with the response
+     */
+    postObservable<T = any>(service: string, data: any, skipErrorHandling?: boolean, host?: "primary" | "secondary"): Observable<T>;
+    /**
+     * Get an observable for a DELETE request
+     * @param service The service endpoint
+     * @param host The host to use (primary or secondary)
+     * @returns An observable with the response
+     */
+    deleteObservable<T = DeletedData>(service: string, host?: "primary" | "secondary"): Observable<T>;
+    /**
+     * Upload a file to the specified service
+     * @param service The service endpoint
+     * @param file The file to upload
+     * @param metadata Optional metadata to send with the file
+     * @param host The host to use (primary or secondary)
+     * @returns A promise with the response
+     */
+    uploadFile<T = any>(service: string, file: Blob, metadata?: any, host?: "primary" | "secondary"): Promise<T>;
+    /**
+     * Download a file from the specified service
+     * @param service The service endpoint
+     * @param host The host to use (primary or secondary)
+     * @returns A promise with the response
+     */
+    downloadFile(service: string, host?: "primary" | "secondary"): Promise<any>;
+    /**
+     * Upload a file to the specified service and get the response as a blob
+     * @param service The service endpoint
+     * @param data The data to send
+     * @param host The host to use (primary or secondary)
+     * @returns A promise with the response
+     */
+    postFileAndGetBlob(service: string, data: any, host?: "primary" | "secondary"): Promise<any>;
+    /**
+     * Get a file from the specified service as an observable
+     * @param service The service endpoint
+     * @param host The host to use (primary or secondary)
+     * @returns An observable with the response
+     */
+    getFileObservable(service: string, host?: "primary" | "secondary"): Observable<Blob>;
+    /**
+     * Get the URL for the specified host
+     * @param host The host to use (primary or secondary)
+     * @returns The URL for the specified host
+     */
+    private getHostUrl;
+    /**
+     * Handle an error from a request
+     * @param error The error to handle
+     * @returns An observable that throws the error
+     */
+    private handleRequestError;
+    /**
+     * Handle an error from a blob request
+     * @param error The error to handle
+     * @returns An observable that throws the error
+     */
+    private handleBlobError;
+    /**
+     * Check the status of a response
+     * @param response The response to check
+     */
+    private checkResponseStatus;
+    /**
+     * Convert an object to a plain object
+     * @param obj The object to convert
+     * @returns A plain object
+     */
+    private toPlainObject;
+    postObservableWithProgress<DataType>(service: string, data: DataType, host?: 'primary' | 'secondary'): Observable<{
+        progress?: number;
+        blob?: Blob;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpCoreService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpCoreService>;
+}
+
+declare abstract class EntityCommunicationService<T> {
+    private serviceName;
+    protected httpService: HttpCoreService;
+    constructor(serviceName: string);
+    findAll(): Promise<T[]>;
+    findOne(id: string): Promise<T>;
+    createOrUpdate(entity: Partial<T>): Promise<T>;
+    query(filterConfig: FiltersConfig): Promise<IFilterQueryResponse<T>>;
+    partialUpdate(id: string, partialUpdates: Partial<T>): Promise<T>;
+    remove(id: string): Promise<void>;
+    clone(id: string, overrides?: Partial<T>): Promise<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCommunicationService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCommunicationService<any>>;
+}
+
+declare abstract class EntityBaseListComponent<T> extends PaginationBase implements OnInit {
+    protected router: Router;
+    protected route: ActivatedRoute;
+    protected abstract entityCommunicationService: EntityCommunicationService<T>;
+    abstract getCustomButtons(item: T): MenuItem[];
+    readonly initialViewType: i0.InputSignal<"table" | "card">;
+    readonly onlyView: i0.InputSignal<boolean>;
+    readonly onSelect: i0.OutputEmitterRef<T>;
+    items: WritableSignal<T[]>;
+    viewType: WritableSignal<'table' | 'card'>;
+    totalRecordsSignal: WritableSignal<number>;
+    filterBarOptions: ListFilterBarOptions;
+    columns: any[];
+    constructor();
+    ngOnInit(): Promise<void>;
+    protected loadData(): Promise<void>;
+    onNew(): void;
+    toggleView(): void;
+    doAction(actionEvent: OnActionEvent): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityBaseListComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EntityBaseListComponent<any>, never, never, { "initialViewType": { "alias": "initialViewType"; "required": false; "isSignal": true; }; "onlyView": { "alias": "onlyView"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
+}
+
+declare abstract class EntityBaseFormComponent<T extends {
+    _id?: string;
+}> {
+    protected route: ActivatedRoute;
+    protected router: Router;
+    toastService: _dataclouder_ngx_core.ToastAlertsAbstractService;
+    entity: i0.WritableSignal<T>;
+    entityId: i0.Signal<string>;
+    abstract form: FormGroup;
+    protected abstract entityCommunicationService: EntityCommunicationService<T>;
+    protected abstract patchForm(entity: T): void;
+    save(): Promise<T | undefined>;
+    getDirtyValues(form: FormGroup | FormArray): {
+        [key: string]: unknown;
+    };
+    saveDirtyValues(): Promise<T>;
+    private loadEntityEffect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityBaseFormComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EntityBaseFormComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare enum EModelQuality {
+    FAST = "fast",// Prioritize speed over intelligence like flash lite
+    BALANCED = "balanced",// Equal balance like flash 2.5
+    SMART = "smart",// Prioritize intelligence over speed like gemini pro 2.5
+    SMART_THINKING = "smart-thinking"
+}
+declare const ModelQualityOptions: {
+    label: string;
+    value: EModelQuality;
+}[];
+
+declare const TOAST_ALERTS_TOKEN: InjectionToken<ToastAlertsAbstractService>;
+interface ToastData {
+    title: string;
+    subtitle: string;
+}
+declare abstract class ToastAlertsAbstractService {
+    abstract success(data: ToastData): void;
+    abstract info(data: ToastData): void;
+    abstract warn(data: ToastData): void;
+    abstract error(data: ToastData): void;
+}
+declare function provideToastAlert(serviceImplementation: Type<ToastAlertsAbstractService>): Provider[];
+declare enum AudioSpeed {
+    VerySlow = "verySlow",
+    Slow = "slow",
+    Regular = "regular",
+    Fast = "fast",
+    VeryFast = "veryFast"
+}
+declare const AudioSpeedReverse: {
+    verySlow: number;
+    slow: number;
+    regular: number;
+    fast: number;
+    veryFast: number;
+};
+declare class IAIModel {
+    provider?: string;
+    modelName?: string;
+    quality?: EModelQuality;
+    id?: string;
+}
+declare class ChatUserSettings {
+    realTime: boolean;
+    superHearing: boolean;
+    repeatRecording: boolean;
+    voice?: string;
+    highlightWords?: boolean;
+    synthVoice?: boolean;
+    model?: IAIModel;
+    speed?: AudioSpeed;
+    speedRate?: number;
+    userMessageTask: boolean;
+    assistantMessageTask: boolean;
+}
+
+/**
+ * Extracts and parses the first JSON object or array found within a string.
+ *
+ * @param content - The input string that may contain JSON data
+ * @returns {any} The parsed JSON data if found and valid, or null if:
+ *   - No JSON object/array is found in the string
+ *   - The found JSON is invalid and cannot be parsed
+ *
+ * @example
+ * // Returns {name: "John"}
+ * extractJsonFromString('Some text {"name": "John"} more text');
+ *
+ * // Returns [1, 2, 3]
+ * extractJsonFromString('Before [1,2,3] after');
+ *
+ * // Returns null
+ * extractJsonFromString('No JSON here');
+ */
+declare function extractJsonFromString(content: string): any;
+/**
+ * Transforms a camelCase string into a string with spaces between words,
+ * with the first letter of each word capitalized.
+ * e.g., "camelCaseString" becomes "Camel Case String"
+ * e.g., "characterDescription" becomes "Character Description"
+ *
+ * @param input The camelCase string to transform.
+ * @returns The transformed string with spaces and capitalized words.
+ */
+declare function formatCamelCaseString(input: string): string;
+
+declare class GetPathPipe implements PipeTransform {
+    transform(obj: any, column: PColumn): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetPathPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GetPathPipe, "getPath", true>;
+}
+
+interface ConfirmOptions {
+    title?: string;
+    message?: string;
+    acceptText?: string;
+    cancelText?: string;
+    warning?: string;
+    oneBotton?: boolean;
+    piIcon?: string;
+}
+declare class ConfirmService {
+    pdialogService: DialogService;
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
+    openConfirm(title?: string, message?: string, acceptText?: string): rxjs.Observable<any>;
+    confirm(options: ConfirmOptions): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmService>;
+}
+
+interface PromptOptions {
+    title?: string;
+    message?: string;
+    acceptText?: string;
+    cancelText?: string;
+    initialValue?: string;
+}
+declare class PromptService {
+    private readonly dialogService;
+    /**
+     * Opens a prompt dialog.
+     * @param options Configuration options for the prompt dialog.
+     * @returns A promise that resolves with the input value if accepted, or null if canceled.
+     */
+    openPrompt(options: PromptOptions): Promise<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PromptService>;
+}
+
+declare class UiStateService {
+    chatDrawerVisible: WritableSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiStateService>;
+}
+
+interface ILangTranslation {
+    en: string;
+    es: string;
+}
+declare const SUPPORTED_LANGUAGES: string[];
+interface ILanguageData {
+    nativeName: string;
+    flag: string;
+    code: string;
+    i: number;
+    llmKnowledge: number;
+    countries: string[];
+    translations: ILangTranslation;
+    flagImg?: string;
+    status: 'ready' | 'commingsoon' | 'almostready';
+    speakers: number;
+}
+declare const LANGUAGES: Record<string, ILanguageData>;
+declare function getLangDesc(langCode: string, lang: string): string;
+declare function getSupportedLanguageOptions(lang?: 'es' | 'en'): {
+    value: string;
+    label: string;
+}[];
+
+declare const MoodStateOptions: {
+    value: string;
+    label: string;
+    emoji: string;
+}[];
+
+export { AudioSpeed, AudioSpeedReverse, ChatUserSettings, ConfirmComponent, ConfirmService, DCFilterBarComponent, DCProgressToastComponent, DcAuditableViewerComponent, DcExtensionsViewerComponent, DcLearnableViewerComponent, DcManageableViewerComponent, DcReactionsViewerComponent, EModelQuality, EmptyStateComponent, EntityBaseFormComponent, EntityBaseListComponent, EntityCommunicationService, GetPathPipe, HTTP_CORE_CONFIG, HttpCoreService, IAIModel, LANGUAGES, LoadingBarComponent, LoadingBarService, ModelQualityOptions, MoodStateOptions, OptionValue, PaginationBase, PromptService, QuickTableComponent, SUPPORTED_LANGUAGES, TOAST_ALERTS_TOKEN, ToastAlertsAbstractService, UiStateService, availibleFilters, extractJsonFromString, formatCamelCaseString, getLangDesc, getSupportedLanguageOptions, provideToastAlert, sortOptions, sortTypes };
+export type { ConfirmOptions, DeletedData, FiltersConfig, HttpCoreConfig, HttpCoreError, IAuditable, ICustomFilter, IExtensionable, IFilterQueryResponse, ILangTranslation, ILanguageData, ILearnable, IManageable, IReactable, ListFilterBarOptions, OnActionEvent, PColumn, PromptOptions, SortOption, ToastData };