import * as i0 from '@angular/core';
import { Type, Signal, InjectionToken, WritableSignal, PipeTransform, ComponentFactory, NgModuleRef, ElementRef, ViewContainerRef, Injector, ModelSignal, OnDestroy, AfterContentInit, ChangeDetectorRef, InputSignal, ComponentRef, TemplateRef, OnInit, Renderer2, AfterViewInit, OutputEmitterRef, OnChanges, SimpleChange, NgModule } from '@angular/core';
import * as i2$1 from '@angular/forms';
import { ValidatorFn, AsyncValidatorFn, UntypedFormControl, UntypedFormArray, AbstractControl, UntypedFormGroup, ControlValueAccessor } from '@angular/forms';
import * as rxjs from 'rxjs';
import { Observable, MonoTypeOperatorFunction, Subject, Subscription } from 'rxjs';
import { IEntity, IAddress, IDateRange } from '@smartsoft001/domain-core';
import * as _smartsoft001_models from '@smartsoft001/models';
import { IFieldOptions, IModelOptions, FieldTypeDef } from '@smartsoft001/models';
import moment from 'moment';
import * as i1 from '@ngx-translate/core';
import { TranslateService } from '@ngx-translate/core';
import * as i2 from 'ngx-cookie';
import { Store, ActionReducer, Selector } from '@ngrx/store';
import { Action } from '@ngrx/store/src/models';
import { SafeHtml } from '@angular/platform-browser';
import * as _angular_router from '@angular/router';
import { Router } from '@angular/router';
import { Editor, Toolbar } from 'ngx-editor';
import * as i9 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import * as i10 from '@angular/cdk/table';
import { CdkTableDataSourceInput } from '@angular/cdk/table';
import * as i11 from 'ng-dynamic-component';
import * as i1$1 from '@angular/common';
import * as i7 from '@angular/common/http';
import * as i8 from 'ng-lazyload-image';

/**
 * Forward declaration for InputBaseComponent to break circular dependency.
 * This is a placeholder type that will be properly typed when imported from components.
 */
type InputBaseComponentType<T = any> = Type<any>;

interface IFormProvider {
    submit(): void;
}
interface IAppProvider {
    logged: Signal<boolean>;
    username: Signal<string>;
    logout: () => void;
}

declare abstract class IModelExportProvider {
    abstract execute(type: Type<any>, value: any): void;
}
declare const MODEL_EXPORT_PROVIDER: InjectionToken<IModelExportProvider>;

declare abstract class IModelImportProvider {
    abstract getAccept(type: Type<any>): Promise<string>;
    abstract convert(type: Type<any>, file: File): Promise<any>;
}
declare const MODEL_IMPORT_PROVIDER: InjectionToken<IModelImportProvider>;

declare abstract class IModelLabelProvider {
    abstract get(options: IModelLabelOptions): Signal<string>;
}
interface IModelLabelOptions {
    key: string;
    instance?: any;
    type?: Type<any>;
}
declare const MODEL_LABEL_PROVIDER: InjectionToken<IModelLabelOptions>;

declare abstract class IModelPossibilitiesProvider {
    abstract get(options: IModelPossibilitiesOptions): WritableSignal<{
        id: any;
        text: string;
        checked: boolean;
    }[]>;
}
interface IModelPossibilitiesOptions {
    key: string;
    instance: any;
    type?: Type<any>;
}
declare const MODEL_POSSIBILITIES_PROVIDER: InjectionToken<IModelPossibilitiesProvider>;

/**
 * @example
 *
 * in module:
 @NgModule({
  providers: [
    ...
    {
      provide: MODEL_VALIDATORS_PROVIDER,
      useClass: ModelValidatorsProvider
    }
  ],
 *
 * provider:
 * @Injectable()
 export class ModelValidatorsProvider extends IModelValidatorsProvider {
  async get(options: IModelValidatorsOptions): Promise<IModelValidators> {
    if (options.type === Todo && options.key === 'test') {
      return {
        validators: null,
        asyncValidators: null
      }
    }

    if (options.type === Todo && options.key === 'number') {
      return {
        validators: [ Validators.required ],
        asyncValidators: null
      }
    }

    return Promise.resolve(options.base);
  }
}
 */
declare abstract class IModelValidatorsProvider {
    abstract get(options: IModelValidatorsOptions): Promise<IModelValidators>;
}
interface IModelValidatorsOptions {
    key: string;
    instance: any;
    type?: Type<any> | (() => void);
    base?: IModelValidators;
}
interface IModelValidators {
    validators?: ValidatorFn | ValidatorFn[];
    asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[];
}
declare const MODEL_VALIDATORS_PROVIDER: InjectionToken<IModelValidatorsProvider>;

type IStyle = Record<string, string | undefined>;
type StyleType = 'color-primary' | 'color-primary-rgb' | 'color-primary-contrast' | 'color-primary-contrast-rgb' | 'color-primary-shade' | 'color-primary-tint' | 'color-secondary' | 'color-secondary-rgb' | 'color-secondary-contrast' | 'color-secondary-contrast-rgb' | 'color-secondary-shade' | 'color-secondary-tint' | 'color-tertiary' | 'color-tertiary-rgb' | 'color-tertiary-contrast' | 'color-tertiary-contrast-rgb' | 'color-tertiary-shade' | 'color-tertiary-tint' | 'color-success' | 'color-success-rgb' | 'color-success-contrast' | 'color-success-contrast-rgb' | 'color-success-shade' | 'color-success-tint' | 'color-warning' | 'color-warning-rgb' | 'color-warning-contrast' | 'color-warning-contrast-rgb' | 'color-warning-shade' | 'color-warning-tint' | 'color-danger' | 'color-danger-rgb' | 'color-danger-contrast' | 'color-danger-contrast-rgb' | 'color-danger-shade' | 'color-danger-tint' | 'color-dark' | 'color-dark-rgb' | 'color-dark-contrast' | 'color-dark-contrast-rgb' | 'color-dark-shade' | 'color-dark-tint' | 'color-medium' | 'color-medium-rgb' | 'color-medium-contrast' | 'color-medium-contrast-rgb' | 'color-medium-shade' | 'color-medium-tint' | 'color-light' | 'color-light-rgb' | 'color-light-contrast' | 'color-light-contrast-rgb' | 'color-light-shade' | 'color-light-tint' | 'font' | 'font-weight' | 'font-style' | 'ios-font' | 'ios-font-weight' | 'ios-font-style' | 'md-font' | 'md-font-weight' | 'md-font-style' | 'button-height' | 'button-min-width' | 'button-padding-right' | 'button-padding-left' | 'button-padding-top' | 'button-padding-bottom' | 'button-icon-size' | 'phone-breakpoint' | 'tablet-breakpoint';

