@tekus/design-system 5.18.0 → 5.20.0

package/assets/tokens/tk-foundations.json

@@ -527,7 +527,7 @@
       }
     },
     "paddingX": {
-      "nome": {
+      "none": {
         "value": "{tk-spacing.base.0}",
         "type": "number"
       },
@@ -553,7 +553,7 @@
       }
     },
     "paddingY": {
-      "nome": {
+      "none": {
         "value": "{tk-spacing.base.0}",
         "type": "number"
       },
@@ -579,7 +579,7 @@
       }
     },
     "gap": {
-      "nome": {
+      "none": {
         "value": "{tk-spacing.base.0}",
         "type": "number"
       },

package/components/checkbox/src/checkbox.component.d.ts

@@ -2,8 +2,13 @@ import { OnInit, OnDestroy } from '@angular/core';
 import { ControlValueAccessor, FormControl, NgControl } from '@angular/forms';
 import * as i0 from "@angular/core";
 export declare class CheckboxComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    /** Internal references and injections */
     readonly ngControl: NgControl | null;
+    /**
+     * Initialize the component and register it as a ControlValueAccessor.
+     */
     constructor();
+    /** Properties and Signals */
     /**
      * @property {ModelSignal<any>} model
      * @description
@@ -55,24 +60,50 @@ export declare class CheckboxComponent implements ControlValueAccessor, OnInit,
      * Message to display when the control is invalid and touched.
      */
     errorMessage: import("@angular/core").InputSignal<string>;
+    /**
+     * @property {ModelSignal<boolean>} indeterminate
+     * @description
+     * Indeterminate state of the checkbox (reactive).
+     * Useful for parent checkboxes in lists with partial selection.
+     */
+    indeterminate: import("@angular/core").ModelSignal<boolean>;
     /**
      * @property {boolean} disabled
      * @description
      * Whether the checkbox is disabled.
      */
-    disabled: import("@angular/core").WritableSignal<boolean>;
+    disabled: import("@angular/core").ModelSignal<boolean>;
+    /** Component Methods */
     get effectiveControl(): FormControl;
     onChange: (value: unknown) => void;
     onTouched: () => void;
     private readonly subscription;
     ngOnInit(): void;
     ngOnDestroy(): void;
+    /**
+     * Implementation of ControlValueAccessor: Writes a new value from the form.
+     */
     writeValue(value: unknown): void;
+    /**
+     * Implementation of ControlValueAccessor: Registers a callback for change events.
+     */
     registerOnChange(fn: (value: unknown) => void): void;
+    /**
+     * Implementation of ControlValueAccessor: Registers a callback for touched events.
+     */
     registerOnTouched(fn: () => void): void;
+    /**
+     * Implementation of ControlValueAccessor: Sets the disabled state.
+     */
     setDisabledState?(isDisabled: boolean): void;
+    /**
+     * Handle model change events from the template.
+     */
     onModelChange(value: unknown): void;
+    /**
+     * Handle blur events to trigger onTouched.
+     */
     onBlur(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "tk-checkbox", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "binary": { "alias": "binary"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; }, { "model": "modelChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "tk-checkbox", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "binary": { "alias": "binary"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "model": "modelChange"; "indeterminate": "indeterminateChange"; "disabled": "disabledChange"; }, never, never, true, never>;
 }

package/components/drawer/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@tekus/design-system/components/drawer" />
+export * from './public-api';

package/components/drawer/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './src/drawer.component';
+export * from './src/services/drawer.service';
+export * from './src/drawer.types';

package/components/drawer/src/drawer.component.d.ts

@@ -0,0 +1,105 @@
+import { EventEmitter, Type, ElementRef, OnDestroy } from '@angular/core';
+import { DrawerHeaderAction, DrawerSizeType } from './drawer.types';
+import { TkCloseInterceptor } from '@tekus/design-system/core/types';
+import * as i0 from "@angular/core";
+/**
+ * @component DrawerComponent
+ * @description
+ * A programmatically controlled drawer overlay used for displaying dynamic content,
+ * titles, and header actions. The drawer is opened through a service with a configuration object,
+ * similar to tk-modal.
+ *
+ * This component supports:
+ * - Required title with ellipsis for long text.
+ * - Optional header action button + close button.
+ * - Content as string or component.
+ * - Position: always right.
+ * - Sizes: small (500px), large (1024px).
+ * - Closable and dismissible mask behavior.
+ *
+ * @usage
+ * ### Open a drawer from TypeScript using the drawer service
+ * ```ts
+ * this.drawerService.open({
+ *   title: 'Drawer name',
+ *   content: 'Content text drawer example',
+ *   headerAction: {
+ *     label: 'Action',
+ *     severity: 'primary',
+ *     action: () => console.log('Action clicked'),
+ *     returnValue: true,
+ *   },
+ *   size: 'small',
+ * }).subscribe((result) => {
+ *   console.log('Drawer closed with value:', result);
+ * });
+ * ```
+ * Modernized for Angular 19 with 100% synchronous Signal-based closing interception.
+ */
+export declare class DrawerComponent<T = unknown> implements OnDestroy {
+    private readonly elementRef;
+    private readonly contentHost;
+    private componentRef?;
+    /** The required title displayed at the top left of the drawer header */
+    title: import("@angular/core").InputSignal<string>;
+    /** The main content of the drawer. Can be a string or a Component Type. */
+    content: import("@angular/core").InputSignal<string | Type<T> | null>;
+    /** Optional header action button (displayed before close button) */
+    headerAction: import("@angular/core").InputSignal<DrawerHeaderAction | null>;
+    /** Drawer size: 'small' (500px), 'large' (1024px) */
+    size: import("@angular/core").InputSignal<DrawerSizeType>;
+    /** Whether the drawer can be closed by the user via close button */
+    closable: import("@angular/core").InputSignal<boolean>;
+    /** Whether clicking the mask closes the drawer */
+    dismissible: import("@angular/core").InputSignal<boolean>;
+    /** Optional data to be passed as inputs to the dynamic component. */
+    data: import("@angular/core").InputSignal<Partial<T>>;
+    /** Optional interceptor called before the drawer closes. */
+    interceptor: import("@angular/core").InputSignal<TkCloseInterceptor | undefined>;
+    isContentString: import("@angular/core").Signal<boolean>;
+    hasHeaderAction: import("@angular/core").Signal<boolean>;
+    /** Computed: drawer width (responsive) and max-width based on `size`. Always right position. */
+    drawerStyle: import("@angular/core").Signal<{
+        width: string;
+        maxWidth: string;
+    }>;
+    /** Visibility flag. Use model for two-way binding when using drawer in template. */
+    isOpened: import("@angular/core").ModelSignal<boolean>;
+    /** Whether the drawer content has a scrollbar */
+    hasScroll: boolean;
+    /** Emits when the drawer closes, passing the return value from header action or null */
+    readonly onClose: EventEmitter<unknown>;
+    private alreadyEmitted;
+    private returnValueOnClose;
+    constructor(elementRef: ElementRef);
+    ngOnDestroy(): void;
+    private attachDynamicContent;
+    private syncDynamicInputs;
+    private detachDynamicContent;
+    /**
+     * Checks if the drawer content has a scrollbar and updates `hasScroll` state.
+     */
+    checkScroll(): void;
+    /** Opens the drawer */
+    open(): void;
+    /**
+     * @summary Main entry point for closure requests.
+     * @returns true if closure was executed.
+     */
+    tryClose(returnValue?: unknown): boolean;
+    private canExecuteClosure;
+    private executeClosure;
+    /** Handles external visibility changes (from p-drawer close button or mask) */
+    onVisibleChange(visible: boolean): void;
+    /** Closes the drawer and emits onClose */
+    handleClose(): void;
+    /** Forcefully closes the drawer without checks */
+    close(): void;
+    /**
+     * Handles header action button click.
+     */
+    handleHeaderAction(action: (() => void) | undefined, returnValue: unknown): void;
+    private resetClosureState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DrawerComponent<any>, "tk-drawer", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "headerAction": { "alias": "headerAction"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "interceptor": { "alias": "interceptor"; "required": false; "isSignal": true; }; "isOpened": { "alias": "isOpened"; "required": false; "isSignal": true; }; }, { "isOpened": "isOpenedChange"; }, never, never, true, never>;
+}

package/components/drawer/src/drawer.types.d.ts

@@ -0,0 +1,22 @@
+import { Type } from '@angular/core';
+import { Variant } from '@tekus/design-system/components/button';
+import { SeverityType } from '@tekus/design-system/components/modal';
+import { TkCloseInterceptor } from '@tekus/design-system/core/types';
+export type DrawerSizeType = 'small' | 'large';
+export interface DrawerHeaderAction {
+    label: string;
+    severity: SeverityType;
+    action?: () => void;
+    returnValue?: unknown;
+    variant?: Variant;
+}
+export interface DrawerConfig<T = unknown> {
+    title: string;
+    content?: string | Type<T>;
+    headerAction?: DrawerHeaderAction;
+    size?: DrawerSizeType;
+    closable?: boolean;
+    dismissible?: boolean;
+    data?: Partial<T>;
+    interceptor?: TkCloseInterceptor;
+}

package/components/drawer/src/services/drawer.service.d.ts

@@ -0,0 +1,15 @@
+import { ApplicationRef, ComponentRef } from '@angular/core';
+import { DrawerComponent } from '../drawer.component';
+import { Observable } from 'rxjs';
+import { DrawerConfig } from '../drawer.types';
+import * as i0 from "@angular/core";
+export declare class DrawerService {
+    private readonly appRef;
+    private drawerRef;
+    constructor(appRef: ApplicationRef);
+    get _drawerRefForTesting(): ComponentRef<DrawerComponent<unknown>> | null;
+    set _drawerRefForTesting(ref: ComponentRef<DrawerComponent<unknown>> | null);
+    open(config: DrawerConfig): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DrawerService>;
+}

package/components/icon/core/icons/arrows-rotate.d.ts

@@ -0,0 +1,2 @@
+import { IconRegister } from "../icon-catalog";
+export declare const arrowsRotateIcon: IconRegister;

package/components/icon/core/icons/edit.d.ts

@@ -0,0 +1,2 @@
+import { IconRegister } from '../icon-catalog';
+export declare const editIcon: IconRegister;

package/components/icon/core/icons/globe-pointer.d.ts

@@ -0,0 +1,2 @@
+import { IconRegister } from '../icon-catalog';
+export declare const globePointerIcon: IconRegister;

package/components/icon/core/icons/grip-vertical.d.ts

@@ -0,0 +1,2 @@
+import { IconRegister } from '../icon-catalog';
+export declare const gridVerticalIcon: IconRegister;

package/components/modal/src/modal.component.d.ts

@@ -1,99 +1,118 @@
-import { EventEmitter, Type, ElementRef } from '@angular/core';
+import { EventEmitter, Type, ElementRef, OnDestroy } from '@angular/core';
 import { ModalFooterButton, ModalSizeType } from './modal.types';
+import { TkCloseInterceptor } from '@tekus/design-system/core/types';
 import * as i0 from "@angular/core";
 /**
  * @component ModalComponent
  * @description
- * A programmatically controlled modal dialog used for displaying dynamic content, titles, and footer actions.
- * The modal is not instantiated via template bindings, but rather opened through a service with a configuration object.
- *
- * This component supports:
- * - Configurable title and content.
- * - Optional footer buttons with callbacks and return values.
- * - Multiple sizes: `'small' | 'large' | 'full'`.
- * - Closable modal and outside-click behavior.
- * - Passing arbitrary data to the modal instance.
- *
- * @usage
- * ### Open a modal from TypeScript using the modal service
- * ```ts
- * this.modalService.open({
- *   title: 'Demo Modal',
- *   content: 'This modal is opened from TypeScript using the service.',
- *   footerButtons: [
- *     {
- *       label: 'Accept',
- *       severity: 'secondary',
- *       action: () => console.log('Accept clicked'),
- *       returnValue: true,
- *     },
- *     {
- *       label: 'Cancel',
- *       severity: 'danger',
- *       action: () => console.log('Cancel clicked'),
- *       returnValue: false,
- *     },
- *   ],
- *   size: 'small',
- *   closable: true,
- *   closeOnOutsideClick: false,
- * }).subscribe((result) => {
- *   console.log('Modal closed with value:', result);
- * });
- * ```
+ * A programmatically controlled modal dialog used for displaying dynamic content.
+ * Modernized for Angular 19 with 100% synchronous Signal-based closing interception.
  */
-export declare class ModalComponent {
+export declare class ModalComponent<T = unknown> implements OnDestroy {
     private readonly elementRef;
-    constructor(elementRef: ElementRef);
+    private readonly contentHost;
+    private componentRef?;
     /** The title displayed at the top of the modal */
     title: import("@angular/core").InputSignal<string>;
-    /** The main content of the modal */
-    content: import("@angular/core").InputSignal<string | Type<unknown> | null>;
+    /** The main content of the modal. Can be a string or a Component Type. */
+    content: import("@angular/core").InputSignal<string | Type<T> | null>;
     /** Array of footer buttons with label, callback, and return value */
     footerButtons: import("@angular/core").InputSignal<ModalFooterButton[]>;
-    /** Modal size: 'small', 'large', or 'full' */
+    /** Modal size: 'small', 'large', 'medium' or 'full' */
     size: import("@angular/core").InputSignal<ModalSizeType>;
-    /** Whether the modal can be closed by the user */
+    /** Whether the modal can be closed by the user via close button */
     closable: import("@angular/core").InputSignal<boolean>;
-    /** Whether clicking outside closes the modal */
+    /** Whether clicking outside the modal mask closes the modal */
     closeOnOutsideClick: import("@angular/core").InputSignal<boolean>;
-    isContentString: import("@angular/core").Signal<boolean>;
-    /** Computed: whether the modal has footer buttons */
-    hasFooter: import("@angular/core").Signal<boolean>;
     /**
-     * Whether the modal should be responsive on mobile screens.
-     * If true, the modal width will adapt based on breakpoints.
-     * @default true
+     * Optional data to be passed as inputs to the dynamic component.
+     */
+    data: import("@angular/core").InputSignal<Partial<T>>;
+    /**
+     * Optional interceptor called before the modal closes.
+     * MUST be synchronous. Returns true to allow closing.
      */
+    interceptor: import("@angular/core").InputSignal<TkCloseInterceptor | undefined>;
+    /** Computed: whether the content is a simple string */
+    isContentString: import("@angular/core").Signal<boolean>;
+    /** Computed: whether the modal has footer buttons to display */
+    hasFooter: import("@angular/core").Signal<boolean>;
+    /** Whether the modal should be responsive on mobile screens */
     responsive: import("@angular/core").InputSignal<boolean>;
-    /** Computed: calculates modal max-width based on `size` */
-    modalMaxWidth: import("@angular/core").Signal<"67.5rem" | "35rem" | "98vw" | "25rem">;
+    /** Visibility flag as Model Signal (allows two-way binding) */
+    isOpened: import("@angular/core").ModelSignal<boolean>;
     /** Whether the modal content has a scrollbar */
     hasScroll: boolean;
-    /** Visibility flag */
-    isOpened: boolean;
     /** Emits when the modal closes, passing the return value from footer buttons or null */
     readonly onClose: EventEmitter<unknown>;
     private alreadyEmitted;
     private returnValueOnClose;
-    /** Opens the modal */
-    open(): void;
+    constructor(elementRef: ElementRef);
+    /** Computed: calculates modal max-width based on `size` */
+    modalMaxWidth: import("@angular/core").Signal<"67.5rem" | "35rem" | "98vw" | "25rem">;
+    ngOnDestroy(): void;
+    /**
+     * @summary Orchestrates dynamic rendering and destruction based on visibility.
+     * @private
+     */
+    private attachDynamicContent;
+    /**
+     * @summary Synchronizes incoming data record with the dynamic instance @Inputs.
+     * @private
+     */
+    private syncDynamicInputs;
+    /**
+     * @summary Safely destroys the dynamic component and clears references.
+     * @private
+     */
+    private detachDynamicContent;
     /**
      * Checks if the modal content has a scrollbar and updates `hasScroll` state.
-     * This is called when the modal is shown.
      */
     checkScroll(): void;
-    /** Closes the modal and emits onClose with null */
+    /**
+     * Opens the modal dialog.
+     */
+    open(): void;
+    /**
+     * @summary Main entry point for closure requests.
+     * Evaluation is 100% synchronous based on current Signal state.
+     * @param returnValue (Optional) Value to emit on close.
+     */
+    tryClose(returnValue?: unknown): void;
+    /**
+     * @summary Synchronous evaluator of hierarchical guards.
+     * @returns true if closure is allowed.
+     * @private
+     */
+    private canExecuteClosure;
+    /**
+     * @summary Unified logic to execute the final closure state change.
+     * @private
+     */
+    private executeClosure;
+    /**
+     * @summary Handles external visibility changes (from p-dialog 'X' or Escape).
+     * Ensures the reactive guard is respected before allowing closure.
+     */
+    onVisibleChange(visible: boolean): void;
+    /**
+     * Handles the close event from the underlying dialog component.
+     */
     handleClose(): void;
-    /** Closes the modal without emitting an event */
-    close(): void;
     /**
-     * Handles footer button actions.
-     * Executes the action callback, emits `onClose` with the provided returnValue, then closes the modal.
-     * @param action Callback to execute when the button is clicked
-     * @param returnValue Value emitted on modal close
+     * @summary Handles actions triggered by footer buttons.
      */
     handleAction(action: (() => void) | undefined, returnValue: unknown): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "tk-modal", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "footerButtons": { "alias": "footerButtons"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    /**
+     * @summary Safely closes the modal forcefully without checks.
+     */
+    close(): void;
+    /**
+     * @private
+     * Encapsulates state cleanup to avoid repetitive assignments
+     */
+    private resetClosureState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent<any>, "tk-modal", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "footerButtons": { "alias": "footerButtons"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "interceptor": { "alias": "interceptor"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "isOpened": { "alias": "isOpened"; "required": false; "isSignal": true; }; }, { "isOpened": "isOpenedChange"; }, never, never, true, never>;
 }

package/components/modal/src/modal.types.d.ts

@@ -1,19 +1,39 @@
 import { Type } from '@angular/core';
 import { Variant } from '@tekus/design-system/components/button';
+import { TkCloseInterceptor } from '@tekus/design-system/core/types';
 export type ModalSizeType = 'small' | 'large' | 'medium' | 'full';
 export type SeverityType = 'primary' | 'secondary' | 'danger';
 export interface ModalFooterButton {
     label: string;
     severity: SeverityType;
+    /** Optional callback function executed when the button is clicked */
     action?: () => void;
+    /** Optional value emitted when the modal closes after clicking this button */
     returnValue?: unknown;
+    /** Optional button variant */
     variant?: Variant;
 }
-export interface ModalConfig {
+export interface ModalConfig<T = unknown> {
+    /** The title displayed at the top of the modal */
     title: string;
-    content?: string | Type<unknown>;
+    /** The main content of the modal. Can be a string or a Component Type. */
+    content?: string | Type<T>;
+    /** Array of footer buttons with label, callback, and return value */
     footerButtons?: ModalFooterButton[];
+    /** Modal size: 'small', 'large', 'medium' or 'full' */
     size?: ModalSizeType;
+    /** Whether the modal can be closed by the user via close button */
     closable?: boolean;
+    /** Whether clicking outside the modal mask closes the modal */
     closeOnOutsideClick?: boolean;
+    /**
+     * Optional data to be passed as inputs to the dynamic component.
+     * Keys must match the component's @Input names.
+     */
+    data?: Partial<T>;
+    /**
+     * Optional interceptor called before the modal closes.
+     * Return false, Promise<false> or Observable<false> to prevent closing.
+     */
+    interceptor?: TkCloseInterceptor;
 }

package/components/modal/src/services/modal.service.d.ts

@@ -3,13 +3,28 @@ import { ModalComponent } from '../modal.component';
 import { Observable } from 'rxjs';
 import { ModalConfig } from '../modal.types';
 import * as i0 from "@angular/core";
+/**
+ * @service ModalService
+ * @description
+ * Service responsible for programmatically opening and managing modal dialogs.
+ * It handles component creation, attachment to the document body, and cleanup.
+ */
 export declare class ModalService {
     private readonly injector;
     private readonly appRef;
+    /** Reference to the currently open modal component */
     private modalRef;
     constructor(injector: Injector, appRef: ApplicationRef);
+    /** Internal getter for testing purposes */
     get _modalRefForTesting(): ComponentRef<ModalComponent> | null;
+    /** Internal setter for testing purposes */
     set _modalRefForTesting(ref: ComponentRef<ModalComponent> | null);
+    /**
+     * Opens a modal dialog with the provided configuration.
+     * Only one modal can be open at a time.
+     * @param config Configuration object for the modal (title, content, buttons, etc.)
+     * @returns An observable that emits the modal's return value when it closes.
+     */
     open(config: ModalConfig): Observable<unknown>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;