import * as i0 from '@angular/core'; import { InjectionToken, OnInit, EventEmitter, ElementRef, PipeTransform, Signal, WritableSignal, ComponentFactoryResolver, ApplicationRef, Injector, ComponentRef, ModuleWithProviders } from '@angular/core'; import { Router, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router'; import * as _angular_platform_browser from '@angular/platform-browser'; import { Meta, Title, DomSanitizer } from '@angular/platform-browser'; import { Observable } from 'rxjs'; import { HttpErrorResponse, HttpClient } from '@angular/common/http'; import * as i13 from '@angular/common'; import { DatePipe } from '@angular/common'; import * as i14 from '@angular/forms'; interface Any { [key: string]: string; } interface Config { meta?: { useTitleSuffix?: boolean; warnMissingGuard?: boolean; defaults?: { title?: string; titleSuffix?: string; } & { [key: string]: string | undefined; }; }; alert?: { alerts?: object; text?: string; type?: string; icon?: string; class?: string; unique?: string; progress?: boolean; position?: string; timeout?: number; close?: any; buttons?: any; }; modal?: { size?: any; timeout?: any; timestart?: any; class?: string; modals?: object; position?: string; closable?: boolean; unique?: string; }; popup?: { popups?: object; }; loader?: { loaders?: object; }; socket?: any; io?: any; http?: { headers?: any; url?: string; }; store?: { prefix?: string; set?: (hold: any, value: any, cb?: () => void, errCb?: () => void) => Promise; get?: (hold: any, cb?: (value: string) => void, errCb?: () => void) => Promise; remove?: (hold: any, cb?: () => void, errCb?: () => void) => Promise; clear?: (cb?: () => void, errCb?: () => void) => Promise; }; } declare const CONFIG_TOKEN: InjectionToken; declare const DEFAULT_CONFIG: Config; interface Alert { onClose?: any; alerts?: object; component?: any; text?: string; icon?: string; type?: string; class?: string; unique?: string; progress?: boolean; position?: string; timeout?: any; closable?: boolean; close?: any; buttons?: any; [x: string]: any; } declare const DEFAULT_Alert: Alert; interface Modal { onOpen?: any; onClose?: any; onClickOutside?: any; id?: number; close?: any; component?: any; size?: any; timeout?: any; timestart?: any; class?: string; modals?: object; position?: string; closable?: boolean; unique?: string; [x: string]: any; } declare const DEFAULT_Modal: Modal; interface CrudDocument { _id: string; appId?: string; order?: number; __created?: boolean; __modified?: boolean; } interface CrudOptions { name?: string; alert?: string; callback?: (resp: Document | Document[]) => void; errCallback?: (resp: unknown) => void; } interface CrudServiceInterface { get: (params: { page: number; }, options: CrudOptions) => any; getDocs: () => Document[]; create: (doc: Document) => any; update: (doc: Document) => any; delete: (doc: Document) => any; setPerPage?: (count: number) => void; loaded: Promise; } interface TableConfig { paginate?: (page?: number) => void; perPage?: number; setPerPage?: ((count: number) => void) | undefined; allDocs?: boolean; create: (() => void) | null; update: ((doc: Document) => void) | null; delete: ((doc: Document) => void) | null; buttons: ({ icon?: string; click?: (doc: Document) => void; hrefFunc?: (doc: Document) => string; } | null)[]; headerButtons: ({ icon?: string; click?: () => void; hrefFunc?: (doc: Document) => string; class?: string; } | null)[]; } declare class MetaService { private router; private meta; private titleService; private config; private _meta; constructor(router: Router, meta: Meta, titleService: Title, config: Config); /** * Sets the default meta tags. * * @param defaults - The default meta tags. */ setDefaults(defaults: { [key: string]: string; }): void; /** * Sets the title and optional title suffix. * * @param title - The title to set. * @param titleSuffix - The title suffix to append. * @returns The MetaService instance. */ setTitle(title?: string, titleSuffix?: string): MetaService; /** * Sets link tags. * * @param links - The links to set. * @returns The MetaService instance. */ setLink(links: { [key: string]: string; }): MetaService; /** * Sets a meta tag. * * @param tag - The meta tag name. * @param value - The meta tag value. * @param prop - The meta tag property. * @returns The MetaService instance. */ setTag(tag: string, value: string, prop?: string): MetaService; /** * Updates a meta tag. * * @param tag - The meta tag name. * @param value - The meta tag value. * @param prop - The meta tag property. */ private _updateMetaTag; /** * Removes a meta tag. * * @param tag - The meta tag name. * @param prop - The meta tag property. */ removeTag(tag: string, prop?: string): void; /** * Warns about missing meta guards in routes. */ private _warnMissingGuard; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class MetaGuard { private metaService; private config; static IDENTIFIER: string; private _meta; constructor(metaService: MetaService, config: Config); canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean; private _processRouteMetaTags; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class AlertComponent { alert: any; component: any; text: string; class: string; type: string; progress: boolean; position: string; icon: string; timeout: any; close: any; closable: any; buttons: any; constructor(); delete_animation: boolean; remove(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class ModalComponent implements OnInit { class: string; size: string; closable: boolean; close: any; onOpen: any; timestart: any; timeout: any; showModal: boolean; allowClose: boolean; onClickOutside: any; ngOnInit(): void; ngAfterViewInit(): void; ngOnDestroy(): void; popStateListener(e: Event): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class LoaderComponent { loader: any; text: string; class: string; progress: boolean; timeout: number; close: any; closable: any; constructor(); ngOnInit(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } /** * BaseComponent is an abstract class that provides basic functionality for managing the current timestamp. */ declare abstract class BaseComponent { /** * The current timestamp in milliseconds since the Unix epoch. */ now: number; /** * Refreshes the `now` property with the current timestamp. */ refreshNow(): void; } /** * Abstract reusable base class for CRUD list views. * It encapsulates pagination, modals, and document handling logic. * * @template Service - A service implementing CrudServiceInterface for a specific document type * @template Document - The data model extending CrudDocument */ declare abstract class CrudComponent, Document extends CrudDocument, FormInterface> { protected formService: unknown; protected translate: { translate: (key: string) => string; }; /** Service responsible for data fetching, creating, updating, deleting */ protected service: Service; /** The array of documents currently loaded and shown */ protected documents: Document[]; /** The reactive form instance generated from the provided config */ protected form: any; /** Current pagination page */ protected page: number; /** CoreService handles timing and copying helpers */ private __core; /** AlertService handles alerts */ private __alert; /** ChangeDetectorRef handles on push strategy */ private __cdr; /** Internal reference to form service matching FormServiceInterface */ private __form; /** * Constructor * * @param formConfig - Object describing form title and its component structure * @param formService - Any service that conforms to FormServiceInterface (usually casted) * @param translate - An object providing a translate() method for i18n * @param service - CRUD service implementing get/create/update/delete */ constructor(formConfig: unknown, formService: unknown, translate: { translate: (key: string) => string; }, service: Service, module?: string); /** * Loads documents for a given page. */ protected setDocuments(page?: number): Promise; protected updatableFields: string[]; /** * Clears temporary metadata before document creation. */ protected preCreate(doc: Document): void; /** * Funciton which controls whether the create functionality is available. */ protected allowCreate(): boolean; /** * Funciton which controls whether the update and delete functionality is available. */ protected allowMutate(): boolean; /** * Funciton which controls whether the unique url functionality is available. */ protected allowUrl(): boolean; protected allowSort(): boolean; /** * Funciton which prepare get crud options. */ protected getOptions(): CrudOptions; /** * Handles bulk creation and updating of documents. * In creation mode, adds new documents. * In update mode, syncs changes and deletes removed entries. */ protected bulkManagement(create?: boolean): () => void; protected configType: 'server' | 'local'; protected perPage: number; /** * Configuration object used by the UI for rendering table and handling actions. */ protected getConfig(): TableConfig; private _module; } declare class ClickOutsideDirective { private elementRef; clickOutside: EventEmitter; constructor(elementRef: ElementRef); onClick(event: Event): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } declare class ArrPipe implements PipeTransform { transform(data: any, type?: any, refresh?: any): any; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class MongodatePipe implements PipeTransform { transform(_id: any): Date; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class PaginationPipe implements PipeTransform { transform(arr: any, config: any, sort: any, search?: string): any; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class SafePipe { private sanitizer; constructor(sanitizer: DomSanitizer); transform(html: any): _angular_platform_browser.SafeResourceUrl; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class SearchPipe implements PipeTransform { private c; transform(given: any, s?: any, f?: any, l?: any, i?: any, reload?: any): any; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class SplicePipe implements PipeTransform { transform(from: any, which: any, refresh?: number): any; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class SplitPipe implements PipeTransform { transform(value: string, index?: number, devider?: string): unknown; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class NumberPipe implements PipeTransform { transform(value: unknown): number; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class BaseService { now: number; refreshNow(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } interface Selectitem { name: string; _id: string; } declare global { interface String { capitalize(): string; } } declare class CoreService { private platformId; deviceID: string; constructor(platformId: boolean); /** * Generates a UUID (Universally Unique Identifier) version 4. * * This implementation uses `Math.random()` to generate random values, * making it suitable for general-purpose identifiers, but **not** for * cryptographic or security-sensitive use cases. * * The format follows the UUID v4 standard: `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx` * where: * - `x` is a random hexadecimal digit (0–f) * - `4` indicates UUID version 4 * - `y` is one of 8, 9, A, or B * * Example: `f47ac10b-58cc-4372-a567-0e02b2c3d479` * * @returns A string containing a UUID v4. */ UUID(): string; /** * Converts an object to an array. Optionally holds keys instead of values. * * @param {any} obj - The object to be converted. * @param {boolean} [holder=false] - If true, the keys will be held in the array; otherwise, the values will be held. * @returns {any[]} The resulting array. */ ota(obj: any, holder?: boolean): any[]; /** * Removes elements from `fromArray` that are present in `removeArray` based on a comparison field. * * @param {any[]} removeArray - The array of elements to remove. * @param {any[]} fromArray - The array from which to remove elements. * @param {string} [compareField='_id'] - The field to use for comparison. * @returns {any[]} The modified `fromArray` with elements removed. */ splice(removeArray: any[], fromArray: any[], compareField?: string): any[]; /** * Unites multiple _id values into a single unique _id. * The resulting _id is unique regardless of the order of the input _id values. * * @param {...string[]} args - The _id values to be united. * @returns {string} The unique combined _id. */ ids2id(...args: string[]): string; private _afterWhile; /** * Delays the execution of a callback function for a specified amount of time. * If called again within that time, the timer resets. * * @param {string | object | (() => void)} doc - A unique identifier for the timer, an object to host the timer, or the callback function. * @param {() => void} [cb] - The callback function to execute after the delay. * @param {number} [time=1000] - The delay time in milliseconds. */ afterWhile(doc: string | object | (() => void), cb?: () => void, time?: number): void; /** * Recursively copies properties from one object to another. * Handles nested objects, arrays, and Date instances appropriately. * * @param from - The source object from which properties are copied. * @param to - The target object to which properties are copied. */ copy(from: any, to: any): void; device: string; /** * Detects the device type based on the user agent. */ detectDevice(): void; /** * Checks if the device is a mobile device. * @returns {boolean} - Returns true if the device is a mobile device. */ isMobile(): boolean; /** * Checks if the device is a tablet. * @returns {boolean} - Returns true if the device is a tablet. */ isTablet(): boolean; /** * Checks if the device is a web browser. * @returns {boolean} - Returns true if the device is a web browser. */ isWeb(): boolean; /** * Checks if the device is an Android device. * @returns {boolean} - Returns true if the device is an Android device. */ isAndroid(): boolean; /** * Checks if the device is an iOS device. * @returns {boolean} - Returns true if the device is an iOS device. */ isIos(): boolean; version: string; appVersion: string; dateVersion: string; /** * Sets the combined version string based on appVersion and dateVersion. */ setVersion(): void; /** * Sets the app version and updates the combined version string. * * @param {string} appVersion - The application version to set. */ setAppVersion(appVersion: string): void; /** * Sets the date version and updates the combined version string. * * @param {string} dateVersion - The date version to set. */ setDateVersion(dateVersion: string): void; private _signals; /** * Emits a signal, optionally passing data to the listeners. * @param signal - The name of the signal to emit. * @param data - Optional data to pass to the listeners. */ emit(signal: string, data?: any): void; /** * Returns an Observable that emits values when the specified signal is emitted. * Multiple components or services can subscribe to this Observable to be notified of the signal. * @param signal - The name of the signal to listen for. * @returns An Observable that emits when the signal is emitted. */ on(signal: string): Observable; /** * Completes the Subject for a specific signal, effectively stopping any future emissions. * This also unsubscribes all listeners for the signal. * @param signal - The name of the signal to stop. */ off(signal: string): void; private _completed; private _completeResolvers; /** * Marks a task as complete. * @param task - The task to mark as complete, identified by a string. */ complete(task: string, document?: unknown): void; /** * Waits for one or more tasks to be marked as complete. * * @param {string | string[]} tasks - The task or array of tasks to wait for. * @returns {Promise} A promise that resolves when all specified tasks are complete. * - If a single task is provided, resolves with its completion result. * - If multiple tasks are provided, resolves with an array of results in the same order. * * @remarks * If any task is not yet completed, a resolver is attached. The developer is responsible for managing * resolver cleanup if needed. Resolvers remain after resolution and are not removed automatically. */ onComplete(tasks: string | string[]): Promise; /** * Returns a resolver function that checks if all given tasks are completed, * and if so, calls the provided resolve function with their results. * * @param {string[]} tasks - The list of task names to monitor for completion. * @param {(value: unknown) => void} resolve - The resolver function to call once all tasks are complete. * @returns {(doc: unknown) => void} A function that can be registered as a resolver for each task. * * @remarks * This function does not manage or clean up resolvers. It assumes the developer handles any potential duplicates or memory concerns. */ private _allCompleted; /** * Checks whether all specified tasks have been marked as completed. * * @param {string[]} tasks - The array of task names to check. * @returns {boolean} `true` if all tasks are completed, otherwise `false`. */ private _isCompleted; /** * Checks if a task is completed. * @param task - The task to check, identified by a string. * @returns True if the task is completed, false otherwise. */ completed(task: string): unknown; /** * Clears the completed state for a specific task. * * This removes the task from the internal `_completed` store, * allowing it to be awaited again in the future if needed. * It does not affect pending resolvers or trigger any callbacks. * * @param task - The task identifier to clear from completed state. */ clearCompleted(task: string): void; private _locked; private _unlockResolvers; /** * Locks a resource to prevent concurrent access. * @param which - The resource to lock, identified by a string. */ lock(which: string): void; /** * Unlocks a resource, allowing access. * @param which - The resource to unlock, identified by a string. */ unlock(which: string): void; /** * Returns a Promise that resolves when the specified resource is unlocked. * @param which - The resource to watch for unlocking, identified by a string. * @returns A Promise that resolves when the resource is unlocked. */ onUnlock(which: string): Promise; /** * Checks if a resource is locked. * @param which - The resource to check, identified by a string. * @returns True if the resource is locked, false otherwise. */ locked(which: string): boolean; linkCollections: string[]; linkRealCollectionName: Record; linkIds: Record; addLink(name: string, reset: () => Selectitem[], realName?: string): void; /** * Converts a plain object into a signal-wrapped object. * Optionally wraps specific fields of the object as individual signals, * and merges them into the returned signal for fine-grained reactivity. * * @template Document - The type of the object being wrapped. * @param {Document} document - The plain object to wrap into a signal. * @param {Record unknown>} [signalFields={}] - * Optional map where each key is a field name and the value is a function * to extract the initial value for that field. These fields will be wrapped * as separate signals and embedded in the returned object. * * @returns {Signal} A signal-wrapped object, possibly containing * nested field signals for more granular control. * * @example * const user = { _id: '1', name: 'Alice', score: 42 }; * const sig = toSignal(user, { score: (u) => u.score }); * console.log(sig().name); // 'Alice' * console.log(sig().score()); // 42 — field is now a signal */ toSignal(document: Document, signalFields?: Record unknown>): Signal; /** * Converts an array of objects into an array of Angular signals. * Optionally wraps specific fields of each object as individual signals. * * @template Document - The type of each object in the array. * @param {Document[]} arr - Array of plain objects to convert into signals. * @param {Record unknown>} [signalFields={}] - * Optional map where keys are field names and values are functions that extract the initial value * from the object. These fields will be turned into separate signals. * * @returns {Signal[]} An array where each item is a signal-wrapped object, * optionally with individual fields also wrapped in signals. * * @example * toSignalsArray(users, { * name: (u) => u.name, * score: (u) => u.score, * }); */ toSignalsArray(arr: Document[], signalFields?: Record unknown>): Signal[]; /** * Adds a new object to the signals array. * Optionally wraps specific fields of the object as individual signals before wrapping the whole object. * * @template Document - The type of the object being added. * @param {Signal[]} signals - The signals array to append to. * @param {Document} item - The object to wrap and push as a signal. * @param {Record unknown>} [signalFields={}] - * Optional map of fields to be wrapped as signals within the object. * * @returns {void} */ pushSignal(signals: Signal[], item: Document, signalFields?: Record unknown>): void; /** * Removes the first signal from the array whose object's field matches the provided value. * @template Document * @param {WritableSignal[]} signals - The signals array to modify. * @param {unknown} value - The value to match. * @param {string} [field='_id'] - The object field to match against. * @returns {void} */ removeSignalByField>(signals: WritableSignal[], value: unknown, field?: string): void; /** * Returns a generic trackBy function for *ngFor, tracking by the specified object field. * @template Document * @param {string} field - The object field to use for tracking (e.g., '_id'). * @returns {(index: number, sig: Signal) => unknown} TrackBy function for Angular. */ trackBySignalField>(field: string): (_: number, sig: Signal) => unknown; /** * Finds the first signal in the array whose object's field matches the provided value. * @template Document * @param {Signal[]} signals - Array of signals to search. * @param {unknown} value - The value to match. * @param {string} [field='_id'] - The object field to match against. * @returns {Signal | undefined} The found signal or undefined if not found. */ findSignalByField>(signals: Signal[], value: unknown, field?: string): Signal | undefined; /** * Updates the first writable signal in the array whose object's field matches the provided value. * @template Document * @param {WritableSignal[]} signals - Array of writable signals to search. * @param {unknown} value - The value to match. * @param {(val: Document) => Document} updater - Function to produce the updated object. * @param {string} field - The object field to match against. * @returns {void} */ updateSignalByField>(signals: WritableSignal[], value: unknown, updater: (val: Document) => Document, field: string): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class StoreService { private config; private core; private _prefix; constructor(config: Config, core: CoreService); /** * Sets the prefix for storage keys. * * @param prefix - The prefix to set. */ setPrefix(prefix: string): void; /** * Sets a value in storage. * * @param key - The storage key. * @param value - The value to store. * @param callback - The callback to execute on success. * @param errCallback - The callback to execute on error. */ set(key: string, value: string, callback?: () => void, errCallback?: () => void): void; /** * Sets a value in storage asynchronously. * * @param key - The storage key. * @param value - The value to store. * @returns A promise that resolves to a boolean indicating success. */ setAsync(key: string, value: string): Promise; /** * Gets a value from storage. * * @param key - The storage key. * @param callback - The callback to execute with the retrieved value. * @param errCallback - The callback to execute on error. */ get(key: string, callback?: (value: string) => void, errCallback?: () => void): void; /** * Gets a value from storage asynchronously. * * @param key - The storage key. * @returns A promise that resolves to the retrieved value. */ getAsync(key: string): Promise; /** * Sets a JSON value in storage. * * @param key - The storage key. * @param value - The value to store. * @param callback - The callback to execute on success. * @param errCallback - The callback to execute on error. */ setJson(key: string, value: any, callback?: () => void, errCallback?: () => void): void; /** * Sets a JSON value in storage asynchronously. * * @param key - The storage key. * @param value - The value to store. * @returns A promise that resolves to a boolean indicating success. */ setJsonAsync(key: string, value: any): Promise; /** * Gets a JSON value from storage. * * @param key - The storage key. * @param callback - The callback to execute with the retrieved value. * @param errCallback - The callback to execute on error. */ getJson(key: string, callback?: (value: any) => void, errCallback?: () => void): void; /** * Gets a JSON value from storage asynchronously. * * @param key - The storage key. * @returns A promise that resolves to the retrieved value. */ getJsonAsync(key: string): Promise; /** * Removes a value from storage. * * @param key - The storage key. * @param callback - The callback to execute on success. * @param errCallback - The callback to execute on error. * @returns A promise that resolves to a boolean indicating success. */ remove(key: string, callback?: () => void, errCallback?: () => void): Promise; /** * Clears all values from storage. * * @param callback - The callback to execute on success. * @param errCallback - The callback to execute on error. * @returns A promise that resolves to a boolean indicating success. */ clear(callback?: () => void, errCallback?: () => void): Promise; /** * Applies the configured prefix to a storage key. * * @param key - The storage key. * @returns The prefixed storage key. */ private applyPrefix; /** * Checks if a value exists in storage. * * This function checks whether a value is present for the given key in the storage. * It uses the configured storage mechanism if available; otherwise, it defaults to using `localStorage`. * * @param key - The storage key to check. * @returns A promise that resolves to `true` if the value exists, otherwise `false`. * * @example * const store = new StoreService(config, core); * * // Set a value and check if it exists * await store.setAsync('exampleKey', 'exampleValue'); * const exists = await store.has('exampleKey'); * console.log(exists); // Output: true * * @notes * - This method internally uses `getAsync` to retrieve the value and checks if it is not null or empty. * - An empty string value will still return `true` as the key exists in storage. */ has(key: string): Promise; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class HttpService { private store; private http; private _config; errors: ((err: HttpErrorResponse, retry?: () => void) => {})[]; url: string; locked: boolean; awaitLocked: any[]; private _http; private _headers; private _http_headers; constructor(store: StoreService, http: HttpClient, _config: Config); setUrl(url: string): void; removeUrl(): void; set(key: any, value: any): void; header(key: any): any; remove(key: any): void; private _httpMethod; /** * Internal method to handle HTTP requests for various methods (POST, PUT, PATCH, DELETE, GET). * * Features: * - **Request Locking**: Manages request locking to prevent simultaneous requests. * - **Acceptance Check**: Validates the server response against a user-defined `acceptance` function. * If the check fails, the response is rejected with an error. * - **Replace Logic**: Allows modification of specific parts of the response object, determined by a user-defined `replace` function. * Can handle both objects and arrays within the response. * - **Field Filtering**: Supports extracting specific fields from response objects or arrays. * - **Legacy Support**: Compatible with callback-based usage alongside Observables. * - **ReplaySubject**: Ensures that the response can be shared across multiple subscribers. * * @param url - The endpoint to send the HTTP request to (relative to the base URL). * @param doc - The request payload for methods like POST, PUT, and PATCH. * @param callback - A legacy callback function to handle the response. * @param opts - Additional options: * - `err`: Error handling callback. * - `acceptance`: Function to validate the server response. Should return `true` for valid responses. * - `replace`: Function to modify specific parts of the response data. * - `fields`: Array of fields to extract from the response object(s). * - `data`: Path in the response where the data resides for `replace` and `fields` operations. * - `skipLock`: If `true`, bypasses request locking. * - `url`: Overrides the base URL for this request. * @param method - The HTTP method (e.g., 'post', 'put', 'patch', 'delete', 'get'). * @returns An Observable that emits the processed HTTP response or an error. */ private _post; /** * Public method to perform a POST request. * - Supports legacy callback usage. * - Returns an Observable for reactive programming. */ post(url: string, doc: any, callback?: (resp: any) => void, opts?: any): Observable; /** * Public method to perform a PUT request. * - Supports legacy callback usage. * - Returns an Observable for reactive programming. */ put(url: string, doc: any, callback?: (resp: any) => void, opts?: any): Observable; /** * Public method to perform a PATCH request. * - Supports legacy callback usage. * - Returns an Observable for reactive programming. */ patch(url: string, doc: any, callback?: (resp: any) => void, opts?: any): Observable; /** * Public method to perform a DELETE request. * - Supports legacy callback usage. * - Returns an Observable for reactive programming. */ delete(url: string, callback?: (resp: any) => void, opts?: any): Observable; /** * Public method to perform a GET request. * - Supports legacy callback usage. * - Returns an Observable for reactive programming. */ get(url: string, callback?: (resp: any) => void, opts?: any): Observable; clearLocked(): void; lock(): void; unlock(): void; /** * Handles HTTP errors. * - Calls provided error callback and retries the request if needed. */ private handleError; /** * Internal method to trigger error handling callbacks. */ private err_handle; private prepare_handle; private response_handle; /** * Retrieves a nested object or property from the response based on a dot-separated path. * * @param resp - The response object to retrieve data from. * @param base - A dot-separated string indicating the path to the desired property within the response. * - Example: `'data.items'` will navigate through `resp.data.items`. * - If empty, the entire response is returned. * @returns The object or property located at the specified path within the response. */ private _getObjectToReplace; /** * Sets or replaces a nested object or property in the response based on a dot-separated path. * * @param resp - The response object to modify. * @param base - A dot-separated string indicating the path to the property to replace. * - Example: `'data.items'` will navigate through `resp.data.items`. * @param doc - The new data or object to set at the specified path. * @returns `void`. */ private _setObjectToReplace; /** * Creates a new object containing only specified fields from the input item. * * @param item - The input object to extract fields from. * @param fields - An array of field names to include in the new object. * - Example: `['id', 'name']` will create a new object with only the `id` and `name` properties from `item`. * @returns A new object containing only the specified fields. */ private _newDoc; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class DomService { private componentFactoryResolver; private appRef; private injector; private providedIn; constructor(componentFactoryResolver: ComponentFactoryResolver, appRef: ApplicationRef, injector: Injector); /** * Appends a component to a specified element by ID. * * @param component - The component to append. * @param options - The options to project into the component. * @param id - The ID of the element to append the component to. * @returns An object containing the native element and the component reference. */ appendById(component: any, options: any | undefined, id: string): { nativeElement: HTMLElement; componentRef: ComponentRef; }; /** * Appends a component to a specified element or to the body. * * @param component - The component to append. * @param options - The options to project into the component. * @param element - The element to append the component to. Defaults to body. * @returns An object containing the native element and the component reference. */ appendComponent(component: any, options?: any, element?: HTMLElement): { nativeElement: HTMLElement; componentRef: ComponentRef; } | void; /** * Gets a reference to a dynamically created component. * * @param component - The component to create. * @param options - The options to project into the component. * @returns The component reference. */ getComponentRef(component: any, options?: any): ComponentRef; /** * Projects the inputs onto the component. * * @param component - The component reference. * @param options - The options to project into the component. * @returns The component reference with the projected inputs. */ private projectComponentInputs; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class AlertService { private dom; private config; private alert; private _container; constructor(dom: DomService, config: Config); private uniques; private shortcuts; private positionNumber; show(opts: any | Alert): any; open(opts: Alert): void; info(opts: Alert): void; success(opts: Alert): void; warning(opts: Alert): void; error(opts: Alert): void; question(opts: Alert): void; destroy(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } interface CrudConfig { signalFields?: Record unknown>; name: string; _id?: string; replace?: (doc: Document) => void; unauthorized?: boolean; appId?: string; } interface GetConfig { page?: number; perPage?: number; query?: string; } /** * Abstract class representing a CRUD (Create, Read, Update, Delete) service. * * This class provides methods for managing documents, interacting with an API, * and storing/retrieving data from local storage. It is designed to be extended * for specific document types. * * @template Document - The type of the document the service handles. */ declare abstract class CrudService extends BaseService { private _config; /** * URL for the API. */ private _url; /** * Array of documents managed by this service. */ private _docs; /** * Number of documents per page. */ private _perPage; /** * Callbacks for filtering documents. */ private _filteredDocumentsCallbacks; /** * Constructs a CRUD service instance. * * @param _config - Configuration options for the CRUD service. * @param __http - Service to handle HTTP requests. * @param __store - Service to manage local storage of documents. * @param __alert - Service to display alerts. * @param __core - Core service for utility functions. */ protected __http: HttpService; protected __store: StoreService; protected __alert: AlertService; protected __core: CoreService; loaded: Promise; constructor(_config: CrudConfig); restoreDocs(): void; /** * Saves the current set of documents to local storage. */ setDocs(): void; /** * Retrieves the current list of documents. * * @returns The list of documents. */ getDocs(): Document[]; /** * Clears the current list of documents. * * Empties the internal documents array and saves the updated state to local storage. */ clearDocs(): void; /** * Adds multiple documents to the service and saves them to local storage. * * @param docs - An array of documents to add. */ addDocs(docs: Document[]): void; /** * Adds a single document to the service. If it already exists, it will be updated. * * @param doc - The document to add. */ addDoc(doc: Document): void; /** * Creates a new document with a temporary ID and status flags. * * @param doc - Optional base document to use for the new document. * @returns A new document instance with default properties. */ new(doc?: Document): Document; /** * Retrieves a document by its unique ID or creates a new one if it doesn't exist. * * @param _id - The document ID to search for. * @returns The found document or a new document if not found. */ doc(_id: string): Document; /** * Sets the number of documents to display per page. * * @param _perPage - Number of documents per page. */ setPerPage(_perPage: number): void; /** * Fetches a list of documents from the API with optional pagination. * * @param config - Optional pagination configuration. * @param options - Optional callback and error handling configuration. * @returns An observable that resolves with the list of documents. */ get(config?: GetConfig, options?: CrudOptions): Observable; /** * Sends a request to the API to create a new document. * * @param doc - The document to create. * @param options - Optional callback and error handling configuration. * @returns An observable that resolves with the created document, or emits an error if already created. */ create(doc?: Document, options?: CrudOptions): Observable; /** * Fetches a document from the API based on a query. * * @param query - The query object used to filter documents. * @param options - Optional callback and error handling configuration. * @returns An observable that resolves with the fetched document. */ fetch(query?: object, options?: CrudOptions): Observable; /** * Updates a document after a specified delay and returns an observable. * * @param doc - The document to update. * @param options - Optional callback and error handling configuration. * @returns An observable that emits the updated document. */ updateAfterWhile(doc: Document, options?: CrudOptions): Observable; /** * Updates a document in the API. * * @param doc - The document to update. * @param options - Optional callback and error handling configuration. * @returns An observable that resolves with the updated document. */ update(doc: Document, options?: CrudOptions): Observable; /** * Unique update a document field in the API. * * @param doc - The document to update. * @param options - Optional callback and error handling configuration. * @returns An observable that resolves with the updated document. */ unique(doc: Document, options?: CrudOptions): Observable; /** * Deletes a document from the API. * * @param doc - The document to delete. * @param options - Optional callback and error handling configuration. * @returns An observable that resolves with the deleted document. */ delete(doc: Document, options?: CrudOptions): Observable; /** * Filters documents based on specific conditions and stores the result in a provided object. * * @param storeObject - Object to store filtered documents. * @param field - The field to filter by or a function to extract the field. * @param valid - Optional function to check the validity of a document. * @param sort - Function to sort the filtered documents. * @returns A callback function that triggers the filtering process. */ filteredDocuments(storeObject: Record, field?: string | ((doc: Document) => string), valid?: (doc: Document) => boolean, sort?: (a: Document, b: Document) => number): () => void; /** * Generates a unique ID for a document. * * @param doc - The document for which to generate the ID. * @returns The unique ID as a string. */ private _id; /** * Executes all registered filter document callbacks. */ private _filterDocuments; private _fetchingId; } declare class MongoService { private store; private http; private core; private data; private socket; config(part: any, opts: any): { arr: any; obj: any; } | undefined; create(part: any, doc?: any, cb?: any, opts?: any): void; fetch(part: any, opts?: any, cb?: any): any; get(part: any, opts?: any, cb?: any): any; set(part: any, opts?: any, resp?: any): { arr: any; obj: any; }; private prepare_update; update(part: any, doc: any, opts?: any, cb?: any): void; unique(part: any, doc: any, opts?: any, cb?: any): void; delete(part: any, doc: any, opts?: any, cb?: any): void; _id(cb: any): void; to_id(docs: any): any; afterWhile(doc: any, cb: any, time?: number): void; populate(doc: any, field: any, part: any): any; on(parts: any, cb: any): any; track(index: any, doc: any): any; sortAscId(): (a: any, b: any) => 1 | -1; sortDescId(): (a: any, b: any) => 1 | -1; sortAscString(opts: any): (a: any, b: any) => any; sortDescString(opts: any): (a: any, b: any) => any; sortAscDate(opts: any): (a: any, b: any) => any; sortDescDate(opts: any): (a: any, b: any) => any; sortAscNumber(opts: any): (a: any, b: any) => any; sortDescNumber(opts: any): (a: any, b: any) => any; sortAscBoolean(opts: any): (a: any, b: any) => any; sortDescBoolean(opts: any): (a: any, b: any) => any; beArr(val: any, cb: any): void; beObj(val: any, cb: any): void; beDate(val: any, cb: any): void; beString(val: any, cb: any): void; beDoc: (val: any, cb: any) => void; forceArr(val: any, cb: any): void; forceObj(val: any, cb: any): void; forceString(val: any, cb: any): void; forceDoc: (val: any, cb: any) => void; getCreated(val: any, cb: any, doc: any): void; private replace; renew(part: any, doc: any): any; push(part: any, doc: any): any; remove(part: any, doc: any): void; constructor(store: StoreService, http: HttpService, core: CoreService); static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class RenderService { /** * A dictionary to store event callbacks. * Each event has an array of callback functions that will be executed when the event is triggered. */ private _pipes; /** * Registers a callback function to an event. * * @param event - The name of the event to listen for. * @param cb - The callback function to execute when the event is triggered. * @returns A function to unregister the callback from the event. */ on(event: string, cb: () => void): () => void; /** * Triggers an event and executes all registered callback functions for that event. * * @param event - The name of the event to trigger. * @param param - An optional parameter to pass to the callback functions. */ render(event?: string, param?: unknown): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class HashService { private replacements; hash: { [key: string]: string; }; private done; constructor(); /** * Initializes the hash service by loading the current hash from the URL. */ private initialize; /** * Loads the current hash from the URL into the hash object. */ private load; /** * Applies replacements to a given string based on the replacements array. * * @param str - The string to apply replacements to. * @returns The string with replacements applied. */ private applyReplacements; /** * Executes a callback with the value of a specific hash field once the hash is loaded. * * @param field - The hash field to get the value for. * @param cb - The callback to execute with the value. */ on(field: string, cb: (value: string) => void): void; /** * Saves the current hash object to the URL. */ save(): void; /** * Sets a value for a specific hash field and updates the URL. * * @param field - The hash field to set the value for. * @param value - The value to set. */ set(field: string, value: string): void; /** * Gets the value of a specific hash field. * * @param field - The hash field to get the value for. * @returns The value of the hash field. */ get(field: string): string | undefined; /** * Clears a specific hash field or all hash fields and updates the URL. * * @param field - The hash field to clear. If not provided, clears all hash fields. */ clear(field?: string): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class LoaderService { private dom; private config; loaders: any; constructor(dom: DomService, config: Config); show(opts?: any): any; destroy(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class SocketService { private _config; private _core; private _url; private _io; private _connected; private _opts; constructor(_config: Config, _core: CoreService); /** * Sets the URL for the WebSocket connection and reloads the socket. * @param url - The URL of the WebSocket server. */ setUrl(url: string): void; /** * Loads and initializes the WebSocket connection. */ private load; /** * Subscribes to a WebSocket event. * @param to - The event to subscribe to. * @param cb - The callback function to execute when the event is received. */ on(to: string, cb?: (message: any) => void): void; /** * Emits a message to a WebSocket event. * @param to - The event to emit the message to. * @param message - The message to emit. * @param room - Optional room to emit the message to. */ emit(to: string, message: any, room?: any): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class ModalService { private dom; private config; private _modal; constructor(dom: DomService, config: Config); show(opts: Modal | any): any; open(opts: Modal): void; small(opts: Modal): void; mid(opts: Modal): void; big(opts: Modal): void; full(opts: Modal): void; private opened; locked: boolean; destroy(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } interface FileOptions { id: string; type?: string; resize?: number | { width: number; height: number; }; multiple?: boolean; multiple_cb?: (files: { dataUrl: string; file: File; }[]) => void; cb?: (dataUrl: string | false, file: File) => void; save?: boolean; complete?: () => void; api?: string; part?: string; name?: string; body?: () => object | object; resp?: (response: any) => void; append?: (formData: FormData, files: File[]) => void; multiple_files?: { dataUrl: string; file: File; }[]; multiple_counter?: number; url?: string; } declare class FileService { private dom; private http; private added; private files; constructor(dom: DomService, http: HttpService); /** * Adds a file input configuration. * * @param opts - The file options. */ add(opts: FileOptions | string): void | (() => void); /** * Handles file input change event. * * @param event - The input change event. * @param info - The file options. */ change(event: Event, info: FileOptions): void; /** * Removes a file. * * @param part - The part of the API. * @param url - The URL of the file. * @param opts - Additional options. * @param cb - The callback function. */ remove(part: string, url: string, opts?: any, cb?: (resp: any) => void): void | (() => void); /** * Uploads files to the server. * * @param info - The file options. * @param files - The files to upload. * @param cb - The callback function. */ uploadFiles(info: FileOptions, files: File[], cb?: (resp: any) => void): void; /** * Uploads an image to the server. * * @param info - The file options. * @param cb - The callback function. */ image(info: FileOptions, cb?: (resp: any) => void): void | (() => void); /** * Updates the file information after processing. * * @param dataUrl - The data URL of the processed file. * @param info - The file options. * @param file - The file object. */ private update; /** * Processes an image file for resizing. * * @param file - The file object. * @param info - The file options. */ process(file: File, info: any): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class UiService { private variables; private _forms; var: Record; constructor(); /** * Manages form states. * * @param id - The form identifier. * @returns The form state object. */ form(id: string): any; /** * Validates input values based on the specified type. * * @param value - The value to validate. * @param kind - The type of validation. * @param extra - Additional validation criteria. * @returns True if the value is valid, false otherwise. */ valid(value: any, kind?: string, extra?: number): boolean; /** * Determines the strength of a password. * * @param value - The password to evaluate. * @returns The strength level of the password. */ level(value?: string): number; /** * Saves the CSS variables to local storage. */ private save; /** * Sets a CSS variable. * * @param key - The CSS variable name. * @param value - The CSS variable value. */ private setProperty; /** * Sets multiple CSS variables. * * @param variables - The CSS variables to set. * @param opts - Options for setting the variables. */ set(variables: { [key: string]: string; }, opts?: any): void; /** * Retrieves the stored CSS variables. * * @returns The stored CSS variables. */ get(): { [key: string]: string; }; /** * Removes specified CSS variables. * * @param keys - The keys of the CSS variables to remove. */ remove(keys: string | string[]): void; /** * Generates an array of sample data. * * @param arrLen - The length of the array. * @param type - The type of data to generate. * @returns An array of sample data. */ arr(arrLen?: number, type?: string): any[]; /** * Generates a random text string. * * @param length - The length of the text string. * @returns A random text string. */ text(length?: number): string; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class TimeService { private datePipe; private weekDays; constructor(datePipe: DatePipe); /** * Returns the name of the day of the week for a given date. * * @param date - The date for which to get the day of the week. * @param format - The format in which to return the day name. Default is 'long'. * @returns The name of the day of the week. */ getDayName(date: Date, format?: 'short' | 'long'): string; /** * Formats a date according to the specified format and timezone. * * @param date - The date to format. * @param format - The format string (see Angular DatePipe documentation for format options). * @param timezone - The timezone to use for formatting. * @returns The formatted date string. */ formatDate(date: Date, format?: string, timezone?: string): string; /** * Converts a date to a different timezone. * * @param date - The date to convert. * @param timezone - The timezone to convert to. * @returns The date in the new timezone. */ convertToTimezone(date: Date, timezone: string): Date; /** * Returns the start of the day for a given date. * * @param date - The date for which to get the start of the day. * @returns The start of the day (midnight) for the given date. */ startOfDay(date: Date): Date; /** * Returns the end of the day for a given date. * * @param date - The date for which to get the end of the day. * @returns The end of the day (one millisecond before midnight) for the given date. */ endOfDay(date: Date): Date; /** * Returns the number of days in a given month and year. * * @param month - The month (0-11). * @param year - The year. * @returns The number of days in the month. */ getDaysInMonth(month: number, year: number): number; /** * Checks if a given year is a leap year. * * @param year - The year to check. * @returns True if the year is a leap year, false otherwise. */ isLeapYear(year: number): boolean; /** * Adds a specified number of days to a date. * * @param date - The date to which to add days. * @param days - The number of days to add. * @returns The new date with the added days. */ addDays(date: Date, days: number): Date; /** * Adds a specified number of months to a date. * * @param date - The date to which to add months. * @param months - The number of months to add. * @returns The new date with the added months. */ addMonths(date: Date, months: number): Date; /** * Adds a specified number of years to a date. * * @param date - The date to which to add years. * @param years - The number of years to add. * @returns The new date with the added years. */ addYears(date: Date, years: number): Date; /** * Subtracts a specified number of days from a date. * * @param date - The date from which to subtract days. * @param days - The number of days to subtract. * @returns The new date with the subtracted days. */ subtractDays(date: Date, days: number): Date; /** * Subtracts a specified number of months from a date. * * @param date - The date from which to subtract months. * @param months - The number of months to subtract. * @returns The new date with the subtracted months. */ subtractMonths(date: Date, months: number): Date; /** * Subtracts a specified number of years from a date. * * @param date - The date from which to subtract years. * @param years - The number of years to subtract. * @returns The new date with the subtracted years. */ subtractYears(date: Date, years: number): Date; /** * Checks if two dates are on the same day. * * @param date1 - The first date. * @param date2 - The second date. * @returns True if the dates are on the same day, false otherwise. */ isSameDay(date1: Date, date2: Date): boolean; /** * Returns the ISO week number for a given date. * * @param date - The date for which to get the week number. * @returns The ISO week number (1-53). */ getWeekNumber(date: Date): number; /** * Returns the number of weeks in a month for a given month and year. * * @param month - The month (0-11). * @param year - The year. * @returns The number of weeks in the month. */ getWeeksInMonth(month: number, year: number): number; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } /** * RtcService handles WebRTC peer connections and local media stream setup. * It provides functionality to initialize the user's camera/microphone, * manage multiple peer connections, and handle offer/answer negotiation. */ declare class RtcService { /** * Map of peer connections, keyed by peer ID. */ private peers; /** * Local media stream from user's camera and microphone. */ private localStream; /** * Initializes the local media stream (audio/video). * Requests permissions and stores the stream internally. */ initLocalStream(): Promise; /** * Creates a new RTCPeerConnection for the given ID and attaches local tracks. */ createPeer(id: string): Promise; /** * Retrieves an existing peer connection by ID. */ getPeer(id: string): RTCPeerConnection | undefined; /** * Creates an SDP offer for the specified peer and sets it as the local description. */ createOffer(id: string): Promise; /** * Accepts an SDP offer, creates an answer, and sets it as the local description. */ createAnswer(id: string, offer: RTCSessionDescriptionInit): Promise; /** * Sets the remote description with an SDP answer for the given peer. */ setRemoteAnswer(id: string, answer: RTCSessionDescriptionInit): Promise; /** * Adds an ICE candidate to the specified peer connection. */ addIceCandidate(id: string, candidate: RTCIceCandidateInit): void; /** * Returns the initialized local media stream. */ getLocalStream(): MediaStream | null; /** * Closes a specific peer connection and removes it from the map. */ closePeer(id: string): void; /** * Closes all peer connections and stops the local media stream. */ closeAll(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class WrapperComponent { constructor(); static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class FilesComponent { fs: any; constructor(); static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class WacomModule { static forRoot(config?: Config): ModuleWithProviders; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵmod: i0.ɵɵNgModuleDeclaration; static ɵinj: i0.ɵɵInjectorDeclaration; } export { AlertComponent, AlertService, ArrPipe, BaseComponent, BaseService, CONFIG_TOKEN, ClickOutsideDirective, CoreService, CrudComponent, CrudService, DEFAULT_Alert, DEFAULT_CONFIG, DEFAULT_Modal, DomService, FileService, HashService, HttpService, LoaderComponent, LoaderService, MetaGuard, MetaService, ModalComponent, ModalService, MongoService, MongodatePipe, NumberPipe, PaginationPipe, RenderService, RtcService, SafePipe, SearchPipe, SocketService, SplicePipe, SplitPipe, StoreService, TimeService, UiService, WacomModule }; export type { Alert, Any, Config, CrudDocument, CrudOptions, CrudServiceInterface, Modal, TableConfig };