@bootkit/ng0 0.0.0-alpha.5 → 0.0.0-alpha.51

package/README.md

@@ -1,2 +1,2 @@
-# NG0
-Angular+Bootstrap Component Library
+# NG0
+Angular+Bootstrap Component Library

package/common/index.d.ts

@@ -1,52 +1,312 @@
-import { InjectionToken } from '@angular/core';
+import * as i0 from '@angular/core';
+import { InjectionToken, TrackByFunction } from '@angular/core';
+import { IsActiveMatchOptions } from '@angular/router';
+import { Observable } from 'rxjs';
 
-type Placement = 'start' | 'end' | 'top' | 'bottom';
-type Alignment = 'start' | 'center' | 'end';
 declare const RTL: InjectionToken<boolean>;
 
+/**
+ * Represents a claim object that can contain multiple claims.
+ */
 interface ClaimObject {
     all?: string[];
     any?: string[];
 }
+/**
+ * Represents a claim that can be a string or an object containing claims.
+ * This is useful for defining permissions or roles in a security context.
+ * It allows for both simple string claims and more complex claims that can include multiple values.
+ * For example:
+ * - A simple claim: 'admin'
+ * - A complex claim: { all: ['read', 'write']'] }
+ *
+ */
 type ClaimLike = string | ClaimObject;
+/**
+ * Represents a condition to check against a user.
+ * It can be a ClaimLike or a boolean value.
+ * - If it's a ClaimLike, it checks if the user has the specified claim(s).
+ * - If it's true, it checks if there is a logged-in user.
+ * - If it's false, it checks if there is no logged-in user.
+ */
+type UserCondition = ClaimLike | boolean;
 
-declare function numberRange(start: number, end: number): number[];
-declare function fillArray(start: number, end: number): number[];
+type Placement = 'start' | 'end' | 'top' | 'bottom';
+type Alignment = 'start' | 'center' | 'end';
+/**
+ * Flips the placement direction.
+ * @param placement The placement direction to flip.
+ * @returns The flipped placement direction.
+ */
 declare function flipPlacement(placement: Placement): "start" | "end" | "top" | "bottom";
 
+/**
+ * Formats a string by replacing placeholders with the provided arguments.
+ * @param str The string to format, containing placeholders in the form of {0}, {1}, etc.
+ * @param args The values to replace the placeholders with.
+ * @returns The formatted string.
+ */
 declare function formatString(str: string, ...args: any[]): string;
 