interface IAppOptions {
    provider: IAppProvider;
    logo?: string;
    menu?: {
        showForAnonymous?: boolean;
        items?: IMenuItem[];
    };
    style?: IStyle;
}
interface ICardOptions {
    title?: string;
    buttons?: Array<IIconButtonOptions>;
}
interface IIconButtonOptions {
    icon: string;
    text?: string;
    handler?: () => void;
    component?: any;
    type?: 'default' | 'popover';
    disabled$?: Observable<boolean>;
    number?: number;
}
type DynamicComponentType = 'form' | 'page' | 'button' | 'details' | 'list' | 'crud-list-page' | 'crud-item-page';
interface IDynamicComponentData {
    key: DynamicComponentType;
    component: Type<any>;
    data?: any;
}
interface IFormOptions<T> {
    model: T;
    show: boolean;
    treeLevel?: number;
    control?: AbstractControl;
    mode?: 'create' | 'update' | string;
    loading$?: Observable<boolean>;
    uniqueProvider?: (values: Record<keyof T, any>) => Promise<boolean>;
    possibilities?: {
        [key: string]: WritableSignal<{
            id: any;
            text: string;
            checked: boolean;
        }[]>;
    };
    inputComponents?: {
        [key: string]: InputBaseComponentType<T>;
    };
    fieldOptions?: IFieldOptions;
    modelOptions?: IModelOptions;
}
type InputOptions<T> = IInputOptions & IInputFromFieldOptions<T>;
interface IInputOptions {
    treeLevel: number;
    control: UntypedFormControl | UntypedFormArray;
    possibilities?: WritableSignal<{
        id: any;
        text: string;
        checked: boolean;
    }[]>;
    component?: InputBaseComponentType<any>;
}
interface IInputFromFieldOptions<T> {
    model: T;
    fieldKey: string;
    mode?: 'create' | 'update' | string;
}
interface IDetailsComponentFactories<T> {
    top?: ComponentFactory<any>;
    bottom?: ComponentFactory<any>;
}
interface IDetailsOptions<T extends IEntity<string>> {
    title?: string;
    cellPipe?: ICellPipe<T>;
    type: any;
    item: Signal<T>;
    loading?: Signal<boolean>;
    itemHandler?: ((id: string) => void) | null;
    removeHandler?: ((item: T) => void) | null;
    componentFactories?: IDetailsComponentFactories<T>;
}
interface IMenuItem {
    mode?: 'divider' | 'default';
    route?: string;
    click?: (arg0: IMenuItem) => void;
    caption?: string;
    component?: any;
    icon?: string;
    infos?: Array<{
        text: string;
    }>;
}
interface IButtonOptions {
    type?: 'submit' | 'button';
    expand?: 'block' | 'full' | undefined;
    confirm?: boolean;
    color?: 'primary' | 'light' | string;
    click: () => void;
    loading?: Signal<boolean>;
}
interface IDetailOptions<T> {
    key: string;
    item?: Signal<T>;
    options: IFieldOptions;
    cellPipe?: ICellPipe<T>;
    loading?: Signal<boolean>;
}
interface ICellPipe<T> extends PipeTransform {
    transform(value: T, columnName: string, translate?: (val: string) => string): string;
}
interface IPageOptions {
    title: string;
    hideHeader?: boolean;
    hideMenuButton?: boolean;
    showBackButton?: boolean;
    endButtons?: Array<IIconButtonOptions>;
    search?: {
        text: Signal<string>;
        set: (txt: string) => void;
    };
}
interface IListProvider<T> {
    getData: (filter: any) => void;
    onChangeMultiSelected?: (list: Array<T>) => void;
    onCleanMultiSelected$?: Observable<void>;
    list: Signal<T[]>;
    loading: Signal<boolean>;
}
interface IListPaginationOptions {
    mode?: PaginationMode;
    limit: number;
    loadNextPage: () => Promise<boolean>;
    loadPrevPage: () => Promise<boolean>;
    page: Signal<number>;
    totalPages: Signal<number>;
}
declare enum PaginationMode {
    infiniteScroll = "infiniteScroll",
    singlePage = "singlePage"
}
declare enum ListMode {
    mobile = "mobile",
    desktop = "desktop",
    masonryGrid = "masonryGrid"
}
interface IItemOptionsForPage {
    routingPrefix: string;
    edit: boolean;
}
interface IItemOptionsForCustom {
    select: (id: string) => void;
    edit: boolean;
}
type ItemOptions = IItemOptionsForPage | IItemOptionsForCustom;
interface IListComponentFactories<T> {
    top?: ComponentFactory<any>;
}
interface IDetailsProvider<T> {
    getData: (id: string) => void;
    clearData: () => void;
    item: Signal<T>;
    loading: Signal<boolean>;
}
interface IListOptions<T> {
    provider: IListProvider<T>;
    type: any;
    mode?: ListMode;
    pagination?: IListPaginationOptions;
    cellPipe?: ICellPipe<T>;
    componentFactories?: IListComponentFactories<T>;
    sort?: boolean | {
        default?: string;
        defaultDesc?: boolean;
    };
    details?: boolean | {
        provider?: IDetailsProvider<T>;
        componentFactories?: IDetailsComponentFactories<T>;
        component?: Type<any>;
    };
    item?: boolean | {
        options?: ItemOptions;
    };
    remove?: boolean | {
        provider?: IRemoveProvider<T>;
    };
    select?: 'multi';
}
interface IRemoveProvider<T> {
    invoke: (id: string) => void;
    check?: (item: T) => boolean;
}
interface IListInternalOptions<T> extends IListOptions<T> {
    fields?: Array<{
        key: string;
        options: IFieldOptions;
    }>;
}

declare class AppService {
    private titleService;
    private translate;
    private router;
    private static _endButtonsSource$;
    private static _titleSource$;
    private _baseTitle;
    endButtons$: rxjs.Observable<AppEndButton[]>;
    title$: rxjs.Observable<string>;
    addEndButton(button: AppEndButton): void;
    removeEndButton(buttonOrId: AppEndButton | string): void;
    initTitle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
}
type AppEndButton = IIconButtonOptions & {
    id?: string;
};

interface month {
    dates: moment.Moment[];
    number: string;
    monthName: string;
    year: string;
}
interface state {
    date: moment.Moment;
    calendar: month[];
}
declare class CalendarService {
    state: state;
    constructor();
    setState: (nextState: Partial<state>) => void;
    getCalendar(): month[];
    generatePrevMonths(): void;
    generateNextMonths(): void;
    private initCalendar;
    private previousMonth;
    private filterFutureDates;
    private generateMonth;
    private generateMonthDates;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarService>;
}

declare class StorageService {
    setItem(key: string, value: any): void;
    getItem(key: string): any;
    removeItem(key: string): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
}

