@acorex/components 19.15.0-next.9 → 20.0.1

package/kanban/index.d.ts

@@ -0,0 +1,56 @@
+import { NXComponent, NXNativeEvent } from '@acorex/cdk/common';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { AXDropListDroppedEvent } from '@acorex/cdk/drag-drop';
+
+declare class AXKanbanComponent extends NXComponent {
+    statuses: _angular_core.InputSignal<AXKanbanStatus[]>;
+    itemTemplate: _angular_core.InputSignal<TemplateRef<unknown>>;
+    dataSource: _angular_core.InputSignal<any[] | AXKanbanItem[]>;
+    keyField: _angular_core.InputSignal<string>;
+    indexField: _angular_core.InputSignal<string>;
+    titleField: _angular_core.InputSignal<string>;
+    cssClassField: _angular_core.InputSignal<string>;
+    priorityField: _angular_core.InputSignal<string>;
+    statusKeyField: _angular_core.InputSignal<string>;
+    descriptionField: _angular_core.InputSignal<string>;
+    onSortChanged: _angular_core.OutputEmitterRef<AXKanbanSortEvent>;
+    protected items: _angular_core.Signal<AXKanbanItem[]>;
+    protected filteredStatuses: _angular_core.Signal<AXKanbanStatus[]>;
+    /**
+     * Handles the drop event. It uses the component's current rendered state (`this.items`)
+     * as the source of truth for the operation, calculates the new state with precise
+     * re-indexing, and emits a comprehensive event with the updated data source.
+     */
+    drop(event: AXDropListDroppedEvent): void;
+    protected getListById(key: any): AXKanbanItem[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXKanbanComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXKanbanComponent, "ax-kanban", never, { "statuses": { "alias": "statuses"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "keyField": { "alias": "keyField"; "required": false; "isSignal": true; }; "indexField": { "alias": "indexField"; "required": false; "isSignal": true; }; "titleField": { "alias": "titleField"; "required": false; "isSignal": true; }; "cssClassField": { "alias": "cssClassField"; "required": false; "isSignal": true; }; "priorityField": { "alias": "priorityField"; "required": false; "isSignal": true; }; "statusKeyField": { "alias": "statusKeyField"; "required": false; "isSignal": true; }; "descriptionField": { "alias": "descriptionField"; "required": false; "isSignal": true; }; }, { "onSortChanged": "onSortChanged"; }, never, never, true, never>;
+}
+
+type AXKanbanItem = {
+    id: any;
+    index?: number;
+    title?: string;
+    statusKey: any;
+    cssClass?: string;
+    description?: string;
+    priority?: 'highest' | 'high' | 'medium' | 'low' | 'lowest';
+};
+type AXKanbanStatus = {
+    key: any;
+    title: string;
+    index?: number;
+    cssClass?: string;
+};
+interface AXKanbanSortEvent extends NXNativeEvent<AXKanbanComponent, MouseEvent> {
+    item: any;
+    allItems: any[];
+    currentIndex: number;
+    previousIndex: number;
+    currentStatusKey: any;
+    previousStatusKey: any;
+}
+
+export { AXKanbanComponent };
+export type { AXKanbanItem, AXKanbanSortEvent, AXKanbanStatus };

package/kbd/index.d.ts

@@ -1,3 +1,23 @@
-export * from './lib/kbd-item/kbd-item.component';
-export * from './lib/kbd.component';
-export * from './lib/kbd.module';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+
+declare class AXKBDItemComponent {
+    keys: i0.InputSignal<string | string[]>;
+    modifierKeys: i0.WritableSignal<string[]>;
+    capitalizeFirstLetter(text: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXKBDItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXKBDItemComponent, "ax-kbd-item", never, { "keys": { "alias": "keys"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXKBDComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXKBDComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXKBDComponent, "ax-kbd", never, {}, {}, never, ["ax-kbd-item"], true, never>;
+}
+
+declare class AXKBDModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXKBDModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXKBDModule, never, [typeof i1.CommonModule, typeof AXKBDComponent, typeof AXKBDItemComponent], [typeof AXKBDComponent, typeof AXKBDItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXKBDModule>;
+}
+
+export { AXKBDComponent, AXKBDItemComponent, AXKBDModule };

package/label/index.d.ts

@@ -1,2 +1,58 @@
-export * from './lib/label.component';
-export * from './lib/label.module';
+import { MXBaseComponent, MXValueComponent } from '@acorex/cdk/common';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import * as i1 from '@angular/common';
+
+/**
+ * Represents a label component that provides a way to display text labels within the application.
+ *
+ * @category Components
+ */
+declare class AXLabelComponent extends MXBaseComponent {
+    /**
+     * Emitted when the `required` property changes.
+     *
+     * @event
+     */
+    requiredChange: EventEmitter<boolean>;
+    /**
+     *  @ignore
+     */
+    private _required?;
+    /**
+     * Determines if the field is required.
+     *
+     * @defaultValue false
+     */
+    get required(): boolean;
+    /**
+     * Sets whether the field is required.
+     *
+     * @param v - A boolean indicating if the field is required.
+     */
+    set required(v: boolean);
+    /**
+     *  @ignore
+     */
+    private _for;
+    /**
+     * Gets the form control or component associated with the label.
+     */
+    get for(): MXValueComponent;
+    /**
+     * Sets the form control or component associated with the label.
+     *
+     * @param v The `MXValueComponent` to associate with the label.
+     */
+    set for(v: MXValueComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXLabelComponent, "ax-label", never, { "required": { "alias": "required"; "required": false; }; "for": { "alias": "for"; "required": false; }; }, { "requiredChange": "requiredChange"; }, never, ["*"], true, never>;
+}
+
+declare class AXLabelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLabelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXLabelModule, never, [typeof i1.CommonModule, typeof AXLabelComponent], [typeof AXLabelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXLabelModule>;
+}
+
+export { AXLabelComponent, AXLabelModule };

package/list/index.d.ts

@@ -1,2 +1,148 @@
-export * from './lib/list.component';
-export * from './lib/list.module';
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, WritableSignal, TemplateRef } from '@angular/core';
+import { AXEvent, MXSelectionValueComponent, AXItemClickEvent, AXDataSource, AXListDataSource } from '@acorex/cdk/common';
+import * as i1 from '@angular/common';
+import * as i2 from '@angular/cdk/scrolling';
+import * as i3 from '@acorex/core/translation';
+
+interface AXListScrollIndexChanged extends AXEvent {
+    index: number;
+}
+/**
+ * provides a list control with various input options and events for user interaction.
+ *
+ * @category Components
+ */
+declare class AXListComponent extends MXSelectionValueComponent implements OnInit {
+    /**
+     * Emitted when an item in the list is clicked.
+     *
+     * @event
+     */
+    onItemClick: EventEmitter<AXItemClickEvent<any>>;
+    /**
+     * Defines the data source for the list.
+     *
+     *  @defaultValue convertArrayToDataSource([])
+     */
+    dataSource: AXDataSource<unknown>;
+    /**
+     *  @ignore
+     */
+    itemHeightSignal: WritableSignal<number | 'auto'>;
+    /**
+     * Sets the height of each item in the list.
+     */
+    set itemHeight(v: number | 'auto');
+    /**
+     * Template for rendering individual items in the list.
+     */
+    itemTemplate: TemplateRef<unknown>;
+    /**
+     * Template to display when the list is empty.
+     */
+    emptyTemplate: TemplateRef<unknown>;
+    /**
+     * Template to show while the list is loading.
+     */
+    loadingTemplate: TemplateRef<unknown>;
+    /**
+     * Emitted when the index of the scrolled item changes.
+     *
+     * @event
+     */
+    onScrolledIndexChanged: EventEmitter<AXListScrollIndexChanged>;
+    /**
+     * Specifies whether the checkbox is enabled.
+     *
+     *  @defaultValue true
+     */
+    checkbox: boolean;
+    /**
+     *  @ignore
+     */
+    protected listDataSource: AXListDataSource<unknown>;
+    /**
+     *  @ignore
+     */
+    protected isLoading: WritableSignal<boolean>;
+    /**
+     *  @ignore
+     */
+    protected hasItems: boolean;
+    /**
+     *  @ignore
+     */
+    private lastIndex;
+    /**
+     *  @ignore
+     */
+    private postponeFocus;
+    /**
+     *  @ignore
+     */
+    private viewport;
+    trackByIdx(i: any): any;
+    /**
+     *  @ignore
+     */
+    ngOnInit(): void;
+    /**
+     *  @ignore
+     */
+    _handleOnItemClick(e: MouseEvent, item: any): void;
+    /**
+     *  @ignore
+     */
+    _handleKeydown(e: KeyboardEvent): void;
+    /**
+     *  @ignore
+     */
+    private focusItemByNav;
+    /**
+     *  @ignore
+     */
+    protected _handleOnscrolledIndexChange(e: number): void;
+    /**
+     * Retrieves an item from the data source based on the provided key.
+     *
+     * @param key The key used to identify the item.
+     * @ignore
+     */
+    getItemByKey(key: unknown): Promise<unknown> | unknown;
+    /**
+     * Renders the component by updating the viewport size, scrolling to the last index, and optionally focusing the element.
+     */
+    render(): void;
+    /**
+     * Refreshes the list by clearing the selection cache and reloading the data source.
+     * @ignore
+     */
+    refresh(clearSelection?: boolean): void;
+    /**
+     * Scrolls the viewport to the specified item index.
+     * @param index The index of the item to scroll to.
+     * @ignore
+     */
+    scrollToIndex(index: number): void;
+    /**
+     * Sets focus to the first selectable list item. If no item is available, postpones focus.
+     */
+    focus(): void;
+    /**
+     * Determines whether to show the empty template based on the presence of items and loading state.
+     * @ignore
+     */
+    showEmptyTemplate: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXListComponent, "ax-list", never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; "textField": { "alias": "textField"; "required": false; }; "textTemplate": { "alias": "textTemplate"; "required": false; }; "disabledField": { "alias": "disabledField"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "itemHeight": { "alias": "itemHeight"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "emptyTemplate": { "alias": "emptyTemplate"; "required": false; }; "loadingTemplate": { "alias": "loadingTemplate"; "required": false; }; "checkbox": { "alias": "checkbox"; "required": false; }; }, { "onValueChanged": "onValueChanged"; "disabledChange": "disabledChange"; "readOnlyChange": "readOnlyChange"; "onBlur": "onBlur"; "onFocus": "onFocus"; "onItemClick": "onItemClick"; "onScrolledIndexChanged": "onScrolledIndexChanged"; }, never, ["ax-header", "ax-footer"], true, never>;
+}
+
+declare class AXListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXListModule, never, [typeof i1.CommonModule, typeof i2.ScrollingModule, typeof i3.AXTranslationModule, typeof AXListComponent], [typeof AXListComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXListModule>;
+}
+
+export { AXListComponent, AXListModule };
+export type { AXListScrollIndexChanged };

package/loading/index.d.ts

@@ -1,6 +1,149 @@
-export * from './lib/loading-spinner.component';
-export * from './lib/loading.component';
-export * from './lib/loading.config';
-export * from './lib/loading.directive';
-export * from './lib/loading.module';
-export * from './lib/loading.service';
+import { AXStyleColorType, MXBaseComponent } from '@acorex/cdk/common';
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, InjectionToken, ElementRef } from '@angular/core';
+import * as i4 from '@angular/cdk/portal';
+import { Portal, CdkPortalOutletAttachedRef } from '@angular/cdk/portal';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i1 from '@angular/common';
+import * as i2 from '@angular/cdk/overlay';
+import * as i3 from '@angular/cdk/dialog';
+
+/**
+ * A loading spinner component that displays a rotating spinner icon.
+ * @category Components
+ */
+declare class AXLoadingSpinnerComponent {
+    /**
+     * The text to display alongside the spinner.
+     * @ignore
+     */
+    text: string;
+    /**
+     * Color of the spinner. Can be a predefined style color or a custom color.
+     * @defaultValue 'default'
+     */
+    color: AXStyleColorType | 'white' | 'black';
+    /**
+     * Size of the spinner, in pixels. This determines both the width and height of the spinner.
+     * @defaultValue 16
+     */
+    size: number;
+    /**
+     * Thickness of the spinner's border, in pixels. This affects the visual weight of the spinner's outline.
+     * @defaultValue 3
+     */
+    stroke: number;
+    /**
+     *  @ignore
+     */
+    private get __hostClass();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLoadingSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXLoadingSpinnerComponent, "ax-loading-spinner", never, { "text": { "alias": "text"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "stroke": { "alias": "stroke"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A component that displays a loading indicator.
+ * @category Components
+ */
+declare class AXLoadingComponent extends MXBaseComponent implements OnInit {
+    private config;
+    /**
+     *  @ignore
+     */
+    protected _selectedPortal: Portal<unknown>;
+    /**
+     * Emits an event when the visibility state of the component changes.
+     * @event
+     */
+    visibleChange: EventEmitter<boolean>;
+    /**
+     *  @ignore
+     */
+    private _visible;
+    /**
+     * Determines whether the component is visible or not.
+     */
+    get visible(): boolean;
+    /**
+     * Sets the visibility of the component and emits a visibility change event.
+     *
+     * @param v - A boolean value indicating whether the component should be visible.
+     */
+    set visible(v: boolean);
+    /**
+     * Specifies the type of loading indicator to display.
+     * @defaultValue 'spinner'
+     */
+    type: string;
+    /**
+     * Provides additional context or data that may be used by the component.
+     */
+    context?: unknown;
+    /**
+     *  @ignore
+     */
+    ngOnInit(): void;
+    /**
+     *  @ignore
+     */
+    protected _handleAttched(ref: CdkPortalOutletAttachedRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXLoadingComponent, "ax-loading", never, { "visible": { "alias": "visible"; "required": false; }; "type": { "alias": "type"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, never, true, never>;
+}
+
+interface AXLoadingConfig {
+    spinner: unknown;
+}
+declare const AX_LOADING_CONFIG: InjectionToken<AXLoadingConfig>;
+declare const AXLoadingDefaultConfig: AXLoadingConfig;
+type PartialLoadingConfig = Partial<AXLoadingConfig>;
+declare function loadingConfig(config?: PartialLoadingConfig): AXLoadingConfig;
+
+type LoadingContext = object;
+type LoaderId = string | number;
+declare class AXLoadingService {
+    protected loadingStates: WeakMap<object, Map<LoaderId, boolean>>;
+    protected loadingStates$: WeakMap<object, Map<LoaderId, BehaviorSubject<boolean>>>;
+    private dialog;
+    show(config?: {
+        location?: Element;
+        type?: string;
+        context?: unknown;
+    }): number;
+    hide(id: number): void;
+    doLoading<V>(source$: Observable<V>, context: LoadingContext, loaderId?: LoaderId): Observable<V>;
+    isLoading(context: LoadingContext, loaderId?: LoaderId): boolean;
+    isLoading$(context: LoadingContext, loaderId?: LoaderId | any): Observable<boolean>;
+    startLoading(context: LoadingContext, loaderId?: LoaderId): void;
+    endLoading(context: LoadingContext, loaderId?: LoaderId): void;
+    clearLoadings(): void;
+    protected setLoadingState(context: LoadingContext, state: boolean, loaderId: LoaderId): void;
+    protected hasLoadingStates(context: LoadingContext, loaderId: LoaderId): boolean;
+    protected hasContextLoadingState(context: LoadingContext): boolean;
+    protected hasLoaderLoadingState(context: LoadingContext, loaderId: LoaderId): boolean;
+    protected getLoaderId(loaderId?: LoaderId): LoaderId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXLoadingService>;
+}
+
+declare class AXLoadingDirective {
+    protected readonly elementRef: ElementRef<any>;
+    protected readonly loadingService: AXLoadingService;
+    private _hostElement;
+    private _loadingRef;
+    private _isLoading;
+    get isLoading(): boolean;
+    set isLoading(v: boolean);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLoadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXLoadingDirective, "[axIsLoading]", never, { "isLoading": { "alias": "axIsLoading"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AXLoadingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLoadingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXLoadingModule, never, [typeof i1.CommonModule, typeof i2.OverlayModule, typeof i3.DialogModule, typeof i4.PortalModule, typeof AXLoadingComponent, typeof AXLoadingDirective, typeof AXLoadingSpinnerComponent], [typeof AXLoadingComponent, typeof AXLoadingDirective, typeof AXLoadingSpinnerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXLoadingModule>;
+}
+
+export { AXLoadingComponent, AXLoadingDefaultConfig, AXLoadingDirective, AXLoadingModule, AXLoadingService, AXLoadingSpinnerComponent, AX_LOADING_CONFIG, loadingConfig };
+export type { AXLoadingConfig, PartialLoadingConfig };

package/loading-dialog/index.d.ts

@@ -1,4 +1,115 @@
-export * from './lib/loading-dialog.class';
-export * from './lib/loading-dialog.component';
-export * from './lib/loading-dialog.module';
-export * from './lib/loading-dialog.service';
+import * as i1 from '@acorex/cdk/common';
+import { AXStyleColorType, AXStyleLookType, AXHotKeyAction, MXBaseComponent } from '@acorex/cdk/common';
+import { AXDialogButtonItem } from '@acorex/components/dialog';
+import * as i2 from '@acorex/components/progress-bar';
+import { AXProgressMode } from '@acorex/components/progress-bar';
+import * as i0 from '@angular/core';
+import { WritableSignal } from '@angular/core';
+import * as i3 from '@acorex/components/loading';
+import * as i4 from '@acorex/components/decorators';
+import * as i5 from '@acorex/components/button';
+import * as i6 from '@acorex/core/translation';
+import * as i7 from '@angular/common';
+
+interface AXLoadingDialogConfig {
+    title: string;
+    mode: AXProgressMode;
+    status?: string;
+    text?: string;
+    progressValue?: number;
+    progressColor?: AXStyleColorType;
+    progressHeight?: number;
+    buttons?: AXLoadingDialogButtonItem[];
+}
+interface AXLoadingDialogButtonItem {
+    text: string;
+    color?: AXStyleColorType;
+    look?: AXStyleLookType;
+    name?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    hotkey?: string | AXHotKeyAction;
+    autofocus?: boolean;
+    onClick?: (e?: {
+        source: AXDialogButtonItem;
+        handled?: boolean;
+    }) => void;
+}
+interface AXDialogRef {
+    close(): void;
+    setProgressValue(value: number): any;
+    setProgressText(text: string): any;
+    setDialogTitle(text: string): any;
+    setProgressColor(color: AXStyleColorType): any;
+    setProgressStatus(status: string): any;
+}
+
+/**
+ * Represents a loading dialog component with custom styles and encapsulation.
+ * @category components
+ */
+declare class AXLoadingDialogComponent extends MXBaseComponent {
+    data: AXLoadingDialogConfig;
+    private dialogRef;
+    /** @ignore */
+    protected progressText: WritableSignal<string>;
+    /** @ignore */
+    protected progressStatus: WritableSignal<string>;
+    /** @ignore */
+    protected progressColor: WritableSignal<AXStyleColorType>;
+    /** @ignore */
+    protected dialogTitle: WritableSignal<string>;
+    /** @ignore */
+    protected progressValue: WritableSignal<number>;
+    /**
+     * Closes the dialog.
+     */
+    close(): void;
+    /**
+     * Sets the progress text.
+     * @param text
+     */
+    setProgressText(text: string): void;
+    /**
+     * Sets the progress status.
+     * @param status
+     */
+    setProgressStatus(status: string): void;
+    /**
+     * Sets the color for the progress.
+     * @param color
+     */
+    setProgressColor(color: AXStyleColorType): void;
+    /**
+     * Sets the title for the dialog.
+     * @param text
+     */
+    setDialogTitle(text: string): void;
+    /**
+     * Sets the progress value.
+     * @param value
+     */
+    setProgressValue(value: number): void;
+    /** @ignore */
+    protected _handleButtonClick(button: AXLoadingDialogButtonItem): void;
+    /** @ignore */
+    protected _hasAutoFocus(button: AXLoadingDialogButtonItem): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLoadingDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXLoadingDialogComponent, "ax-loading-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXLoadingDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLoadingDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXLoadingDialogModule, never, [typeof i1.AXCommonModule, typeof i2.AXProgressBarModule, typeof i3.AXLoadingModule, typeof i4.AXDecoratorModule, typeof i5.AXButtonModule, typeof i6.AXTranslationModule, typeof i7.AsyncPipe, typeof AXLoadingDialogComponent], [typeof AXLoadingDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXLoadingDialogModule>;
+}
+
+declare class AXLoadingDialogService {
+    private dialog;
+    show(options: AXLoadingDialogConfig): AXDialogRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLoadingDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXLoadingDialogService>;
+}
+
+export { AXLoadingDialogComponent, AXLoadingDialogModule, AXLoadingDialogService };
+export type { AXDialogRef, AXLoadingDialogButtonItem, AXLoadingDialogConfig };