-/** Base class of all menu items  */
-interface MenuItemBase<DataType = any> {
-    type: 'group' | 'text' | 'divider';
+/** Menu item  */
+interface MenuItemBase {
+    type?: string;
     id?: any;
-    disabled?: boolean;
-    active?: boolean;
     show?: boolean;
+    /**
+     * @deprecated use 'user' instead
+     */
     claim?: ClaimLike;
-    parent?: MenuItem;
-    data?: DataType;
+    cssClass?: string;
+    data?: any;
+    user?: UserCondition;
 }
-/** Section Menu Item  */
-interface GroupMenuItem<DataType = any> extends MenuItemBase<DataType> {
-    type: 'group';
-    text: string;
-    expanded?: boolean;
+interface NodeMenuItem extends MenuItemBase {
+    type?: 'node';
+    disabled?: boolean;
+    text?: string;
     icon?: string;
-    children: Array<MenuItem<DataType>>;
+    expanded?: boolean;
+    children?: MenuItem[];
+    parent?: MenuItem;
+    routerLink?: string | string[];
+    routerLinkActiveOptions?: {
+        exact: boolean;
+    } | IsActiveMatchOptions;
+    href?: string;
+    target?: '_blank' | '_parent' | '_self' | '_top';
+    tag?: string;
+    tagCssClass?: string | string[];
 }
-/** Text Menu Item */
-interface TextMenuItem<DataType = any> extends MenuItemBase<DataType> {
-    type: 'text';
-    text: string;
-    routerLink?: string[];
+interface HeaderMenuItem extends MenuItemBase {
+    type: 'header';
+    disabled?: boolean;
+    text?: string;
     icon?: string;
+    tag?: string;
+    tagCssClass?: string | string[];
 }
-/** Divider Menu Item */
-interface DividerMenuItem<DataType = any> extends MenuItemBase<DataType> {
+interface DividerMenuItem extends MenuItemBase {
     type: 'divider';
 }
-type MenuItem<DataType = any> = TextMenuItem<DataType> | DividerMenuItem<DataType> | GroupMenuItem<DataType>;
+type MenuItem = NodeMenuItem | HeaderMenuItem | DividerMenuItem;
+
+/**
+ * Converts a value to an Observable.
+ * If the value is already an Observable, it returns it directly.
+ * If the value is a Promise, it converts it to an Observable.
+ * If the value is neither, it wraps it in an Observable using `of`.
+ * @param value The value to convert.
+ * @returns An Observable that emits the value.
+ */
+declare function toObservable<T>(value: T | Observable<T> | Promise<T>): Observable<T>;
+
+/**
+ * Creates an array of numbers within a specified range.
+ * @param start The starting number of the range (inclusive).
+ * @param end The ending number of the range (inclusive).
+ * @returns An array of numbers within the specified range.
+ */
+declare function numberArray(start: number, end: number): number[];
+/**
+ * Deletes multiple entries from an array based on the provided indices.
+ * @param array
+ * @param indices
+ * @private
+ */
+declare function deleteEntries(array: any[], indices: number[]): void;
+
+declare function getEnumValues(enumClass: Record<string, string | number>): Array<string | number>;
+
+/**
+ * Type definition for an ID generator function.
+ * @param item The item for which the ID is to be generated.
+ * @returns A string representing the generated ID.
+ */
+type IdGenerator = (item: any) => string;
+/**
+ * Type definition for an ID generator which can be a function or a string representing the property name to extract the ID from.
+ */
+type IdGeneratorLike = IdGenerator | string;
+/**
+ * Creates a sequential ID generator function with an optional prefix.
+ * This function generates unique IDs by incrementing a counter each time it is called.
+ * @param prefix Optional prefix for the generated IDs.
+ * @returns A function that generates sequential IDs with the given prefix.
+ */
+declare function sequentialIdGenerator(prefix?: string): IdGenerator;
+/**
+ * Converts an IdGeneratorLike to an IdGenerator function.
+ * @param v The ID generator to convert.
+ * @returns An IdGenerator function.
+ */
+declare function IdGeneratorAttribute(v: IdGeneratorLike): IdGenerator;
+
+/**
+ * CSS class type which can be a string, array of strings, set of strings, or an object with class names as keys.
+ */
+type CssClass = string | string[] | Set<string> | {
+    [klass: string]: any;
+} | null | undefined;
+/**
+ * A function that takes an item and returns a CssClass.
+ * @param item The item to get the CSS class for.
+ * @returns The CSS class for the item.
+ */
+type CssClassGetter = (obj: any) => CssClass;
+/**
+ * A type that represents a CSS class or a function that returns a CSS class.
+ */
+type CssClassLike = CssClass | CssClassGetter;
+/**
+ * Converts a CssClassLike to a CssClassGetter function.
+ * @param v The CssClassLike to convert.
+ * @returns A function that returns the desired CSS class.
+ */
+declare function CssClassAttribute(v: CssClassLike): CssClassGetter;
+
+/**
+ * Equality comparer function type.
+ * @param a First value to compare.
+ * @param b Second value to compare.
+ * @returns true if a is considered equal to b else returns false
+ */
+type EqualityComparer = (a: any, b: any) => boolean;
+/**
+ * Equality comparer like type.
+ * can be a function or a string representing the property name to compare.
+ */
+type EqualityComparerLike = EqualityComparer | string;
+/**
+ * Default equality comparer function.
+ * @param a First value to compare.
+ * @param b Second value to compare.
+ * @returns true if a === b else returns false
+ */
+declare function defaultEqualityComparer(a: any, b: any): boolean;
+/**
+ * Converts an EqualityComparerLike to an EqualityComparer function.
+ * @param e The EqualityComparerLike to convert.
+ * @returns The converted EqualityComparer.
+ */
+declare function equalityComparerAttribute(e: EqualityComparerLike): EqualityComparer;
+
+/**
+ * Value writer function type.
+ * @param a The input value
+ * @returns The written value
+ */
+type ValueWriter = (a: any) => any;
+/**
+ * Value writer can be a function or a string representing the property name to extract the value from.
+ */
+type ValueWriterLike = ValueWriter | string;
+/**
+ * Default value writer function.
+ * @param a The input value
+ * @returns the input value (it does not transform it)
+ */
+declare function defaultValueWriter(a: any): any;
+/**
+ * Converts a ValueWriterLike to a ValueWriterFunction.
+ * @param v The value writer to convert.
+ * @returns A ValueWriter function.
+ */
+declare function valueWriterAttribute(v: ValueWriterLike): ValueWriter;
+
+/**
+ * A comparison function type that defines an ordering relation between two values.
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns
+ * - A negative number if `a` should come before `b`
+ * - A positive number if `a` should come after `b`
+ * - Zero if `a` and `b` are considered equal
+ */
+type Comparer = (a: any, b: any) => number;
+/**
+ * Value comparer can be a function or a string representing the property name to compare.
+ */
+type ComparerLike = Comparer | string;
+/**
+ * A simple comparer function.
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns -1 if a < b, 1 if a > b, 0 if a === b
+ */
+declare function defaultComparer(a: any, b: any): number;
+/**
+ * Converts a ComparerLike to a Comparer.
+ * @param v The comparer to convert.
+ * @returns A function that compares two values.
+ */
+declare function comparerAttribute(v: ComparerLike): Comparer;
+
+/**
+ * Filter predicate function type.
+ * @param item The item to test against the filter.
+ * @param params Additional parameters to pass to the filter.
+ * @returns True if the item matches the filter, false otherwise.
+ */
+type FilterPredicate = (item: any, ...params: any[]) => boolean;
+/**
+ * Filter predicate can be a function or a string representing the property name to filter.
+ */
+type FilterPredicateLike = FilterPredicate | string;
+/**
+ * No-op filter predicate that always returns true.
+ * @param item The item to test against the filter.
+ * @returns true
+ */
+declare const noopFilter: FilterPredicate;
+/**
+ * A simple filter predicate that checks if the item's string representation includes the match string.
+ * @param item The item to test against the filter.
+ * @param match The string to match.
+ * @returns True if the item matches the filter, false otherwise.
+ */
+declare const defaultFilter: FilterPredicate;
+/**
+ * Converts a FilterPredicateLike to a FilterPredicate function.
+ * If the input is a string, it creates a predicate that checks the property with that name.
+ * @param v The FilterPredicateLike to convert.
+ * @returns The corresponding FilterPredicate function.
+ */
+declare function filterPredicateAttribute(v: FilterPredicateLike): FilterPredicate;
+
+/**
+ * An item tracker that can be either a TrackByFunction or a string property name.
+ */
+type TrackByLike = TrackByFunction<any> | string;
+/**
+ * A trackBy function that tracks items by their index.
+ */
+declare const trackByIndex: TrackByFunction<any>;
+/**
+ * A trackBy function that tracks items by the item itself.
+ */
+declare const trackByItem: TrackByFunction<any>;
+/**
+ * Converts a TrackByLike to a TrackByFunction.
+ * @param v The item tracker to convert.
+ * @returns A TrackByFunction.
+ */
+declare function TrackByAttribute(v: TrackByLike): TrackByFunction<any>;
+
+/**
+ * IfDirective is a structural directive that conditionally includes or excludes a template
+ * based on the boolean value of the `show` input property.
+ *
+ */
+declare class IfDirective {
+    private readonly _templateRef;
+    private _vcr;
+    private _viewRef?;
+    readonly show: i0.InputSignal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IfDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IfDirective, "[ng0If]", ["ng0If"], { "show": { "alias": "ng0If"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 
-export { RTL, fillArray, flipPlacement, formatString, numberRange };
-export type { Alignment, ClaimLike, ClaimObject, DividerMenuItem, GroupMenuItem, MenuItem, MenuItemBase, Placement, TextMenuItem };
+export { CssClassAttribute, IdGeneratorAttribute, IfDirective, RTL, TrackByAttribute, comparerAttribute, defaultComparer, defaultEqualityComparer, defaultFilter, defaultValueWriter, deleteEntries, equalityComparerAttribute, filterPredicateAttribute, flipPlacement, formatString, getEnumValues, noopFilter, numberArray, sequentialIdGenerator, toObservable, trackByIndex, trackByItem, valueWriterAttribute };
+export type { Alignment, ClaimLike, ClaimObject, Comparer, ComparerLike, CssClass, CssClassGetter, CssClassLike, DividerMenuItem, EqualityComparer, EqualityComparerLike, FilterPredicate, FilterPredicateLike, HeaderMenuItem, IdGenerator, IdGeneratorLike, MenuItem, MenuItemBase, NodeMenuItem, Placement, TrackByLike, UserCondition, ValueWriter, ValueWriterLike };

package/components/accordion/index.d.ts

@@ -1,13 +1,19 @@
 import * as i0 from '@angular/core';
-import { ElementRef, Renderer2, QueryList } from '@angular/core';
+import { QueryList } from '@angular/core';
 
 declare class AccordionItemComponent {
-    private _element;
-    private _renderer;
-    private _accordion;
-    header: i0.InputSignal<string | undefined>;
-    collapsed: i0.ModelSignal<boolean>;
-    constructor(_element: ElementRef, _renderer: Renderer2, _accordion: AccordionComponent);
+    private readonly _element;
+    private readonly _renderer;
+    private readonly _accordion;
+    /**
+     * The header text of the accordion item.
+     */
+    readonly header: i0.InputSignal<string | undefined>;
+    /**
+     * Whether the accordion item is collapsed or expanded.
+     */
+    readonly collapsed: i0.ModelSignal<boolean>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AccordionItemComponent, "ng0-accordion-item", ["ng0AccordionItem"], { "header": { "alias": "header"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
 }
@@ -15,10 +21,14 @@ declare class AccordionItemComponent {
 declare class AccordionComponent {
     private _element;
     private _renderer;
-    /** Items open mode */
-    mode: i0.InputSignal<"single" | "multiple">;
+    /**
+     * The mode of the accordion - 'single' or 'multiple'.
+     * 'single' mode allows only one item to be expanded at a time.
+     * 'multiple' mode allows multiple items to be expanded simultaneously.
+     */
+    readonly mode: i0.InputSignal<"single" | "multiple">;
     readonly items: QueryList<AccordionItemComponent>;
-    constructor(_element: ElementRef, _renderer: Renderer2);
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AccordionComponent, "ng0-accordion", ["ng0Accordion"], { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
 }

package/components/button/index.d.ts

@@ -1,40 +1,37 @@
 import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, ElementRef, Renderer2, DestroyRef } from '@angular/core';
-import { HttpService } from '@bootkit/ng0/http';
+import { OnInit } from '@angular/core';
 
-declare class ButtonDirective implements OnInit, OnDestroy {
+declare class ButtonDirective implements OnInit {
+    private _loadingElement;
     private _element;
     private _renderer;
     private _http;
     private _destroyRef;
-    private _loadingElement;
     /**
      * The IDs of the HTTP requests that this button listens to.
      * If one of these requests is in progress, it will show a loading indicator or will be disabled based on 'showLoading' and 'disableOnLoading' properties.
      */
-    request: i0.InputSignal<string | string[] | undefined>;
+    readonly request: i0.InputSignal<string | string[] | undefined>;
     /**
      * Whether the button is disabled or not.
      */
-    disabled: i0.ModelSignal<boolean>;
+    readonly disabled: i0.ModelSignal<boolean>;
     /**
      * Whether to wait for the HTTP response before enabling the button again.
      * If true, the button will remain disabled until the HTTP request completes.
      * This is useful for preventing multiple clicks while waiting for a response.
      * Default is true.
      */
-    disableDuringRequest: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly disableDuringRequest: i0.InputSignalWithTransform<boolean, unknown>;
     /**
      * Whether to show a loading indicator when the HTTP request is in progress.
      * If true, a loading spinner will be displayed on the button while the request is being processed.
      * Default is true.
      */
-    loadingIndicator: i0.InputSignalWithTransform<boolean, unknown>;
-    constructor(_element: ElementRef, _renderer: Renderer2, _http: HttpService, _destroyRef: DestroyRef);
+    readonly loadingIndicator: i0.InputSignalWithTransform<boolean, unknown>;
     ngOnInit(): void;
     private _showLoading;
     private _hideLoading;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ButtonDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonDirective, "button[ng0Button], a[ng0Button], input[type=button][ng0Button], input[type=submit][ng0Button], input[type=reset][ng0Button]", ["ng0Button"], { "request": { "alias": "request"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "disableDuringRequest": { "alias": "disableDuringRequest"; "required": false; "isSignal": true; }; "loadingIndicator": { "alias": "loadingIndicator"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; }, never, never, true, never>;
 }

package/components/card/index.d.ts

@@ -1,19 +1,15 @@
 import * as i0 from '@angular/core';
-import { ElementRef, Renderer2 } from '@angular/core';
 
 declare class CardComponent {
     private _element;
     private _renderer;
-    header: i0.InputSignal<string | undefined>;
-    constructor(_element: ElementRef, _renderer: Renderer2);
+    readonly header: i0.InputSignal<string | undefined>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "ng0-card", ["ng0Card"], { "header": { "alias": "header"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class CardHeaderComponent {
-    private _element;
-    private _renderer;
-    constructor(_element: ElementRef, _renderer: Renderer2);
     static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CardHeaderComponent, "ng0-card-header", ["ng0CardHeader"], {}, {}, never, ["*"], true, never>;
 }

package/components/code/index.d.ts

@@ -1,6 +1,5 @@
 import * as i0 from '@angular/core';
 import * as _angular_platform_browser from '@angular/platform-browser';
-import { DomSanitizer } from '@angular/platform-browser';
 
 type CodeFormatterFunc = (code: string) => string;
 declare class CodeFormatter {
@@ -19,14 +18,13 @@ declare class CodeFormatters {
 }
 
 declare class CodeComponent {
-    private formatters;
-    private domSanitizer;
+    private _formatters;
+    private _domSanitizer;
     /** Code formatter name */
     formatter: i0.InputSignal<string>;
     /** Code */
     code: i0.InputSignal<string>;
     protected _safeHtml: i0.Signal<_angular_platform_browser.SafeHtml | undefined>;
-    constructor(formatters: CodeFormatters, domSanitizer: DomSanitizer);
     static ɵfac: i0.ɵɵFactoryDeclaration<CodeComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CodeComponent, "ng0-code", ["ng0Code"], { "formatter": { "alias": "formatter"; "required": true; "isSignal": true; }; "code": { "alias": "code"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/collapse/index.d.ts

@@ -1,36 +1,4 @@
 import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, ElementRef, Renderer2 } from '@angular/core';
-import { AnimationBuilder } from '@angular/animations';
-
-/**
- * Directive to handle the collapse and expand functionality of a host element.
- */
-declare class CollapseDirective implements OnInit, OnDestroy {
-    private el;
-    private builder;
-    private renderer;
-    /**
-     * Indicates whether the host element is collapsed.
-     * @input
-     */
-    collapsed: i0.InputSignal<boolean>;
-    /** Animation timings for collapse/expand animations.
-     * @input
-     */
-    timings: i0.InputSignal<string | number>;
-    private _player?;
-    private _firstExecution;
-    constructor(el: ElementRef, builder: AnimationBuilder, renderer: Renderer2);
-    ngOnInit(): void;
-    private _collapse;
-    private _expand;
-    private _playAnimation;
-    private _addClass;
-    private _removeClass;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CollapseDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CollapseDirective, "[ng0Collapse]", ["ng0Collapse"], { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "timings": { "alias": "timings"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
 
 /**
  * A component that provides collapse and expand functionality.
@@ -40,20 +8,15 @@ declare class CollapseComponent {
      * Indicates whether the host element is collapsed.
      * @model
      */
-    collapsed: i0.ModelSignal<boolean>;
-    /** Animation timings for collapse/expand animations.
-     * @input
-     */
-    timings: i0.InputSignal<string | number>;
-    private get _collapseExpand();
+    readonly collapsed: i0.InputSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CollapseComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CollapseComponent, "ng0-collapse", never, { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "timings": { "alias": "timings"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CollapseComponent, "ng0-collapse", never, { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class CollapseModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CollapseModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CollapseModule, never, [typeof CollapseDirective, typeof CollapseComponent], [typeof CollapseDirective, typeof CollapseComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CollapseModule, never, [typeof CollapseComponent], [typeof CollapseComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CollapseModule>;
 }
 
-export { CollapseComponent, CollapseDirective, CollapseModule };
+export { CollapseComponent, CollapseModule };

package/components/confirmation/index.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { OnInit, EventEmitter } from '@angular/core';
 import * as rxjs from 'rxjs';
-import { DialogRef, Dialog } from '@angular/cdk/dialog';
+import { DialogRef } from '@angular/cdk/dialog';
 
 interface ConfirmationConfig {
     message?: string;
@@ -37,23 +37,14 @@ declare class ConfirmationComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmationComponent, "ng0-confirmation", ["ng0Confirmation"], {}, {}, never, never, true, never>;
 }
 
-declare class ConfirmationService {
-    private dialog;
-    constructor(dialog: Dialog);
-    open(config?: ConfirmationConfig): ConfirmationRef;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmationService>;
-}
-
 declare class ConfirmationDirective {
-    private confirmationService;
-    config?: ConfirmationConfig;
-    confirm: EventEmitter<ConfirmationRef>;
-    cancel: EventEmitter<ConfirmationRef>;
-    constructor(confirmationService: ConfirmationService);
-    private _onClick;
+    private _confirmationService;
+    readonly config: i0.InputSignal<ConfirmationConfig | undefined>;
+    readonly confirm: EventEmitter<ConfirmationRef>;
+    readonly cancel: EventEmitter<ConfirmationRef>;
+    protected _onClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ConfirmationDirective, "[ng0Confirmation]", ["ng0Confirmation"], { "config": { "alias": "config"; "required": false; }; }, { "confirm": "confirm"; "cancel": "cancel"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConfirmationDirective, "[ng0Confirmation]", ["ng0Confirmation"], { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "confirm": "confirm"; "cancel": "cancel"; }, never, never, true, never>;
 }
 
 declare class ConfirmationModule {
@@ -62,5 +53,12 @@ declare class ConfirmationModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<ConfirmationModule>;
 }
 
+declare class ConfirmationService {
+    private _dialog;
+    open(config?: ConfirmationConfig): ConfirmationRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmationService>;
+}
+
 export { ConfirmationComponent, ConfirmationDirective, ConfirmationModule, ConfirmationRef, ConfirmationService };
 export type { ConfirmationConfig };