mk-ng-lib 0.0.1

package/index.d.ts

@@ -0,0 +1,587 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, ElementRef, OnDestroy, ChangeDetectorRef, Type, ViewContainerRef, AfterViewChecked, AfterContentInit, DoCheck, Renderer2, TrackByFunction, PipeTransform } from '@angular/core';
+import { FormGroup, AbstractControl, FormBuilder, FormControlName, ValidationErrors, FormGroupDirective } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import * as _angular_common_http from '@angular/common/http';
+import { HttpErrorResponse, HttpClient, HttpResponse } from '@angular/common/http';
+import { ToastrService } from 'ngx-toastr';
+import { Router, ActivatedRoute, Resolve, ActivatedRouteSnapshot, RouterStateSnapshot, CanActivateFn } from '@angular/router';
+import { FileUpload } from 'primeng/fileupload';
+import { Location } from '@angular/common';
+import { DynamicDialogRef, DynamicDialogConfig } from 'primeng/dynamicdialog';
+import { MenuItem, ConfirmationService, TreeNode } from 'primeng/api';
+import * as _angular_material_dialog from '@angular/material/dialog';
+import { MatDialogRef, MatDialog } from '@angular/material/dialog';
+import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+
+declare class NgCore {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgCore, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgCore, "lib-ng-core", never, {}, {}, never, never, true, never>;
+}
+
+interface TokenInterface {
+    token: string;
+}
+
+declare class EventEmitterService<T = unknown> {
+    private subjectComunicators;
+    private subscriptions;
+    constructor();
+    emit(eventName: string, data: T): void;
+    registerCallback(eventNames: string | string[], callback: (eventName: string, status: T) => void): void;
+    unregisterCallback(eventNames: string | string[], callback?: ((eventName: string, status: T) => void) | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventEmitterService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EventEmitterService<any>>;
+}
+
+declare class NotifierService {
+    private toastrService;
+    constructor(toastrService: ToastrService);
+    notify(message: string, type?: 'error' | 'success' | 'warning'): void;
+    success(message: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotifierService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotifierService>;
+}
+
+declare class HttpResponseToasterService {
+    private notifierService;
+    constructor(notifierService: NotifierService);
+    showError(error: string | HttpErrorResponse, codeStatus?: number, errorMessage?: string): void;
+    errorFromBlobResponseTYpe(error: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpResponseToasterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpResponseToasterService>;
+}
+
+interface NgCoreConfig {
+    backendUrl: string;
+    backendRoutesPath: string;
+    externalLoginPage: string;
+}
+declare const NG_CORE_CONFIG: InjectionToken<NgCoreConfig>;
+
+declare class SymfonyApiClientService {
+    private httpClient;
+    private eventEmitterService;
+    private httpResponseToasterService;
+    private router;
+    private platformId;
+    private config;
+    private status;
+    private urlFetchNotification$;
+    private counterRequest;
+    private routes;
+    constructor(httpClient: HttpClient, eventEmitterService: EventEmitterService, httpResponseToasterService: HttpResponseToasterService, router: Router, platformId: object, config: NgCoreConfig);
+    private downloadRoutes;
+    get<T = {}>(routeName: string, querySegmentParam?: {}, headersOptions?: {
+        [header: string]: string;
+    }, options?: {}): Observable<HttpResponse<T>>;
+    post<T = any>(routeName: string, data: any, querySegmentParam?: {}, headersOptions?: {
+        [header: string]: string;
+    }, requestOptions?: {}): Observable<HttpResponse<T>>;
+    getData<T = {}>(routeName: string, querySegmentParam?: {}, headersOptions?: {
+        [header: string]: string;
+    }, options?: {}): Observable<T>;
+    refreshToken(loginData: {}, path: any): Observable<HttpResponse<TokenInterface>>;
+    private prepareHeader;
+    get token(): string | null;
+    set token(value: string);
+    private tryGetRoutes;
+    handleErrorRoute(error: HttpErrorResponse): Observable<never>;
+    emitPreSend(type: 'get' | 'post'): void;
+    generatePostSendCallbacks(type: 'get' | 'post'): (err?: any) => void;
+    logout(): void;
+    handleError(error: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SymfonyApiClientService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SymfonyApiClientService>;
+}
+
+declare class ApiFormService {
+    private symfonyApiClientService;
+    private httpResponseToasterService;
+    isSending: i0.WritableSignal<boolean>;
+    constructor(symfonyApiClientService: SymfonyApiClientService, httpResponseToasterService: HttpResponseToasterService);
+    send<T = any>(path: string, form: FormGroup, querySegment?: {}, additionalPostData?: {}): rxjs.Observable<_angular_common_http.HttpResponse<T>> | null;
+    supplyValidationErrors(validationErrors: {}, abstractControl: AbstractControl): void;
+    convertJsonToFormData(jsonObject: Object, parentKey: any, carryFormData: FormData | null): FormData;
+    isArray(val: any): boolean;
+    isObject(val: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiFormService>;
+}
+
+declare abstract class BaseFormEntity implements OnInit {
+    fileUploader: FileUpload;
+    entity: i0.InputSignal<any>;
+    sourceEntity: i0.InputSignal<null>;
+    fb: FormBuilder;
+    apiForm: ApiFormService;
+    notifierService: NotifierService;
+    router: Router;
+    route: ActivatedRoute;
+    location: Location;
+    api: SymfonyApiClientService;
+    dynamicDialogRef: DynamicDialogRef<any>;
+    dynamicDialogConf: DynamicDialogConfig<any, any> | null;
+    form: FormGroup;
+    abstract controllerBaseName: any;
+    constructor();
+    abstract initForm(): any;
+    ngOnInit(): void;
+    submit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormEntity, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFormEntity, "app-base-form-entity", never, { "entity": { "alias": "entity"; "required": false; "isSignal": true; }; "sourceEntity": { "alias": "sourceEntity"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface BreadcrumbItem {
+    label: string;
+    routerLink: string;
+}
+declare class BreadcrumbService {
+    private router;
+    private route;
+    constructor(router: Router, route: ActivatedRoute);
+    getBreadcrumbs(route?: ActivatedRoute, url?: string, breadcrumbs?: any[]): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbService>;
+}
+
+declare class BreadcrumbComponent {
+    private router;
+    private route;
+    private breadcrumbService;
+    breadcrumbItems: MenuItem[];
+    private breadcrumbs;
+    constructor(router: Router, route: ActivatedRoute, breadcrumbService: BreadcrumbService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "app-breadcrumb", never, {}, {}, never, never, true, never>;
+}
+
+declare class DialogComponent {
+    dialogRef: MatDialogRef<any>;
+    saveButtonShow: boolean;
+    saveData: any;
+    submit?: ElementRef;
+    constructor(dialogRef: MatDialogRef<any>);
+    onSubmit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "app-dialog", never, { "saveButtonShow": { "alias": "saveButtonShow"; "required": false; }; "saveData": { "alias": "saveData"; "required": false; }; }, {}, ["submit"], ["[title]", "[content]", "[save-button]", "[custom-button]"], true, never>;
+}
+
+declare class AnimationHiderComponent implements OnInit {
+    show: boolean;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationHiderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnimationHiderComponent, "app-animation-hider", never, { "show": { "alias": "show"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HidderComponent implements OnInit, OnDestroy {
+    private asyncComunicatorService;
+    private cd;
+    display: string;
+    showOn: string;
+    hideOn: string;
+    callback: (eventName: string, asyncPost: boolean) => void;
+    constructor(asyncComunicatorService: EventEmitterService<boolean>, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    changeStatus(eventName: string, asyncPost: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HidderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HidderComponent, "app-hidder", never, { "showOn": { "alias": "showOn"; "required": false; }; "hideOn": { "alias": "hideOn"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface DataTableRequest {
+    page: number;
+    size: number;
+    sortField?: string | null;
+    sortOrder?: 1 | -1 | 0 | null;
+    filters?: {
+        [key: string]: any;
+    };
+}
+interface DataTableResponse<T> {
+    data: T[];
+    total: number;
+}
+declare class DataTableService {
+    private apiClientService;
+    constructor(apiClientService: SymfonyApiClientService);
+    loadLazyTableData(url: string, event: any, urlParams: any): Observable<DataTableResponse<any>>;
+    loadData<T>(url: string, req: DataTableRequest, urlParams: any): Observable<DataTableResponse<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataTableService>;
+}
+
+declare class AresService {
+    private apiClientService;
+    constructor(apiClientService: SymfonyApiClientService);
+    fetch(ico: string): rxjs.Observable<{}>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AresService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AresService>;
+}
+
+declare class ConfirmDialogService {
+    private confirmationService;
+    constructor(confirmationService: ConfirmationService);
+    show(header: string, message: string, acceptCallback: () => void, confirmButtonText?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmDialogService>;
+}
+
+declare class FileService {
+    private symfonyApiClientService;
+    constructor(symfonyApiClientService: SymfonyApiClientService);
+    downloadFile(id: any, path?: string): Observable<any>;
+    private getFileNameFromContentDisposition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileService>;
+}
+
+declare class ImageService {
+    constructor();
+    static screenshot(ref: ElementRef): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImageService>;
+}
+
+declare class ImportScriptService {
+    isImported: boolean;
+    constructor();
+    import(...paths: any[]): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImportScriptService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImportScriptService>;
+}
+
+declare class UrlService {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    getYoutubeVideoUrl(videoPath: string): any;
+    validateYouTubeUrl(url: string): string | false;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UrlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UrlService>;
+}
+
+declare class Event {
+    static PRE_SEND_POST: string;
+    static POST_SEND_POST: string;
+    static PRE_SEND_GET: string;
+    static POST_SEND_GET: string;
+    static PRE_SEND: string;
+    static POST_SEND: string;
+    static ADMINISTRATION_ELSEWHERE_CLICK: string;
+}
+
+declare class FormService {
+    private formBuilder;
+    constructor(formBuilder: FormBuilder);
+    createForm(formFields: {}, settings: any): FormGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormService>;
+}
+
+declare class LoginClientService {
+    private symfonyApiClient;
+    constructor(symfonyApiClient: SymfonyApiClientService);
+    tryLogin(loginData: {}, path?: string): Observable<HttpResponse<TokenInterface>>;
+    isLoggedIn(): boolean | null;
+    logout(): void;
+    decodeAccessToken(token: string | null): {
+        exp: number;
+    } | null;
+    impersonation(id: string): Observable<HttpResponse<TokenInterface>> | null;
+    removeImpersonation(): void;
+    isImpersonation(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginClientService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoginClientService>;
+}
+
+declare class GenericResolver implements Resolve<{}[]> {
+    private symfonyApiClientService;
+    private httpResponseToasterService;
+    constructor(symfonyApiClientService: SymfonyApiClientService, httpResponseToasterService: HttpResponseToasterService);
+    resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<{}[]>;
+    static getParameterFromUrl(name: string, pathFromRoot: ActivatedRouteSnapshot[]): string | null;
+    static create(routeName: any, queryMap?: any): (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => Observable<{} | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GenericResolver>;
+}
+
+declare abstract class LazyBaseTable implements OnInit {
+    baseTableStatePrefix: string;
+    stateKey: string;
+    entities: i0.WritableSignal<any[]>;
+    totalRecords: i0.WritableSignal<number>;
+    loading: i0.WritableSignal<boolean>;
+    tableService: DataTableService;
+    symfonyApiClientService: SymfonyApiClientService;
+    confirmDialogServiceService: ConfirmDialogService;
+    notifierService: NotifierService;
+    router: Router;
+    route: ActivatedRoute;
+    abstract baseUrl: any;
+    private lastEvent;
+    urlParams: {};
+    ngOnInit(): void;
+    loadEntities(event: any): void;
+    refresh(): void;
+    delete(entity: any): void;
+    initUrlParams(): void;
+    setUrlParams(urlParams: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LazyBaseTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LazyBaseTable, "app-lazy-base-table", never, {}, {}, never, never, true, never>;
+}
+
+declare class LoaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "app-loader-component", never, {}, {}, never, never, true, never>;
+}
+
+interface SettingAbleInterface<T = any> {
+    settings: T;
+    contextObject?: {};
+}
+
+interface AdminAbleInterface {
+    adminComponentsClass: {
+        menuIcon?: string;
+        label: string;
+        path?: string;
+        component: Type<SettingAbleInterface>;
+    }[];
+}
+
+interface InitAbleInterface<T> {
+    set setInitParams(params: T);
+}
+
+interface AdminSettingAbleInterface extends AdminAbleInterface, SettingAbleInterface {
+}
+
+declare class MiniAdminComponent implements OnInit, InitAbleInterface<AdminSettingAbleInterface> {
+    content1: ViewContainerRef;
+    adminAble: AdminAbleInterface & SettingAbleInterface;
+    selectedComponent: new () => any;
+    headerName: string;
+    settings: any;
+    admin: SettingAbleInterface;
+    label: string;
+    allowedAdminComponent: null;
+    constructor();
+    ngOnInit(): void;
+    showContent(component: new () => SettingAbleInterface, label: string): void;
+    set setInitParams(value: AdminSettingAbleInterface);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MiniAdminComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MiniAdminComponent, "app-mini-admin", never, { "setInitParams": { "alias": "setInitParams"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveableModalComponent<T> implements OnInit {
+    data: {
+        contentComponent: new () => InitAbleInterface<T>;
+        params: T;
+        title: string;
+    };
+    content: ViewContainerRef;
+    title: string;
+    instanceReady$: Subject<InitAbleInterface<T>>;
+    constructor(data: {
+        contentComponent: new () => InitAbleInterface<T>;
+        params: T;
+        title: string;
+    });
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MoveableModalComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MoveableModalComponent<any>, "app-moveable-modal", never, {}, {}, never, never, true, never>;
+}
+
+declare class RemoveItemComponent {
+    data: {
+        name: string;
+    };
+    constructor(data: {
+        name: string;
+    });
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RemoveItemComponent, "app-remove-item", never, {}, {}, never, never, true, never>;
+}
+
+declare class SimpleDialogComponent {
+    dynamicDialogConfig: DynamicDialogConfig;
+    dynamicDialogRef: DynamicDialogRef;
+    text: string;
+    constructor(dynamicDialogConfig: DynamicDialogConfig, dynamicDialogRef: DynamicDialogRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleDialogComponent, "app-simple-dialog-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class MoveableModalService {
+    dialog: MatDialog;
+    constructor(dialog: MatDialog);
+    show<T>(contentComponent: new () => InitAbleInterface<T>, params: T, title?: string): _angular_material_dialog.MatDialogRef<MoveableModalComponent<T>, any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MoveableModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MoveableModalService>;
+}
+
+declare class ErrorMessageComponent implements OnInit {
+    private _errors;
+    control: FormControlName;
+    objectKeys: {
+        (o: object): string[];
+        (o: {}): string[];
+    };
+    constructor();
+    ngOnInit(): void;
+    getMessage(index: string, errors: any): string;
+    get errors(): ValidationErrors;
+    set errors(value: ValidationErrors);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorMessageComponent, "app-error-message", never, {}, {}, never, never, true, never>;
+}
+
+declare class InputFormErrorGrouperDirective implements AfterViewChecked {
+    groupeName: string;
+    hasError: boolean;
+    constructor();
+    ngAfterViewChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputFormErrorGrouperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputFormErrorGrouperDirective, "[appInputFormErrorGrouper]", never, { "groupeName": { "alias": "appInputFormErrorGrouper"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class GlobalFormErrorComponent implements AfterContentInit {
+    private parentFormControl?;
+    private inputFormErrorGrouperDirective?;
+    errors: ValidationErrors;
+    objectKeys: {
+        (o: object): string[];
+        (o: {}): string[];
+    };
+    constructor(parentFormControl?: FormGroupDirective | undefined, inputFormErrorGrouperDirective?: InputFormErrorGrouperDirective | undefined);
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalFormErrorComponent, [{ optional: true; host: true; }, { optional: true; host: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GlobalFormErrorComponent, "app-global-form-error", never, {}, {}, never, never, true, never>;
+}
+
+declare class InputFormErrorDirective implements OnInit, DoCheck {
+    private renderer2;
+    private elementRef;
+    private selfViewContainer;
+    private cdRef;
+    private formGroup;
+    private inputFormErrorGrouperDirective;
+    private selfInput?;
+    formInput: FormControlName;
+    formInputElementRef: ElementRef;
+    errorFormContainer: ViewContainerRef;
+    private errorMessageComonent;
+    private isError;
+    rootFormGroupDirective: i0.InputSignal<FormGroupDirective | undefined>;
+    constructor(renderer2: Renderer2, elementRef: ElementRef, selfViewContainer: ViewContainerRef, cdRef: ChangeDetectorRef, formGroup: FormGroupDirective, inputFormErrorGrouperDirective: InputFormErrorGrouperDirective, selfInput?: FormControlName | undefined);
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    createErrorMessage(): void;
+    clearMessage(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputFormErrorDirective, [null, null, null, null, null, { optional: true; host: true; }, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputFormErrorDirective, "[appFormError]", never, { "rootFormGroupDirective": { "alias": "rootFormGroupDirective"; "required": false; "isSignal": true; }; }, {}, ["formInput", "formInputElementRef", "errorFormContainer"], never, true, never>;
+}
+
+declare class HiderElementDirective implements OnInit, OnDestroy {
+    private asyncComunicatorService;
+    private cd;
+    showOn: string;
+    hideOn: string;
+    display: string;
+    callback: (eventName: string, asyncPost: boolean) => void;
+    constructor(asyncComunicatorService: EventEmitterService<boolean>, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    changeStatus(eventName: string, asyncPost: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HiderElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HiderElementDirective, "[appHiderElement]", never, { "showOn": { "alias": "showOn"; "required": false; }; "hideOn": { "alias": "hideOn"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LinkDeactivateService {
+    deactivate: boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkDeactivateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LinkDeactivateService>;
+}
+
+declare class LinkDeactivateDirective {
+    private linkDeactivateService;
+    constructor(linkDeactivateService: LinkDeactivateService);
+    click(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkDeactivateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LinkDeactivateDirective, "[appLinkDeactivate]", never, {}, {}, never, never, true, never>;
+}
+
+declare const loginGuard: CanActivateFn;
+
+declare class ArrayHelper {
+    static uniqueBy<T, K extends keyof T>(items: T[], key: K): T[];
+    static treeToPrimengTreeNode(data: any[]): TreeNode[];
+    static reinitArray(arrayToReinit: any[], newValues: any[]): void;
+    static sortTree(data: {
+        children: any[];
+    }[], sortProperties?: string[]): void;
+    static objectWithLevelToNestedArray(objects: {
+        level: number;
+    }[]): any[] | undefined;
+    static recalculateNestedArrayObjectLevel(dataArray: {
+        level: number;
+    }[], clearChildren?: boolean): void;
+    static flatNestedArrayObject(dataArray: {
+        children?: [];
+    }[]): any[];
+}
+
+declare class ElementHelper {
+    static getCursorPosition(): number | null;
+    static getInnerNodeFromClickPosition(event: MouseEvent): Node | null;
+}
+
+declare class Helper {
+    static getTrackByFunction<T>(propertyName?: string): TrackByFunction<T>;
+    static objectResetAssign(target: any, source: any): void;
+}
+
+declare class ObjectHelper {
+    static reinitObject(target: {}, source: {}): void;
+    static toRaw(source: any): any;
+    static toArray(): void;
+}
+
+declare class StringHelper {
+    constructor();
+    static randomString(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StringHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StringHelper>;
+}
+
+declare class TreeHelper {
+    static findNodeByKey(nodes: TreeNode[], key: string): TreeNode | null;
+}
+
+declare class ElementPositionMessenger {
+    private _x;
+    private _y;
+    constructor(_x: number, _y: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+}
+
+declare const FontAwesomeIcons: _fortawesome_fontawesome_common_types.IconDefinition[];
+
+declare class SafeHtmlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: string, ...args: unknown[]): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
+}
+
+export { AnimationHiderComponent, AresService, ArrayHelper, BaseFormEntity, BreadcrumbComponent, BreadcrumbService, ConfirmDialogService, DataTableService, DialogComponent, ElementHelper, ElementPositionMessenger, ErrorMessageComponent, Event, EventEmitterService, FileService, FontAwesomeIcons, FormService, GenericResolver, GlobalFormErrorComponent, Helper, HidderComponent, HiderElementDirective, HttpResponseToasterService, ImageService, ImportScriptService, InputFormErrorDirective, InputFormErrorGrouperDirective, LazyBaseTable, LinkDeactivateDirective, LinkDeactivateService, LoaderComponent, LoginClientService, MiniAdminComponent, MoveableModalComponent, MoveableModalService, NG_CORE_CONFIG, NgCore, NotifierService, ObjectHelper, RemoveItemComponent, SafeHtmlPipe, SimpleDialogComponent, StringHelper, SymfonyApiClientService, TreeHelper, UrlService, loginGuard };
+export type { AdminAbleInterface, AdminSettingAbleInterface, BreadcrumbItem, DataTableRequest, DataTableResponse, NgCoreConfig, SettingAbleInterface };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "mk-ng-lib",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^20",
+    "@angular/core": "^20",
+    "@angular/forms": "^20",
+    "@angular/platform-browser": "^20",
+    "@angular/platform-browser-dynamic": "^20",
+    "@angular/router": "^20",
+    "ngx-toastr": "^19.1.0",
+    "primeng": "^20.4.0",
+    "jwt-decode": "^4.0.0",
+    "@fortawesome/free-solid-svg-icons": "^7.1.0",
+    "chart.js": "^4",
+    "html2canvas": "^1.4.1",
+    "@angular/material": "^20.2.14"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/mk-ng-lib.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/mk-ng-lib.mjs"
+    }
+  }
+}