declare const AUTH_TOKEN = "AUTH_TOKEN";
declare class AuthService {
    protected storageService: StorageService;
    isAuthenticated(): boolean;
    expectPermissions(permissions: Array<string> | null): boolean;
    getPermissions(): Array<string>;
    getTokenPayload(): any;
    protected getRawToken(): {
        access_token: string;
    } | null;
    protected getToken(): {
        access_token: string;
    } | null;
    setToken(token: {
        access_token: string;
    } | null): void;
    removeToken(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
}

declare class DetailsService {
    private _root;
    get $root(): any;
    constructor();
    init(): void;
    setRoot(obj: any, force?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DetailsService>;
}

declare class DynamicComponentLoader<T> {
    private resolver;
    static declaredComponents: any[];
    getComponentsWithFactories<C>(options: {
        components: Array<any>;
    }): Promise<{
        component: any;
        factory: ComponentFactory<any>;
    }[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentLoader<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicComponentLoader<any>>;
}

declare const DYNAMIC_COMPONENTS_STORE: InjectionToken<[Type<any>]>;
declare class DynamicComponentStorageService {
    static get(key: DynamicComponentType, moduleRef: NgModuleRef<any>): Type<any>[];
}

declare const FILE_SERVICE_CONFIG: InjectionToken<IFileServiceConfig>;
interface IFileServiceConfig {
    apiUrl: string;
}
declare class FileService {
    private config;
    private http;
    upload<T>(file: File, callback?: (result: T) => void): Observable<number>;
    download(id: string): void;
    delete(id: string): Promise<void>;
    getUrl(id: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FileService>;
}

declare class SmartFormGroup extends UntypedFormGroup {
    static create(): SmartFormGroup;
    setForm(form: UntypedFormGroup): void;
}

declare class StyleService {
    private platformId;
    static style: IStyle | null;
    private _elementRef;
    static create(platformId: object, el: ElementRef, style?: Partial<IStyle>): StyleService;
    constructor(platformId: object);
    init(el: ElementRef, style?: IStyle): void;
    set(style?: IStyle): void;
    private execute;
    private setColor;
    private setProperty;
    private setFont;
    private setButton;
    private setMobileBreakpoint;
    static ɵfac: i0.ɵɵFactoryDeclaration<StyleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StyleService>;
}

declare class ToastService {
    static lockError: number;
    addLockError(): void;
    removeLockError(): void;
    error(config: IToastOptions): Promise<void>;
    info(config: IToastOptions): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
}
interface IToastOptions {
    title?: string;
    message: string;
    duration?: number;
    buttons?: Array<IToastButton>;
}
interface IToastButton {
    text: string;
    position: 'start' | 'end';
    handler: () => void;
}

declare class HardwareService {
    get isMobile(): boolean;
    get isMobileWeb(): boolean;
    onBackButtonClick(callback: () => void): Promise</*PluginListenerHandle*/ any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HardwareService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HardwareService>;
}

/**
 * Only to use in smart-page
 * @requires PageComponent
 */
declare class MenuService {
    private readonly resolver;
    private _endContainer;
    private _openedEnd;
    menuItems: i0.WritableSignal<IMenuItem[]>;
    disabled: i0.WritableSignal<boolean>;
    /**
     * @desc checking if the menu is open (menu on the right side of the screen)
     */
    get openedEnd(): boolean;
    enable(): void;
    disable(): void;
    changeMenuItemByRoute(route: string, changes: Partial<IMenuItem>): void;
    setMenuItems(items: IMenuItem[]): void;
    /**
     * @private
     */
    init(endContainer: ViewContainerRef): Promise<void>;
    /**
     * @desc open menu (menu on the right side of the screen)
     * @param {object} options - use options
     * @param {class} options.component - angular component to render
     * @param {class} options.injector - angular injector to use in component
     */
    openEnd(options: {
        component: any;
        injector: Injector;
    }): Promise<void>;
    /**
     * @desc close menu (menu on the left side of the screen)
     */
    closeStart(): Promise<void>;
    /**
     * @desc close menu (menu on the right side of the screen)
     */
    closeEnd(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MenuService>;
}

declare class ModalService {
    show(options: IModalOptions): Promise<IModal>;
    dismiss<T>(data?: T | null): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
}
interface IModalOptions {
    component: any;
    props?: any;
    mode?: 'default' | 'bottom';
    cssClass?: string[];
    backdropDismiss?: boolean;
}
interface IModal {
    dismiss: () => void;
    onDidDismiss(): Promise<{
        data: any;
    }>;
}

declare class AlertService {
    show(options: IAlertOptions): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AlertService>;
}
interface IAlertOptions {
    header?: string;
    subHeader?: string;
    message?: string;
    backdropDismiss?: boolean;
    buttons?: Array<IAlertButton>;
}
interface IAlertButton {
    text: string;
    role?: 'cancel' | 'destructive' | string;
    cssClass?: string | string[];
    handler?: (value: any) => boolean | void | {
        [key: string]: any;
    };
}

declare class PopoverService {
    close(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PopoverService>;
}

declare class UIService {
    showAlertWithDismissCallback(heading: string, msg: string, btnText: string, callback: () => void): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UIService>;
}

declare class SharedServicesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedServicesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedServicesModule, never, [typeof i1.TranslateModule, typeof i2.CookieModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedServicesModule>;
}

declare class NgrxStoreService {
    private static _reducers;
    static store: Store<any> | undefined;
    static addReducer<State, Actions extends Action = Action>(key: string, reducer: ActionReducer<State, Actions>): void;
    connect(store: Store<any>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgrxStoreService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgrxStoreService>;
}

declare class ErrorService {
    private toastService;
    private translateService;
    constructor(toastService: ToastService, translateService: TranslateService);
    log(obj: any): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorService>;
}

declare class DynamicContentDirective {
    container: ViewContainerRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicContentDirective, ".dynamic-content", never, {}, {}, never, never, true, never>;
}

declare class DetailsDirective {
    private modalService;
    private hardwareService;
    options: i0.InputSignal<{
        component: any;
        params: any;
        mode?: "bottom" | "default";
    }>;
    smartDetailsShowed: i0.OutputEmitterRef<void>;
    smartDetailsDismissed: i0.OutputEmitterRef<void>;
    click(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DetailsDirective, "[smartDetails]", never, { "options": { "alias": "smartDetails"; "required": true; "isSignal": true; }; }, { "smartDetailsShowed": "smartDetailsShowed"; "smartDetailsDismissed": "smartDetailsDismissed"; }, never, never, true, never>;
}

declare class SharedDirectivesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedDirectivesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedDirectivesModule, never, [typeof SharedServicesModule, typeof DynamicContentDirective], [typeof DynamicContentDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedDirectivesModule>;
}

declare class EnumToListPipe implements PipeTransform {
    transform(value: any): Array<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<EnumToListPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EnumToListPipe, "smartEnumToList", true>;
}

declare class FileUrlPipe implements PipeTransform {
    private service;
    transform(file: {
        id: any;
    }): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUrlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FileUrlPipe, "smartFileUrl", true>;
}

declare class ListCellPipe<T extends {
    [key: string]: any;
}> implements PipeTransform {
    private readonly translateService;
    transform(obj: T, key: string, pipe: ICellPipe<T>, type?: Type<T>): {
        value?: any;
        type?: FieldTypeDef | null;
    };
    private getFieldType;
    private getValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListCellPipe<any>, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ListCellPipe<any>, "smartListCell", true>;
}

declare class ListHeaderPipe<T> implements PipeTransform {
    private translateService;
    private modelLabelProvider;
    transform(data: T, key: string, type?: Type<any>): Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListHeaderPipe<any>, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ListHeaderPipe<any>, "smartListHeader", true>;
}

declare class ModelLabelPipe<T> implements PipeTransform {
    private translateService;
    private modelLabelProvider;
    transform(instance: T, key: string, type?: Type<any> | (() => void)): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModelLabelPipe<any>, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ModelLabelPipe<any>, "smartModelLabel", true>;
}

declare class SlugPipe implements PipeTransform {
    transform(value: string | undefined | null): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlugPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SlugPipe, "smartSlug", true>;
}

declare class TrustHtmlPipe implements PipeTransform {
    private sanitizer;
    transform(val: string): SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<TrustHtmlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TrustHtmlPipe, "smartTrustHtml", true>;
}

declare const PIPES: (typeof EnumToListPipe | typeof ListCellPipe | typeof ListHeaderPipe | typeof ModelLabelPipe | typeof SlugPipe | typeof TrustHtmlPipe)[];
declare class SharedPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedPipesModule, never, [typeof EnumToListPipe, typeof ListCellPipe, typeof ListHeaderPipe, typeof ModelLabelPipe, typeof SlugPipe, typeof TrustHtmlPipe], [typeof EnumToListPipe, typeof ListCellPipe, typeof ListHeaderPipe, typeof ModelLabelPipe, typeof SlugPipe, typeof TrustHtmlPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedPipesModule>;
}

declare class AccordionComponent {
    show: ModelSignal<boolean>;
    update(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionComponent, "smart-accordion", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; }, { "show": "showChange"; }, never, ["smart-accordion-header", "smart-accordion-body"], true, never>;
}

declare class AccordionBodyComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionBodyComponent, "smart-accordion-body", never, {}, {}, never, ["*"], true, never>;
}

declare class AccordionHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionHeaderComponent, "smart-accordion-header", never, {}, {}, never, ["*"], true, never>;
}

declare abstract class AppBaseComponent implements OnDestroy, AfterContentInit {
    protected router: Router;
    protected cd: ChangeDetectorRef;
    protected elementRef: ElementRef<any>;
    protected styleService: StyleService;
    protected menuService: MenuService;
    protected authService: AuthService;
    protected appService: AppService;
    protected readonly platformId: Object;
    protected document: Document;
    private readonly injector;
    private _subscriptions;
    selectedPath: string;
    showMenu: Signal<boolean>;
    menuItems: Signal<IMenuItem[]>;
    logged: Signal<boolean>;
    username: Signal<string>;
    loadingPage: Signal<boolean>;
    logo: string | undefined;
    routerEvents: Signal<_angular_router.Event | undefined>;
    options: InputSignal<IAppOptions>;
    endMenuContainer: Signal<ViewContainerRef | undefined>;
    constructor();
    logout(): void;
    ngAfterContentInit(): Promise<void>;
    ngOnDestroy(): void;
    private initMenu;
    private initSelectedPath;
    private initLoader;
    private refreshStyles;
    private initPermissionClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppBaseComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AppBaseComponent, never, never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare abstract class BaseComponent implements OnDestroy {
    get takeUntilDestroy(): MonoTypeOperatorFunction<any>;
    destroy$: Subject<boolean>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseComponent, never, never, {}, {}, never, never, true, never>;
}
interface IDynamicComponent<T> extends BaseComponent {
    baseInstance: T;
    baseComponentRef: ComponentRef<T>;
    template: WritableSignal<'custom' | 'default'>;
    contentTpl: Signal<TemplateRef<any> | ViewContainerRef | undefined>;
    dynamicContents: Signal<readonly DynamicContentDirective[]>;
    refreshProperties(): void;
    refreshDynamicInstance(): void;
}
declare function CreateDynamicComponent<T extends {
    contentTpl: Signal<TemplateRef<any> | ViewContainerRef | undefined>;
} = any>(type: DynamicComponentType): new () => IDynamicComponent<T>;

declare abstract class ButtonBaseComponent {
    static smartType: DynamicComponentType;
    mode: WritableSignal<'default' | 'confirm'>;
    options: InputSignal<IButtonOptions>;
    disabled: InputSignal<boolean>;
    contentTpl: i0.Signal<ViewContainerRef | undefined>;
    invoke(): void;
    confirmInvoke(): void;
    confirmCancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonBaseComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonBaseComponent, never, never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const ButtonComponent_base: new () => IDynamicComponent<ButtonBaseComponent>;
declare class ButtonComponent extends ButtonComponent_base {
    options: i0.InputSignal<IButtonOptions>;
    disabled: i0.InputSignal<boolean>;
    contentTpl: i0.Signal<ViewContainerRef | undefined>;
    dynamicContents: i0.Signal<readonly DynamicContentDirective[]>;
    constructor();
    refreshProperties(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "smart-button", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class ButtonStandardComponent extends ButtonBaseComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonStandardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonStandardComponent, "smart-button-standard", never, {}, {}, never, ["*"], true, never>;
}

declare abstract class InputBaseComponent<T> extends BaseComponent {
    protected cd: ChangeDetectorRef;
    internalOptions: InputOptions<T>;
    control: UntypedFormControl | UntypedFormArray | UntypedFormGroup;
    required: boolean;
    possibilities: WritableSignal<Array<{
        id: any;
        text: string;
        checked: boolean;
    }> | null>;
    fieldOptions: i0.InputSignal<IFieldOptions | undefined>;
    options: i0.InputSignal<InputOptions<T> | undefined>;
    constructor();
    protected afterSetOptionsHandler(): void;
    private setRequired;
    get formControl(): UntypedFormControl;
    get formControlArray(): UntypedFormArray;
    get formControlGroup(): UntypedFormGroup;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputBaseComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InputBaseComponent<any>, never, never, { "fieldOptions": { "alias": "fieldOptions"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class InputAddressComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputAddressComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputAddressComponent<any>, "smart-input-address", never, {}, {}, never, never, true, never>;
}

declare class InputColorComponent<T> extends InputBaseComponent<T> {
    color: string;
    protected afterSetOptionsHandler(): void;
    selectColor(color: string): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputColorComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputColorComponent<any>, "smart-input-color", never, {}, {}, never, never, true, never>;
}

declare class InputCurrencyComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputCurrencyComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputCurrencyComponent<any>, "smart-input-currency", never, {}, {}, never, never, true, never>;
}

declare class InputDateWithEditComponent<T> extends InputBaseComponent<T> implements OnDestroy {
    private _subscriptions;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateWithEditComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateWithEditComponent<any>, "smart-input-date-with-edit", never, {}, {}, never, never, true, never>;
}

declare class InputDateComponent<T> extends InputBaseComponent<T> implements OnInit {
    private hardwareService;
    get isMobile(): boolean;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateComponent<any>, "smart-input-date", never, {}, {}, never, never, true, never>;
}

declare class InputEmailComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputEmailComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputEmailComponent<any>, "smart-input-email", never, {}, {}, never, never, true, never>;
}

declare class InputEnumComponent<T> extends InputBaseComponent<T> {
    value: Array<string>;
    protected afterSetOptionsHandler(): void;
    checked(item: string): boolean;
    change(item: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputEnumComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputEnumComponent<any>, "smart-input-enum", never, {}, {}, never, never, true, never>;
}

declare class InputErrorComponent {
    errors: i0.InputSignal<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputErrorComponent, "smart-input-error", never, { "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * @example
 *
 * set accepts (possibilities property):
 * - @Field({
        create: {
            ...modifyMetdata,
            required: false
        },
        update: {
            ...modifyMetdata,
            required: false,
            multi: true
        },
        type: FieldType.image,
        details: true,
        possibilities: '.jpg',
        list: { order: 1 }
    })
 */
declare class InputFileComponent<T> extends InputBaseComponent<T> {
    addButtonOptions: {
        click: () => void;
    };
    inputElementRef: i0.Signal<ElementRef<any> | undefined>;
    changeListener($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputFileComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputFileComponent<any>, "smart-input-file", never, {}, {}, never, never, true, never>;
}

declare class InputFlagComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputFlagComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputFlagComponent<any>, "smart-input-flag", never, {}, {}, never, never, true, never>;
}

declare class InputComponent<T> implements OnInit {
    private componentFactoryResolver;
    private injector;
    status: any;
    fieldOptions: IFieldOptions | undefined;
    FieldType: typeof _smartsoft001_models.FieldTypeDef;
    componentRef: i0.Signal<ViewContainerRef | undefined>;
    options: i0.InputSignal<InputOptions<T> | undefined>;
    constructor();
    oSetValue($event: any): void;
    ngOnInit(): Promise<void>;
    private initStyles;
    private initCustomComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent<any>, "smart-input", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class InputIntComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputIntComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputIntComponent<any>, "smart-input-int", never, {}, {}, never, never, true, never>;
}

declare class InputLongTextComponent<T> extends InputBaseComponent<T> implements OnInit, OnDestroy {
    private translateService;
    hardwareService: HardwareService;
    editor: Editor;
    toolbar: Toolbar;
    placeholder: string;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputLongTextComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputLongTextComponent<any>, "smart-input-long-text", never, {}, {}, never, never, true, never>;
}

declare class InputNipComponent<T> extends InputBaseComponent<T> {
    afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputNipComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputNipComponent<any>, "smart-input-nip", never, {}, {}, never, never, true, never>;
}

declare class InputObjectComponent<T, TChild> extends InputBaseComponent<T> {
    formComponent: any;
    childOptions: IFormOptions<TChild>;
    protected afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputObjectComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputObjectComponent<any, any>, "smart-input-object", never, {}, {}, never, never, true, never>;
}

declare class InputPasswordComponent<T> extends InputBaseComponent<T> {
    valid: boolean;
    focus: boolean;
    afterSetOptionsHandler(): void;
    onChangePasswordStrength(valid: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputPasswordComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputPasswordComponent<any>, "smart-input-password", never, {}, {}, never, never, true, never>;
}

declare abstract class InputPossibilitiesBaseComponent<T> extends InputBaseComponent<T> {
    private modelPossibilitiesProvider;
    protected afterSetOptionsHandler(): void;
    protected getPossibilitiesFromProvider(): WritableSignal<{
        id: any;
        text: string;
        checked: boolean;
    }[] | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputPossibilitiesBaseComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InputPossibilitiesBaseComponent<any>, never, never, {}, {}, never, never, true, never>;
}

declare class InputRadioComponent<T> extends InputPossibilitiesBaseComponent<T> {
    protected afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputRadioComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputRadioComponent<any>, "smart-input-radio", never, {}, {}, never, never, true, never>;
}

declare class InputStringsComponent<T> extends InputBaseComponent<T> {
    private fb;
    list: Array<UntypedFormControl>;
    afterSetOptionsHandler(): void;
    onItemChange(): void;
    private refresh;
    private add;
    removeItem(item: UntypedFormControl): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputStringsComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputStringsComponent<any>, "smart-input-strings", never, {}, {}, never, never, true, never>;
}

declare class InputTextComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputTextComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputTextComponent<any>, "smart-input-text", never, {}, {}, never, never, true, never>;
}

declare class InputLogoComponent<T> extends InputBaseComponent<T> {
    set(inputFile: HTMLInputElement): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputLogoComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputLogoComponent<any>, "smart-input-logo", never, {}, {}, never, never, true, never>;
}

declare class InputCheckComponent<T> extends InputPossibilitiesBaseComponent<T> {
    possibilities: WritableSignal<Array<{
        id: any;
        text: string;
        checked: boolean;
    }> | null>;
    protected afterSetOptionsHandler(): void;
    refresh(item: {
        id: any;
        text: string;
        checked: boolean;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputCheckComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputCheckComponent<any>, "smart-input-check", never, {}, {}, never, never, true, never>;
}

declare class InputIntsComponent<T> extends InputBaseComponent<T> {
    private fb;
    list: Array<UntypedFormControl>;
    afterSetOptionsHandler(): void;
    onItemChange(): void;
    private refresh;
    private add;
    removeItem(item: UntypedFormControl): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputIntsComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputIntsComponent<any>, "smart-input-ints", never, {}, {}, never, never, true, never>;
}

declare class InputPhoneNumberComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputPhoneNumberComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputPhoneNumberComponent<any>, "smart-input-phone-number", never, {}, {}, never, never, true, never>;
}

declare class InputPeselComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputPeselComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputPeselComponent<any>, "smart-input-pesel", never, {}, {}, never, never, true, never>;
}

declare class InputArrayComponent<T, TChild> extends InputBaseComponent<T> {
    childOptions: Array<IFormOptions<TChild>>;
    formComponent: any;
    private factory;
    addButtonOptions: IButtonOptions;
    FieldType: typeof _smartsoft001_models.FieldTypeDef;
    protected afterSetOptionsHandler(): void;
    onRemove(index: number): void;
    private initData;
    drop(event: CdkDragDrop<T, any>): void;
    private getOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputArrayComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputArrayComponent<any, any>, "smart-input-array", never, {}, {}, never, never, true, never>;
}

declare abstract class InputFileBaseComponent<T> extends InputBaseComponent<T> implements OnInit {
    protected renderer: Renderer2;
    protected fileService: FileService;
    protected toastService: ToastService;
    protected translateService: TranslateService;
    valid: boolean;
    oldId: number;
    file: File | null;
    loading: WritableSignal<boolean>;
    percent: Signal<number | undefined>;
    addButtonOptions: IButtonOptions;
    showButtonOptions: IButtonOptions;
    deleteButtonOptions: IButtonOptions;
    inputElementRef: Signal<ElementRef<any> | undefined>;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputFileBaseComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InputFileBaseComponent<any>, never, never, {}, {}, never, never, true, never>;
}

declare class InputPdfComponent<T> extends InputFileBaseComponent<T> implements OnInit {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputPdfComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputPdfComponent<any>, "smart-input-pdf", never, {}, {}, never, never, true, never>;
}

declare class InputVideoComponent<T> extends InputFileBaseComponent<T> implements OnInit {
    url: string | null;
    play: boolean;
    playButtonOptions: IButtonOptions;
    protected afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputVideoComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputVideoComponent<any>, "smart-input-video", never, {}, {}, never, never, true, never>;
}

declare class InputAttachmentComponent<T> extends InputFileBaseComponent<T> implements OnInit {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputAttachmentComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputAttachmentComponent<any>, "smart-input-attachment", never, {}, {}, never, never, true, never>;
}

declare class InputDateRangeComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateRangeComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateRangeComponent<any>, "smart-input-date-range", never, {}, {}, never, never, true, never>;
}

declare class InputImageComponent<T> extends InputFileBaseComponent<T> implements OnInit {
    imageUrl: any;
    ngOnInit(): void;
    private initImage;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputImageComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputImageComponent<any>, "smart-input-image", never, {}, {}, never, never, true, never>;
}

declare class InputFloatComponent<T> extends InputBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputFloatComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputFloatComponent<any>, "smart-input-float", never, {}, {}, never, never, true, never>;
}

declare class InputPhoneNumberPlComponent<T> extends InputBaseComponent<T> {
    afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputPhoneNumberPlComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputPhoneNumberPlComponent<any>, "smart-input-phone-number-pl", never, {}, {}, never, never, true, never>;
}

declare abstract class FormBaseComponent<T> extends BaseComponent {
    protected cd: ChangeDetectorRef;
    static smartType: DynamicComponentType;
    private _fields;
    private _subscription;
    private _model;
    private _possibilities;
    private _inputComponents;
    mode: string;
    treeLevel: number | undefined;
    get fields(): Array<string>;
    get model(): any;
    get possibilities(): {
        [key: string]: WritableSignal<{
            id: any;
            text: string;
            checked: boolean;
        }[]>;
    };
    get inputComponents(): {
        [key: string]: Type<InputBaseComponent<T>>;
    };
    form: i0.InputSignal<UntypedFormGroup>;
    options: i0.InputSignal<IFormOptions<T>>;
    invokeSubmit: i0.OutputEmitterRef<any>;
    contentTpl: i0.Signal<ViewContainerRef | undefined>;
    constructor();
    submit(): void;
    protected afterSetOptions(): void;
    protected afterSetForm(): void;
    getUntypedFormControl(field: string): UntypedFormControl;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormBaseComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormBaseComponent<any>, never, never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; }, { "invokeSubmit": "invokeSubmit"; }, never, never, true, never>;
}

declare const FormComponent_base: new () => IDynamicComponent<FormBaseComponent<any>>;
declare class FormComponent<T> extends FormComponent_base implements OnDestroy {
    exportProvider: IModelExportProvider | null;
    importProvider: IModelImportProvider | null;
    private formFactory;
    private cd;
    private elementRef;
    private _options;
    private _subscription;
    private _mode;
    private _uniqueProvider;
    form: SmartFormGroup;
    type: 'standard' | 'custom';
    export: boolean;
    exportHandler: (val: any) => void;
    import: boolean;
    importAccept: string | undefined;
    customTpl: Signal<ViewContainerRef | undefined>;
    options: i0.InputSignal<IFormOptions<T>>;
    invokeSubmit: i0.OutputEmitterRef<void>;
    valueChange: i0.OutputEmitterRef<T>;
    valuePartialChange: i0.OutputEmitterRef<Partial<T>>;
    validChange: i0.OutputEmitterRef<boolean>;
    contentTpl: Signal<TemplateRef<any> | undefined>;
    dynamicContents: Signal<readonly DynamicContentDirective[]>;
    constructor();
    onSetValue(file: File): Promise<void>;
    refreshProperties(): void;
    ngOnDestroy(): void;
    private initLoading;
    private registerChanges;
    private initType;
    private initExportImport;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent<any>, "smart-form", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; }, { "invokeSubmit": "invokeSubmit"; "valueChange": "valueChange"; "valuePartialChange": "valuePartialChange"; "validChange": "validChange"; }, never, never, true, never>;
}

declare class FormStandardComponent<T> extends FormBaseComponent<T> {
    get__smartDisabled(field: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormStandardComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormStandardComponent<any>, "smart-form-standard", never, {}, {}, never, never, true, never>;
}

declare class ExportComponent {
    value: i0.InputSignal<any>;
    fileName: i0.InputSignal<string | undefined>;
    handler: i0.InputSignal<(value: any) => void>;
    onClick(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExportComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExportComponent, "smart-export", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; "handler": { "alias": "handler"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ImportComponent implements AfterViewInit {
    private renderer;
    accept: i0.InputSignal<string | undefined>;
    set: i0.OutputEmitterRef<File>;
    inputElementRef: i0.Signal<ElementRef<any> | undefined>;
    constructor(renderer: Renderer2);
    onClick(): Promise<void>;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImportComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImportComponent, "smart-import", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; }, { "set": "set"; }, never, never, true, never>;
}

declare abstract class PageBaseComponent implements OnInit, OnDestroy {
    private el;
    private renderer;
    private location;
    appService: AppService;
    hardwareService: HardwareService;
    static smartType: DynamicComponentType;
    options: i0.InputSignal<IPageOptions | null | undefined>;
    private _subscriptions;
    get isMobile(): boolean;
    contentTpl: i0.Signal<ViewContainerRef | TemplateRef<any> | undefined>;
    back(): void;
    presentPopover(ev: any, btn: IIconButtonOptions): Promise<void>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageBaseComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PageBaseComponent, never, never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class PageStandardComponent extends PageBaseComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<PageStandardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageStandardComponent, "smart-page-standard", never, {}, {}, never, ["*"], true, never>;
}

declare const PageComponent_base: new () => IDynamicComponent<PageBaseComponent>;
declare class PageComponent extends PageComponent_base implements OnInit {
    private el;
    private renderer;
    options: i0.InputSignal<IPageOptions | null | undefined>;
    contentTpl: i0.Signal<TemplateRef<any> | undefined>;
    dynamicContents: i0.Signal<readonly DynamicContentDirective[]>;
    constructor();
    ngOnInit(): void;
    refreshProperties(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageComponent, "smart-page", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare abstract class DetailsBaseComponent<T extends IEntity<string>> implements AfterViewInit {
    private authService;
    private detailsService;
    static smartType: DynamicComponentType;
    private _fields;
    private _type;
    componentFactories: IDetailsComponentFactories<T> | null;
    cellPipe: WritableSignal<ICellPipe<T> | null>;
    get fields(): Array<{
        key: string;
        options: IFieldOptions;
    }> | null;
    get type(): any;
    item: Signal<T | undefined> | undefined;
    loading: Signal<boolean> | undefined;
    contentTpl: Signal<ViewContainerRef | undefined>;
    topTpl: Signal<ViewContainerRef | undefined>;
    bottomTpl: Signal<ViewContainerRef | undefined>;
    options: i0.InputSignal<IDetailsOptions<T> | undefined>;
    constructor();
    ngAfterViewInit(): void;
    protected generateDynamicComponents(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsBaseComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DetailsBaseComponent<any>, never, never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DetailsStandardComponent<T extends IEntity<string>> extends DetailsBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsStandardComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailsStandardComponent<any>, "smart-details-standard", never, {}, {}, never, never, true, never>;
}

declare const DetailsComponent_base: new () => IDynamicComponent<DetailsBaseComponent<any>>;
declare class DetailsComponent<T extends IEntity<string>> extends DetailsComponent_base implements OnDestroy {
    private detailsService;
    item: T | null;
    options: i0.InputSignal<IDetailsOptions<T> | undefined>;
    contentTpl: i0.Signal<TemplateRef<any> | undefined>;
    dynamicContents: i0.Signal<readonly DynamicContentDirective[]>;
    constructor(detailsService: DetailsService);
    refreshProperties(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailsComponent<any>, "smart-details", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardComponent {
    readonly options: InputSignal<ICardOptions | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "smart-card", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class DetailComponent<T extends IEntity<string> | undefined> {
    FieldType: typeof _smartsoft001_models.FieldTypeDef;
    readonly options: InputSignal<IDetailOptions<T> | undefined>;
    readonly type: InputSignal<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailComponent<any>, "smart-detail", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare abstract class DetailBaseComponent<T> {
    protected cd: ChangeDetectorRef;
    options: i0.InputSignal<IDetailOptions<T> | undefined>;
    constructor();
    protected afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailBaseComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DetailBaseComponent<any>, never, never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DetailTextComponent<T> extends DetailBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailTextComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailTextComponent<any>, "smart-detail-text", never, {}, {}, never, never, true, never>;
}

declare class DetailEmailComponent<T extends {
    [key: string]: any;
} | undefined> extends DetailBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailEmailComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailEmailComponent<any>, "smart-detail-email", never, {}, {}, never, never, true, never>;
}

declare class DetailEnumComponent<T extends {
    [key: string]: any;
} | undefined> extends DetailBaseComponent<T> {
    protected getValues(item: T, key: string): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailEnumComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailEnumComponent<any>, "smart-detail-enum", never, {}, {}, never, never, true, never>;
}

declare class DetailFlagComponent<T extends {
    [key: string]: any;
} | undefined> extends DetailBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailFlagComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailFlagComponent<any>, "smart-detail-flag", never, {}, {}, never, never, true, never>;
}

declare class DetailAddressComponent<T extends {
    [key: string]: any;
} | undefined> extends DetailBaseComponent<T> {
    thisAddress: Signal<IAddress>;
    protected afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailAddressComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailAddressComponent<any>, "smart-detail-address", never, {}, {}, never, never, true, never>;
}

declare class DetailObjectComponent<T extends (IEntity<string> & {
    [key: string]: any;
}) | undefined, TChild extends IEntity<string>> extends DetailBaseComponent<T> {
    detailsComponent: any;
    childOptions: Signal<IDetailsOptions<TChild> | null>;
    protected afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailObjectComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailObjectComponent<any, any>, "smart-detail-object", never, {}, {}, never, never, true, never>;
}

declare class DetailColorComponent<T extends {
    [key: string]: any;
} | undefined> extends DetailBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailColorComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailColorComponent<any>, "smart-detail-color", never, {}, {}, never, never, true, never>;
}

declare class DetailLogoComponent<T extends {
    [key: string]: any;
} | undefined> extends DetailBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailLogoComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailLogoComponent<any>, "smart-detail-logo", never, {}, {}, never, never, true, never>;
}

declare class DetailArrayComponent<T extends {
    [key: string]: any;
} | undefined, TChild extends IEntity<string>> extends DetailBaseComponent<T> {
    detailsComponent: any;
    childOptions: Signal<IDetailsOptions<TChild>[]>;
    protected afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailArrayComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailArrayComponent<any, any>, "smart-detail-array", never, {}, {}, never, never, true, never>;
}

declare class DetailPdfComponent<T extends IEntity<string> | undefined> extends DetailBaseComponent<T> {
    private fileService;
    getButtonOptions(item: T): IButtonOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailPdfComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailPdfComponent<any>, "smart-detail-pdf", never, {}, {}, never, never, true, never>;
}

declare class DetailVideoComponent<T extends IEntity<string> | undefined> extends DetailBaseComponent<T> {
    private fileService;
    getUrl(item: T): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailVideoComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailVideoComponent<any>, "smart-detail-video", never, {}, {}, never, never, true, never>;
}

declare class DetailAttachmentComponent<T extends IEntity<string> | undefined> extends DetailBaseComponent<T> {
    private fileService;
    getButtonOptions(item: T): IButtonOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailAttachmentComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailAttachmentComponent<any>, "smart-detail-attachment", never, {}, {}, never, never, true, never>;
}

declare class DetailDateRangeComponent<T extends {
    [key: string]: any;
} | undefined> extends DetailBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailDateRangeComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailDateRangeComponent<any>, "smart-detail-date-range", never, {}, {}, never, never, true, never>;
}

declare class DetailImageComponent<T extends {
    [key: string]: any;
} | undefined> extends DetailBaseComponent<T> {
    private fileService;
    imageUrl: Signal<string | null>;
    protected afterSetOptionsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailImageComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailImageComponent<any>, "smart-detail-image", never, {}, {}, never, never, true, never>;
}

declare class DetailPhoneNumberPlComponent<T> extends DetailBaseComponent<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailPhoneNumberPlComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailPhoneNumberPlComponent<any>, "smart-detail-phone-number-pl", never, {}, {}, never, never, true, never>;
}

declare class InfoComponent {
    text: i0.InputSignal<string>;
    onClick(ev: any): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InfoComponent, "smart-info", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class InfoModalComponent {
    text: string;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<InfoModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InfoModalComponent, "smart-info-modal", never, {}, {}, never, never, true, never>;
}

declare abstract class ListBaseComponent<T extends IEntity<string>> {
    static smartType: DynamicComponentType;
    private _fields;
    protected provider: IListProvider<T>;
    protected authService: AuthService;
    protected router: Router;
    protected alertService: AlertService;
    protected cd: ChangeDetectorRef;
    protected translateService: TranslateService;
    detailsComponent: any;
    selectMode?: 'multi';
    detailsComponentProps: IDetailsOptions<T>;
    select: (id: string) => void;
    unselect: () => void;
    itemHandler: ((id: string) => void) | null;
    removeHandler: ((item: T) => void) | null;
    checkRemoveHandler: (item: T) => boolean;
    detailsButtonOptions: IButtonOptions;
    removed: Set<string>;
    keys: Array<string>;
    cellPipe: ICellPipe<T> | null;
    loadPrevPage: ((event?: any) => void) | null;
    loadNextPage: ((event?: any) => void) | null;
    list: Signal<CdkTableDataSourceInput<T> | null>;
    loading: Signal<boolean>;
    page: Signal<number | null>;
    totalPages: Signal<number | null>;
    FieldType: typeof _smartsoft001_models.FieldTypeDef;
    PaginationMode: typeof PaginationMode;
    type: Type<T>;
    sort: boolean | {
        default?: string;
        defaultDesc?: boolean;
    };
    options: i0.InputSignal<IListInternalOptions<T>>;
    contentTpl: Signal<ViewContainerRef | undefined>;
    constructor();
    protected initKeys(data?: Array<T> | null): void;
    protected initList(val: IListInternalOptions<T>): void;
    protected initLoading(): void;
    protected afterInitOptions(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListBaseComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListBaseComponent<any>, never, never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const ListComponent_base: new () => IDynamicComponent<ListBaseComponent<any>>;
declare class ListComponent<T extends IEntity<string>> extends ListComponent_base {
    private _options;
    private hardwareService;
    mode: Signal<ListMode>;
    ListMode: typeof ListMode;
    options: i0.InputSignal<IListOptions<T>>;
    get internalOptions(): IListInternalOptions<T>;
    contentTpl: Signal<TemplateRef<any> | undefined>;
    dynamicContents: Signal<readonly DynamicContentDirective[]>;
    constructor();
    refreshProperties(): void;
    private initFields;
    private initModel;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListComponent<any>, "smart-list", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class ListMobileComponent<T extends IEntity<string>> extends ListBaseComponent<T> implements AfterViewInit {
    listMobile: Signal<T[]>;
    componentFactories: IListComponentFactories<T> | null;
    topTpl: Signal<ViewContainerRef | undefined>;
    protected initList(val: IListInternalOptions<T>): void;
    ngAfterViewInit(): void;
    private generateDynamicComponents;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListMobileComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListMobileComponent<any>, "smart-list-mobile", never, {}, {}, never, never, true, never>;
}

declare class ListDesktopComponent<T extends IEntity<string>> extends ListBaseComponent<T> implements OnInit, OnDestroy, AfterViewInit {
    private _subscriptions;
    private _multiSelected;
    desktopList: Signal<T[]>;
    componentFactories: IListComponentFactories<T> | null;
    get desktopKeys(): Array<string> | null;
    topTpl: Signal<ViewContainerRef | undefined>;
    protected initList(val: IListInternalOptions<T>): void;
    onChangeMultiselect(checked: boolean, element: T, list: T[]): void;
    myTrackById(val: any): any;
    ngAfterViewInit(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private generateDynamicComponents;
    protected readonly Object: ObjectConstructor;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListDesktopComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListDesktopComponent<any>, "smart-list-desktop", never, {}, {}, never, never, true, never>;
}

declare class ListMasonryGridComponent<T extends IEntity<string>> extends ListBaseComponent<T> implements AfterViewInit {
    componentFactories: IListComponentFactories<T> | null;
    listWithImages: Signal<{
        data: T;
        image: any;
    }[] | null>;
    topTpl: Signal<ViewContainerRef | undefined>;
    ngAfterViewInit(): void;
    protected afterInitOptions(): void;
    protected initList(val: IListInternalOptions<T>): void;
    private generateDynamicComponents;
    protected readonly Object: ObjectConstructor;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListMasonryGridComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListMasonryGridComponent<any>, "smart-list-masonry-grid", never, {}, {}, never, never, true, never>;
}

declare class LoaderComponent {
    readonly show: InputSignal<boolean>;
    readonly height: InputSignal<string | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "smart-loader", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class PagingComponent {
    readonly page: InputSignal<number | null>;
    readonly totalPages: InputSignal<number | null>;
    nextPage: OutputEmitterRef<void>;
    prevPage: OutputEmitterRef<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PagingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PagingComponent, "smart-paging", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "totalPages": { "alias": "totalPages"; "required": false; "isSignal": true; }; }, { "nextPage": "nextPage"; "prevPage": "prevPage"; }, never, never, true, never>;
}

declare class SearchbarComponent implements OnDestroy, AfterViewInit {
    private _subscriptions;
    control: WritableSignal<UntypedFormControl>;
    show: i0.ModelSignal<boolean>;
    text: i0.ModelSignal<string>;
    constructor();
    setShow(): Promise<void>;
    tryHide(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchbarComponent, "smart-searchbar", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": true; "isSignal": true; }; }, { "show": "showChange"; "text": "textChange"; }, never, never, true, never>;
}

declare class DateEditComponent implements ControlValueAccessor {
    private cd;
    DEFAULT_DATE: string;
    get d1(): string | null;
    set d1(val: string);
    get d2(): string | null;
    set d2(val: string);
    get m1(): string | null;
    set m1(val: string);
    get m2(): string | null;
    set m2(val: string);
    get y1(): string | null;
    set y1(val: string);
    get y2(): string | null;
    set y2(val: string);
    get y3(): string | null;
    set y3(val: string);
    get y4(): string | null;
    set y4(val: string);
    ngModel: i0.ModelSignal<string>;
    validDate: boolean;
    propagateChange: (val: any) => void;
    propagateTouched: () => void;
    validChange: i0.OutputEmitterRef<boolean>;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    private setValueAt;
    private setCharAt;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateEditComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateEditComponent, "smart-date-edit", never, { "ngModel": { "alias": "ngModel"; "required": false; "isSignal": true; }; }, { "ngModel": "ngModelChange"; "validChange": "validChange"; }, never, never, true, never>;
}

declare class DateRangeComponent implements ControlValueAccessor {
    private cd;
    value: IDateRange | undefined;
    propagateChange: (val: any) => void;
    propagateTouched: () => void;
    ngModel: i0.ModelSignal<IDateRange | undefined>;
    calendarData: CalendarState;
    constructor();
    onClick(): Promise<void>;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onClear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangeComponent, "smart-date-range", never, { "ngModel": { "alias": "ngModel"; "required": false; "isSignal": true; }; }, { "ngModel": "ngModelChange"; }, never, never, true, never>;
}
declare const enum FilterBtnConstants {
    empthyString = "",
    today = "Today",
    yesterday = "Yesterday",
    lastSevenDays = "LastSevenDays",
    lastThirtyDays = "LastThirtyDays",
    thisMonth = "ThisMonth",
    lastMonth = "LastMonth"
}
interface SubjectType {
    date: moment.Moment;
    event: any;
}
interface CalendarState {
    dateFrom: moment.Moment;
    dateTo: moment.Moment;
    scrollPosition: number;
    selectedButtonName: FilterBtnConstants;
}
declare class DateRangeModalComponent implements OnInit, AfterContentInit {
    private fb;
    private uiService;
    private changeDetectionRef;
    private calendarService;
    private zone;
    private styleService;
    private elementRef;
    showFilterBtns: i0.InputSignal<boolean>;
    restrictSelectionTo: i0.InputSignal<number>;
    currentDate: moment.Moment;
    dateForm: UntypedFormGroup;
    calendar: month[];
    selectedButtonName: FilterBtnConstants;
    scrollPositionValue: number;
    valueTop: number;
    previousState: CalendarState;
    subject$: Subject<SubjectType>;
    subjectSubscription: Subscription;
    constructor();
    private initDateRangeForm;
    get datesRefGroup(): UntypedFormGroup;
    ngOnInit(): void;
    ngAfterContentInit(): void;
    private setPreviousStateData;
    noop(): void;
    when: (cond: boolean, fn: () => void) => void;
    setStartDate: (date: moment.Moment, formattedDate: string) => void;
    setEndDate: (date: moment.Moment, formattedDate: string) => void;
    resetDates: () => void;
    canSelectionBeRestricted: () => boolean;
    showRestrictSelectionAlertAndResetDates: () => void;
    isSelectionInRestrictedRange(): boolean;
    private formatDate;
    isInRange(day: moment.Moment): boolean;
    isSelectionStart(day: moment.Moment): boolean;
    isSelectionEnd(day: moment.Moment): boolean;
    isStartAndEndDateSame(): boolean;
    selectThisMonth(): void;
    selectLastMonth(): void;
    selectLastThirtyDays(): void;
    selectLastSevenDays(): void;
    private filterSelectionByDaysAgo;
    selectYesterday(): void;
    selectToday(): void;
    private scrollToBottom;
    dismissPage(): void;
    private unsubscribe;
    applyDates(): void;
    loadDataNext(event: any): void;
    loadDataPrev(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangeModalComponent, "smart-date-range-modal", never, { "showFilterBtns": { "alias": "showFilterBtns"; "required": false; "isSignal": true; }; "restrictSelectionTo": { "alias": "restrictSelectionTo"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class PasswordStrengthComponent implements OnChanges {
    private _colors;
    bar0: string;
    bar1: string;
    bar2: string;
    msg: string;
    msgColor: string;
    result: {
        lowerLetters: boolean;
        upperLetters: boolean;
        symbols: boolean;
        passLength: boolean;
    };
    passwordToCheck: i0.InputSignal<string>;
    showHint: i0.InputSignal<boolean>;
    passwordStrength: i0.OutputEmitterRef<boolean>;
    checkStrength(p?: string): number;
    ngOnChanges(changes: {
        [propName: string]: SimpleChange;
    }): Promise<void>;
    private getColor;
    private setBarColors;
    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordStrengthComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordStrengthComponent, "smart-password-strength", never, { "passwordToCheck": { "alias": "passwordToCheck"; "required": true; "isSignal": true; }; "showHint": { "alias": "showHint"; "required": true; "isSignal": true; }; }, { "passwordStrength": "passwordStrength"; }, never, never, true, never>;
}

declare class FormFactory {
    private fb;
    private authService;
    private detailsService;
    private validatorsProvider;
    static checkModelMeta<T>(obj: T): void;
    static getOptions<T>(obj: T, key: string): IFieldOptions;
    static getOptionsFromMode(options: IFieldOptions, mode?: 'create' | 'update' | string): IFieldOptions;
    create<T>(obj: T, ops?: {
        mode?: 'create' | 'update' | 'multiUpdate' | string;
        uniqueProvider?: (values: Record<string, any>) => Promise<boolean>;
        root?: AbstractControl;
    }): Promise<SmartFormGroup>;
    private setValidators;
    private createControl;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormFactory>;
}

declare class SharedFactoriesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedFactoriesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedFactoriesModule, never, [typeof i2$1.ReactiveFormsModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedFactoriesModule>;
}

declare class DetailsPage<T extends IEntity<string>> implements OnInit {
    private modalService;
    private styleService;
    private elementRef;
    pageOptions: WritableSignal<IPageOptions>;
    detailsOptions: IDetailsOptions<T>;
    constructor();
    ngOnInit(): void;
    private initTitle;
    private initButtons;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsPage<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailsPage<any>, "ng-component", never, {}, {}, never, never, true, never>;
}

declare class SharedComponentsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedComponentsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedComponentsModule, never, [typeof i1$1.CommonModule, typeof i2$1.ReactiveFormsModule, typeof i2$1.FormsModule, typeof i1.TranslateModule, typeof _angular_router.RouterModule, typeof SharedPipesModule, typeof SharedDirectivesModule, typeof i7.HttpClientModule, typeof i8.LazyLoadImageModule, typeof i9.DragDropModule, typeof i10.CdkTableModule, typeof i11.DynamicModule, typeof FormStandardComponent, typeof FormComponent, typeof InputComponent, typeof InputIntComponent, typeof InputErrorComponent, typeof InputTextComponent, typeof InputPasswordComponent, typeof InputFlagComponent, typeof InputEnumComponent, typeof InputEmailComponent, typeof InputCurrencyComponent, typeof InputDateComponent, typeof InputDateWithEditComponent, typeof InputFileComponent, typeof InputRadioComponent, typeof InputNipComponent, typeof InputStringsComponent, typeof InputLongTextComponent, typeof InputAddressComponent, typeof InputObjectComponent, typeof InputColorComponent, typeof InputLogoComponent, typeof InputCheckComponent, typeof InputIntsComponent, typeof InputPhoneNumberComponent, typeof InputPhoneNumberPlComponent, typeof InputPeselComponent, typeof InputArrayComponent, typeof InputPdfComponent, typeof InputVideoComponent, typeof InputAttachmentComponent, typeof InputDateRangeComponent, typeof InputImageComponent, typeof InputFloatComponent, typeof PageStandardComponent, typeof PageComponent, typeof AccordionComponent, typeof AccordionHeaderComponent, typeof AccordionBodyComponent, typeof DateRangeComponent, typeof DateRangeModalComponent, typeof DateEditComponent, typeof ButtonComponent, typeof ButtonStandardComponent, typeof CardComponent, typeof ListComponent, typeof ListMobileComponent, typeof ListDesktopComponent, typeof ListMasonryGridComponent, typeof LoaderComponent, typeof DetailComponent, typeof DetailTextComponent, typeof DetailFlagComponent, typeof DetailEnumComponent, typeof DetailEmailComponent, typeof DetailAddressComponent, typeof DetailObjectComponent, typeof DetailColorComponent, typeof DetailLogoComponent, typeof DetailArrayComponent, typeof DetailPdfComponent, typeof DetailVideoComponent, typeof DetailAttachmentComponent, typeof DetailDateRangeComponent, typeof DetailImageComponent, typeof DetailPhoneNumberPlComponent, typeof DetailsComponent, typeof DetailsStandardComponent, typeof i11.DynamicComponent, typeof InfoComponent, typeof InfoModalComponent, typeof ExportComponent, typeof ImportComponent, typeof PasswordStrengthComponent], [typeof FormStandardComponent, typeof FormComponent, typeof InputComponent, typeof InputIntComponent, typeof InputErrorComponent, typeof InputTextComponent, typeof InputPasswordComponent, typeof InputFlagComponent, typeof InputEnumComponent, typeof InputEmailComponent, typeof InputCurrencyComponent, typeof InputDateComponent, typeof InputDateWithEditComponent, typeof InputFileComponent, typeof InputRadioComponent, typeof InputNipComponent, typeof InputStringsComponent, typeof InputLongTextComponent, typeof InputAddressComponent, typeof InputObjectComponent, typeof InputColorComponent, typeof InputLogoComponent, typeof InputCheckComponent, typeof InputIntsComponent, typeof InputPhoneNumberComponent, typeof InputPhoneNumberPlComponent, typeof InputPeselComponent, typeof InputArrayComponent, typeof InputPdfComponent, typeof InputVideoComponent, typeof InputAttachmentComponent, typeof InputDateRangeComponent, typeof InputImageComponent, typeof InputFloatComponent, typeof PageStandardComponent, typeof PageComponent, typeof AccordionComponent, typeof AccordionHeaderComponent, typeof AccordionBodyComponent, typeof DateRangeComponent, typeof DateRangeModalComponent, typeof DateEditComponent, typeof ButtonComponent, typeof ButtonStandardComponent, typeof CardComponent, typeof ListComponent, typeof ListMobileComponent, typeof ListDesktopComponent, typeof ListMasonryGridComponent, typeof LoaderComponent, typeof DetailComponent, typeof DetailTextComponent, typeof DetailFlagComponent, typeof DetailEnumComponent, typeof DetailEmailComponent, typeof DetailAddressComponent, typeof DetailObjectComponent, typeof DetailColorComponent, typeof DetailLogoComponent, typeof DetailArrayComponent, typeof DetailPdfComponent, typeof DetailVideoComponent, typeof DetailAttachmentComponent, typeof DetailDateRangeComponent, typeof DetailImageComponent, typeof DetailPhoneNumberPlComponent, typeof DetailsComponent, typeof DetailsStandardComponent, typeof i11.DynamicComponent, typeof InfoComponent, typeof InfoModalComponent, typeof ExportComponent, typeof ImportComponent, typeof PasswordStrengthComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedComponentsModule>;
}

declare class SharedPagesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedPagesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedPagesModule, never, [typeof SharedServicesModule, typeof SharedComponentsModule, typeof SharedDirectivesModule, typeof DetailsPage], [typeof DetailsPage]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedPagesModule>;
}

declare class SharedModule {
    constructor(translateService: TranslateService);
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedModule, never, [typeof i1.TranslateModule], [typeof i1.TranslateModule, typeof i7.HttpClientModule, typeof i2$1.ReactiveFormsModule, typeof i1$1.CommonModule, typeof SharedFactoriesModule, typeof SharedServicesModule, typeof SharedPipesModule, typeof SharedPagesModule, typeof SharedDirectivesModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedModule>;
}

declare class NgrxSharedModule {
    constructor(store: Store<any>, storeService: NgrxStoreService);
    static ɵfac: i0.ɵɵFactoryDeclaration<NgrxSharedModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgrxSharedModule, never, [typeof SharedModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgrxSharedModule>;
}

declare const ReduxAction: typeof ReduxActionDecorator;
declare function ReduxActionDecorator(options?: any): <T>(target: T, key: string, desc: PropertyDescriptor) => void;

declare function ReduxSelect<TState = any, TValue = any>(selector: Selector<TState, TValue>): (target: any, name: string) => void;
declare function ReduxSelect<TState = any, TValue = any>(selectorOrFeature?: string, ...paths: string[]): (target: any, name: string) => void;
declare function fastPropGetter(paths: string[]): (x: any) => any;

declare const SmartNgModule: typeof SmartNgModuleDecorator;
declare function SmartNgModuleDecorator(options: NgModule): (constructor: any) => any;

export { AUTH_TOKEN, AccordionBodyComponent, AccordionComponent, AccordionHeaderComponent, AlertService, AppBaseComponent, AppService, AuthService, BaseComponent, ButtonBaseComponent, ButtonComponent, ButtonStandardComponent, CalendarService, CardComponent, CreateDynamicComponent, DYNAMIC_COMPONENTS_STORE, DateEditComponent, DateRangeComponent, DateRangeModalComponent, DetailAddressComponent, DetailArrayComponent, DetailAttachmentComponent, DetailBaseComponent, DetailColorComponent, DetailComponent, DetailDateRangeComponent, DetailEmailComponent, DetailEnumComponent, DetailFlagComponent, DetailImageComponent, DetailLogoComponent, DetailObjectComponent, DetailPdfComponent, DetailPhoneNumberPlComponent, DetailTextComponent, DetailVideoComponent, DetailsBaseComponent, DetailsComponent, DetailsDirective, DetailsPage, DetailsService, DetailsStandardComponent, DynamicComponentLoader, DynamicComponentStorageService, DynamicContentDirective, EnumToListPipe, ErrorService, ExportComponent, FILE_SERVICE_CONFIG, FileService, FileUrlPipe, FilterBtnConstants, FormBaseComponent, FormComponent, FormFactory, FormStandardComponent, HardwareService, IModelExportProvider, IModelImportProvider, IModelLabelProvider, IModelPossibilitiesProvider, IModelValidatorsProvider, ImportComponent, InfoComponent, InfoModalComponent, InputAddressComponent, InputArrayComponent, InputAttachmentComponent, InputBaseComponent, InputCheckComponent, InputColorComponent, InputComponent, InputCurrencyComponent, InputDateComponent, InputDateRangeComponent, InputDateWithEditComponent, InputEmailComponent, InputEnumComponent, InputErrorComponent, InputFileComponent, InputFlagComponent, InputFloatComponent, InputImageComponent, InputIntComponent, InputIntsComponent, InputLogoComponent, InputLongTextComponent, InputNipComponent, InputObjectComponent, InputPasswordComponent, InputPdfComponent, InputPeselComponent, InputPhoneNumberComponent, InputPhoneNumberPlComponent, InputRadioComponent, InputStringsComponent, InputTextComponent, InputVideoComponent, ListBaseComponent, ListCellPipe, ListComponent, ListDesktopComponent, ListHeaderPipe, ListMasonryGridComponent, ListMobileComponent, ListMode, LoaderComponent, MODEL_EXPORT_PROVIDER, MODEL_IMPORT_PROVIDER, MODEL_LABEL_PROVIDER, MODEL_POSSIBILITIES_PROVIDER, MODEL_VALIDATORS_PROVIDER, MenuService, ModalService, ModelLabelPipe, NgrxSharedModule, NgrxStoreService, PIPES, PageBaseComponent, PageComponent, PageStandardComponent, PaginationMode, PagingComponent, PasswordStrengthComponent, PopoverService, ReduxAction, ReduxActionDecorator, ReduxSelect, SearchbarComponent, SharedDirectivesModule, SharedFactoriesModule, SharedModule, SharedPagesModule, SharedPipesModule, SharedServicesModule, SlugPipe, SmartFormGroup, SmartNgModule, SmartNgModuleDecorator, StorageService, StyleService, ToastService, TrustHtmlPipe, UIService, fastPropGetter };
export type { AppEndButton, CalendarState, DynamicComponentType, IAlertButton, IAlertOptions, IAppOptions, IAppProvider, IButtonOptions, ICardOptions, ICellPipe, IDetailOptions, IDetailsComponentFactories, IDetailsOptions, IDetailsProvider, IDynamicComponent, IDynamicComponentData, IFileServiceConfig, IFormOptions, IFormProvider, IIconButtonOptions, IInputFromFieldOptions, IInputOptions, IItemOptionsForCustom, IItemOptionsForPage, IListComponentFactories, IListInternalOptions, IListOptions, IListPaginationOptions, IListProvider, IMenuItem, IModal, IModalOptions, IModelLabelOptions, IModelPossibilitiesOptions, IModelValidators, IModelValidatorsOptions, IPageOptions, IRemoveProvider, IStyle, IToastButton, IToastOptions, InputBaseComponentType, InputOptions, ItemOptions, StyleType, month };