import * as i0 from '@angular/core';
import { Provider, OnInit, EventEmitter, OnDestroy, ElementRef, PipeTransform, ChangeDetectorRef, AfterViewInit, OnChanges, TemplateRef, ViewContainerRef, SimpleChanges, AfterContentChecked, AfterContentInit, QueryList, NgZone, InjectionToken, TrackByFunction, Injector, ComponentFactoryResolver, ApplicationRef, ComponentRef, Component } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { TranslationObject, TranslateService } from '@ngx-translate/core';
import { ValidationErrors, ValidatorFn, AbstractControl, FormControl, FormGroup } from '@angular/forms';
import { Resource, Service, IParamsCollection, DocumentCollection, IPage as IPage$1 } from 'ngx-jsonapi';
import { Observable, UnaryFunction, Subject, BehaviorSubject } from 'rxjs';
import { Params, ActivatedRoute, Router, UrlTree } from '@angular/router';
import { Location, DatePipe } from '@angular/common';
import { UploadOutput } from 'ngx-uploader';
import { MatDialogRef, MatDialog } from '@angular/material/dialog';
import { MatBottomSheet } from '@angular/material/bottom-sheet';
import { FormlyFieldConfig, FormlyTemplateOptions, FormlyForm } from '@ngx-formly/core';
import { MatTabGroup } from '@angular/material/tabs';
import { MatExpansionPanel } from '@angular/material/expansion';
import { CdkPortal, TemplatePortal } from '@angular/cdk/portal';
import { ThemePalette } from '@angular/material/core';
import { Directionality, Direction } from '@angular/cdk/bidi';
import { ViewportRuler } from '@angular/cdk/scrolling';
import { Platform } from '@angular/cdk/platform';
import { AnimationTriggerMetadata } from '@angular/animations';
import { MatIconRegistry } from '@angular/material/icon';
import { DomSanitizer } from '@angular/platform-browser';
import { MatAutocompleteTrigger } from '@angular/material/autocomplete';
import { MatTableDataSource } from '@angular/material/table';
import { Sort } from '@angular/material/sort';
import { PageEvent } from '@angular/material/paginator';
import { SelectionModel } from '@angular/cdk/collections';
import { Breakpoints, BreakpointObserver } from '@angular/cdk/layout';

/**
 * Provides all ngx-jsonapi-material services without NgModule
 */
declare function provideNgxJsonapiMaterial(): Array<Provider>;

declare const NGX_JSONAPI_MATERIAL_I18N_ES_FILE: string;
declare const NGX_JSONAPI_MATERIAL_I18N_EN_FILE: string;
interface NgxJsonapiMaterialTranslations {
    es: TranslationObject;
    en: TranslationObject;
}
declare function loadNgxJsonapiMaterialTranslationsFromAssets(httpClient: HttpClient, basePath?: string): Promise<NgxJsonapiMaterialTranslations>;
declare function registerNgxJsonapiMaterialTranslations(translate: TranslateService, translations: NgxJsonapiMaterialTranslations): void;
declare function registerNgxJsonapiMaterialTranslationsFromAssets(translate: TranslateService, httpClient: HttpClient, basePath?: string): Promise<void>;

declare class CustomValidators {
    patternValidator(regex: RegExp, error: ValidationErrors): ValidatorFn;
    /**
     * @description NoPassswordMatch allows you to display an error if the password does not match.
     * @usageNotes
     * ### Ejemplo
     * ```typescript
     * validation: {
     *     message: {
     *         NoPassswordMatch: 'Mi mensaje'
     *     }
     * }
     * ```
     */
    passwordMatchValidator(control: AbstractControl): void;
}

declare function trackById(index: number, resource: Resource): string;

declare function batchAll<T extends Service<R>, R extends Resource>(service: T, params: IParamsCollection): Observable<DocumentCollection<R>>;
declare const filterOrRequest: <T extends Resource>(params: {
    attribute_to_search?: string;
    resourcesArray: Array<T>;
    getAllFc: (filter: string) => Observable<DocumentCollection<T>>;
    last_filter_value: string;
    collection: DocumentCollection<T>;
    page_size: number;
}) => UnaryFunction<Observable<string>, Observable<Array<T>>>;

declare class Destroyer {
    private takeuntil;
    pipe<T>(): UnaryFunction<Observable<T>, Observable<T>>;
    destroy(): void;
}

declare class SelectComponent implements OnInit {
    appareance: 'fill' | 'outline' | 'legacy' | 'standard';
    floatLabel: 'never' | 'always';
    multiple: boolean;
    parentId: string;
    toRelate: Resource;
    placeholder: string | undefined;
    label: string;
    displayAttribute: string;
    collection: DocumentCollection;
    removeRelationships: boolean;
    disabled: boolean;
    limit: number;
    hasRefresh: boolean;
    toRelateChange: EventEmitter<Resource>;
    refresh: EventEmitter<void>;
    adaptiveArray: Array<Resource>;
    clear_relationships: Resource | null;
    searchText: string;
    ngOnInit(): void;
    updateFilter(search_text: string): void;
    updateRelationships(resource: Resource): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "jam-select", never, { "appareance": { "alias": "appareance"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "parentId": { "alias": "parentId"; "required": false; }; "toRelate": { "alias": "toRelate"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "displayAttribute": { "alias": "displayAttribute"; "required": true; }; "collection": { "alias": "collection"; "required": true; }; "removeRelationships": { "alias": "removeRelationships"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "hasRefresh": { "alias": "hasRefresh"; "required": false; }; }, { "toRelateChange": "toRelateChange"; "refresh": "refresh"; }, never, ["*"], true, never>;
}

declare class JamOptionFooterComponent {
    private activatedRoute;
    private router;
    url: string;
    labelOption: string;
    routerLink: Array<string>;
    queryParams: Params;
    openNewTab: boolean;
    constructor(activatedRoute: ActivatedRoute, router: Router);
    goTo(target?: '_self' | '_blank'): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamOptionFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JamOptionFooterComponent, "jam-option-footer", never, { "url": { "alias": "url"; "required": false; }; "labelOption": { "alias": "labelOption"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "openNewTab": { "alias": "openNewTab"; "required": false; }; }, {}, never, never, true, never>;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

declare class SubmitComponent {
    private location;
    router: Router;
    activatedRoute: ActivatedRoute;
    submitAppearance: 'mat-flat-button' | 'mat-stroked-button' | 'mat-raised-button' | 'mat-button';
    submitColor: 'primary' | 'warn';
    disabled: boolean;
    noCancel: boolean;
    cancelParamsState: object;
    submitLabel: string;
    cancelState: string;
    goBack: boolean;
    loading: boolean;
    accept: EventEmitter<void>;
    cancelAction: EventEmitter<string | void>;
    constructor(location: Location, router: Router, activatedRoute: ActivatedRoute);
    changeState(_event: Event): void;
    submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubmitComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubmitComponent, "jam-submit", never, { "submitAppearance": { "alias": "submitAppearance"; "required": false; }; "submitColor": { "alias": "submitColor"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "noCancel": { "alias": "noCancel"; "required": false; }; "cancelParamsState": { "alias": "cancelParamsState"; "required": false; }; "submitLabel": { "alias": "submitLabel"; "required": false; }; "cancelState": { "alias": "cancelState"; "required": false; }; "goBack": { "alias": "goBack"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "accept": "accept"; "cancelAction": "cancelAction"; }, never, never, true, never>;
}

/***
 * Copyright (C) 1997-2018 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

/**
 * Este component trabaja con 2 ng-content.
 * En el component que se use, debe definirse dos ng-container con las clases css:
 * header-filters, y filters, de esta forma el component sabe en que ng-content ubicar el contenido que se le pasa.
 */
declare class FloatingFiltersComponent implements OnInit {
    hasAdvancedFilters: boolean;
    appearance: 'round' | 'square';
    resetFilters: EventEmitter<void>;
    show_reset_button: boolean;
    open_expansion_panel: boolean;
    ngOnInit(): void;
    toggleStateExpansionPanel(state: boolean): void;
    clearFilters(panel_state: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingFiltersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FloatingFiltersComponent, "jam-floating-filters", never, { "hasAdvancedFilters": { "alias": "hasAdvancedFilters"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; }, { "resetFilters": "resetFilters"; }, never, ["ng-container.jam-filter-header", "ng-container.jam-filter-content"], true, never>;
}

/**
 * Esta directive se usa en conjunto con la directive/attribute [disabled].
 * Es especial para los matExpansionPanel, cuando se aplican botones de acciones al header de este
 * y no se quiere abrir el matExpansionPanel, entonces esta directiv lo que hará es no aplicar los estilos apagado
 * que proporciona material cuando un elemento/tag esta des habilitado.
 */
declare class AvoidDisabledStyleDirective implements OnDestroy {
    private elementRef;
    private changes;
    constructor(elementRef: ElementRef);
    ngOnDestroy(): void;
    private preservingOriginalStyles;
    static ɵfac: i0.ɵɵFactoryDeclaration<AvoidDisabledStyleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AvoidDisabledStyleDirective, "[jamAvoidDisabledStyle]", never, {}, {}, never, never, true, never>;
}

interface ImageChange {
    status_change: 'update' | 'delete';
    source: string;
}

declare class PictureManagerComponent implements OnInit {
    protected httpClient: HttpClient;
    /**
     * Inputs
     *
     * @param type: describes the shape of the image container, this parameter is optional..
     * @param source: is a url to reference an image.
     * @param deleteUrl: is a url for deleting an image, this parameter is optional.
     * @param uploadUrl: is a url for uploading an image, this parameter is optional.
     */
    type: 'square' | 'round';
    source: string;
    deleteUrl: string;
    uploadUrl: string;
    showDeleteOption: boolean;
    jamHeaders: {
        [key: string]: string | Array<string>;
    };
    textDelete: string;
    disableMatDialog: boolean;
    showBtnOption: boolean;
    deletePreview: boolean;
    /**
     * Outputs
     *
     * @param uploadChange: updates the image and returns the url for it.
     */
    uploadChange: EventEmitter<ImageChange>;
    response: EventEmitter<UploadOutput>;
    drag_and_drop: boolean;
    constructor(httpClient: HttpClient);
    ngOnInit(): void;
    dragAndDropStyles(drag_and_drop: boolean): void;
    showPreview(image: string): void;
    delete(): void;
    settingDefaultValues(): void;
    private creatDeleteUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<PictureManagerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PictureManagerComponent, "jam-picture-manager", never, { "type": { "alias": "type"; "required": false; }; "source": { "alias": "source"; "required": false; }; "deleteUrl": { "alias": "deleteUrl"; "required": false; }; "uploadUrl": { "alias": "uploadUrl"; "required": false; }; "showDeleteOption": { "alias": "showDeleteOption"; "required": false; }; "jamHeaders": { "alias": "jamHeaders"; "required": false; }; "textDelete": { "alias": "textDelete"; "required": false; }; "disableMatDialog": { "alias": "disableMatDialog"; "required": false; }; "showBtnOption": { "alias": "showBtnOption"; "required": false; }; "deletePreview": { "alias": "deletePreview"; "required": false; }; }, { "uploadChange": "uploadChange"; "response": "response"; }, never, never, true, never>;
}

declare class GalleryManagerComponent implements OnInit {
    pictures: Array<Resource | unknown>;
    uploadUrl: string;
    updatePicture: string;
    limit: number;
    showDeleteOption: boolean;
    jamHeaders: {
        [key: string]: string | Array<string>;
    };
    /**
     * @param  {number} highlightedImage
     * Position in the array of the highlighted image, by default is the position 0.
     */
    highlightedImage: number;
    addPicture: EventEmitter<string>;
    responsePicture: EventEmitter<Resource>;
    image_loading: boolean;
    ngOnInit(): void;
    showPreview(img: unknown): void;
    response(event: {
        type: string;
        file?: {
            response: {
                data: Resource;
            };
        };
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GalleryManagerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GalleryManagerComponent, "jam-gallery-manager", never, { "pictures": { "alias": "pictures"; "required": false; }; "uploadUrl": { "alias": "uploadUrl"; "required": false; }; "updatePicture": { "alias": "updatePicture"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "showDeleteOption": { "alias": "showDeleteOption"; "required": false; }; "jamHeaders": { "alias": "jamHeaders"; "required": false; }; "highlightedImage": { "alias": "highlightedImage"; "required": false; }; }, { "addPicture": "addPicture"; "responsePicture": "responsePicture"; }, never, never, true, never>;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

declare class SearchInputComponent implements OnInit, OnDestroy {
    text: string;
    opened: boolean;
    textChange: EventEmitter<string>;
    searchCtrl: FormControl;
    showSearch: boolean;
    private destroyer;
    ngOnInit(): void;
    ngOnDestroy(): void;
    showInput(): void;
    switch(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchInputComponent, "jam-search-input", never, { "text": { "alias": "text"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; }, { "textChange": "textChange"; }, never, never, true, never>;
}

declare class FilterPipe implements PipeTransform {
    /**
     *
     * @param items List of items to filter
     * @param term  a string term to compare with every property of the list
     *
     */
    static filter(items: Array<Record<string, unknown>>, term: string): Array<Record<string, unknown>>;
    /**
     * @param items object or resource from array
     * @param searchText search term
     */
    transform(items: Array<Record<string, unknown>>, searchText: string): Array<Record<string, unknown>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterPipe, "filter", true>;
}

declare class ChipsAutocompleteComponent implements OnInit {
    resourceInput: ElementRef;
    placeholder: string;
    resource: Resource;
    remoteFilter: Record<string, unknown>;
    service: Service;
    relationAlias: string;
    attributesDisplay: Array<string>;
    appearance: 'standard' | 'outline' | 'legacy' | 'fill';
    matLabel: string;
    page: IPage$1;
    trackById: (index: number, resource: Resource) => string;
    filteredCollection: Observable<Array<Resource>>;
    formControl: FormControl;
    collection: DocumentCollection;
    addOnBlur: boolean;
    selectable: boolean;
    removable: boolean;
    collection_relationships: DocumentCollection;
    private collectionArray;
    private collectionArrayLastFilterValue;
    constructor();
    ngOnInit(): void;
    getAll(search_text: string): Observable<DocumentCollection>;
    filterCollection(search_text: string | Resource): Array<Resource>;
    addResource(resource: Resource): void;
    displayName(_resource: Resource): '';
    removeResource(resource: Resource): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipsAutocompleteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChipsAutocompleteComponent, "jam-chips-autocomplete", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "resource": { "alias": "resource"; "required": true; }; "remoteFilter": { "alias": "remoteFilter"; "required": false; }; "service": { "alias": "service"; "required": true; }; "relationAlias": { "alias": "relationAlias"; "required": true; }; "attributesDisplay": { "alias": "attributesDisplay"; "required": true; }; "appearance": { "alias": "appearance"; "required": false; }; "matLabel": { "alias": "matLabel"; "required": false; }; "page": { "alias": "page"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ConfirmationDialogComponent {
    dialogRef: MatDialogRef<ConfirmationDialogComponent>;
    private translateService;
    data: {
        accept?: string;
        msg?: string;
        [key: string]: unknown;
    };
    constructor(dialogRef: MatDialogRef<ConfirmationDialogComponent>, translateService: TranslateService, data: {
        accept?: string;
        msg?: string;
        [key: string]: unknown;
    });
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmationDialogComponent, "jam-confirmation-dialog", never, {}, {}, never, never, true, never>;
}

/***
 * Copyright (C) 1997-2018 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

declare class DeleteConfirmationComponent {
    dialog: MatDialog;
    private translateService;
    type: 'icon' | 'button'; /** @Deprecated */
    icon: string;
    tooltip: string;
    msg: string;
    text: string;
    title: string;
    classed: string; /** @Deprecated */
    styled: object;
    styleIcon: string;
    disableMatDialog: boolean;
    accept: string;
    appearance: 'mat-button' | 'mat-raised-button' | 'mat-flat-button' | 'mat-stroked-button' | 'mat-icon-button';
    delete: EventEmitter<unknown>;
    smartColor: {
        [key: string]: string;
    };
    constructor(dialog: MatDialog, translateService: TranslateService);
    showConfirm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeleteConfirmationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DeleteConfirmationComponent, "jam-delete-confirmation", never, { "type": { "alias": "type"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "msg": { "alias": "msg"; "required": false; }; "text": { "alias": "text"; "required": false; }; "title": { "alias": "title"; "required": false; }; "classed": { "alias": "classed"; "required": false; }; "styled": { "alias": "styled"; "required": false; }; "styleIcon": { "alias": "styleIcon"; "required": false; }; "disableMatDialog": { "alias": "disableMatDialog"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; }, { "delete": "delete"; }, never, never, true, never>;
}

interface IEditTextAttributeData {
    resource: Resource;
    attribute: string;
    title: string;
    accept?: string;
    message?: string;
    textarea_label?: string;
}
declare class EditTextAttributeDialogComponent {
    dialogRef: MatDialogRef<EditTextAttributeDialogComponent>;
    data: IEditTextAttributeData;
    text_value: string;
    constructor(dialogRef: MatDialogRef<EditTextAttributeDialogComponent>, data: IEditTextAttributeData);
    onKeyUp(event: KeyboardEvent): void;
    updateAttributeAndClose(attribute: string, value: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditTextAttributeDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EditTextAttributeDialogComponent, "jam-edit-text-attribute", never, {}, {}, never, never, true, never>;
}

/**
 * @param id: The id must be composed of the resource followed by a period and a short,
 * descriptive message of the warning in question.
 * @param message: It must be a descriptive warning message.
 * @param link: It is optional, and must contain a route.
 */
interface IWarning {
    id: string;
    attributes: {
        message: string;
        link?: string;
        linkQueryParams?: {
            [key: string]: string;
        };
        externalLink?: string;
        linkText?: string;
    };
}
declare class TopWarningService {
    warnings: Array<IWarning>;
    /**
     * Receives a warning resource.
     *
     * @param warning
     */
    setWarningMessage(warning: IWarning): void;
    getWarningMessage(): Array<IWarning>;
    clearMessage(warning_keys: Array<string>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TopWarningService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TopWarningService>;
}

declare class TopWarningComponent {
    topWarningService: TopWarningService;
    opened: boolean;
    button_state: 'expanded' | 'contracted' | 'standby';
    button_icons: {
        [keys: string]: string;
    };
    constructor(topWarningService: TopWarningService);
    onMouseEnter(): void;
    onMouseLeave(): void;
    toggleOpenAccordion(opened: boolean): void;
    defaultAccordionState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TopWarningComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TopWarningComponent, "jam-top-warning", never, { "opened": { "alias": "opened"; "required": false; }; }, {}, never, never, true, never>;
}

/***
 * Copyright (C) 1997-2018 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

declare class SingleWarningComponent implements OnInit {
    message: string | null;
    backgroundColor: string;
    textColor: string;
    link: string;
    linkQueryParams: {
        [key: string]: string;
    };
    externalLink: string;
    linkText: string;
    actionButtonText: string;
    actionIconButton: string;
    actionIconButtonTooltip: string;
    actionButtonClick: EventEmitter<void>;
    actionIconButtonClick: EventEmitter<void>;
    custom_styles: {
        color?: string;
        'background-color'?: string;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SingleWarningComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SingleWarningComponent, "jam-single-warning", never, { "message": { "alias": "message"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "link": { "alias": "link"; "required": false; }; "linkQueryParams": { "alias": "linkQueryParams"; "required": false; }; "externalLink": { "alias": "externalLink"; "required": false; }; "linkText": { "alias": "linkText"; "required": false; }; "actionButtonText": { "alias": "actionButtonText"; "required": false; }; "actionIconButton": { "alias": "actionIconButton"; "required": false; }; "actionIconButtonTooltip": { "alias": "actionIconButtonTooltip"; "required": false; }; }, { "actionButtonClick": "actionButtonClick"; "actionIconButtonClick": "actionIconButtonClick"; }, never, never, true, never>;
}

declare class FabSpeedDialMiniButton {
    key: string;
    navigate: boolean;
    tooltip: string;
    router_link: Array<string>;
    query_params: Record<string, unknown>;
    icon: {
        name: string;
        type: 'svg-icon' | 'mat-icon';
    };
    constructor(key: string, tooltip: string, router_link?: Array<string>, query_params?: Record<string, unknown>);
    setRouterLink(router_link: Array<string>): this;
    getRouterLink(): Array<string>;
    setQueryParams(query_params: Record<string, unknown>): this;
    getQueryParams(): Record<string, unknown>;
    shouldNavigate(): boolean;
}

declare class FabSpeedDialComponent implements OnInit {
    private activatedRoute;
    animationMode: string;
    tooltip: string;
    spin: boolean;
    icon: string;
    routerLink: Array<string>;
    queryParams: Record<string, unknown>;
    fabSpeedDialMiniButtons: Array<FabSpeedDialMiniButton>;
    fabSpeedDialClick: EventEmitter<void>;
    actionsClick: EventEmitter<string>;
    fab_status: {
        [key: string]: string | boolean;
    };
    constructor(activatedRoute: ActivatedRoute);
    ngOnInit(): void;
    toggleFabStatus(status: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FabSpeedDialComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FabSpeedDialComponent, "jam-fab-speed-dial", never, { "animationMode": { "alias": "animationMode"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "spin": { "alias": "spin"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "fabSpeedDialMiniButtons": { "alias": "fabSpeedDialMiniButtons"; "required": false; }; }, { "fabSpeedDialClick": "fabSpeedDialClick"; "actionsClick": "actionsClick"; }, never, never, true, never>;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

declare class JamRefreshService {
    collection_to_refresh: Subject<DocumentCollection>;
    refreshSubject: Subject<boolean>;
    autoRefreshSubject: Subject<boolean>;
    refresh(): void;
    autoRefresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamRefreshService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<JamRefreshService>;
}
declare class RefreshComponent implements OnInit, OnDestroy {
    changeDetectorRef: ChangeDetectorRef;
    jamRefreshService: JamRefreshService;
    collectionToRefresh: DocumentCollection;
    serviceToRefresh: Service;
    colorProgressCircular: string;
    icon: string;
    reload: EventEmitter<Record<string, unknown>>;
    destroyer: Destroyer;
    constructor(changeDetectorRef: ChangeDetectorRef, jamRefreshService: JamRefreshService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    refreshCollection(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefreshComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RefreshComponent, "jam-refresh", never, { "collectionToRefresh": { "alias": "collectionToRefresh"; "required": true; }; "serviceToRefresh": { "alias": "serviceToRefresh"; "required": true; }; "colorProgressCircular": { "alias": "colorProgressCircular"; "required": false; }; "icon": { "alias": "icon"; "required": true; }; }, { "reload": "reload"; }, never, never, true, never>;
}

declare class MenuElement {
    attributes: {
        [key: string]: unknown;
    };
    protected _id: string;
    get id(): string;
    constructor(id?: string);
    setAttributes(attribute: string, value: unknown): this;
    addAttributes(attributes: {
        [key: string]: unknown;
    }): this;
    hide(): this;
    show(): this;
    isShown(): boolean;
    disable(): this;
    enable(): this;
}
declare class MenuElementsCollection<T extends MenuElement | MenuElementsCollection<MenuElement>> {
    data: Array<MenuElementsCollection<T> | T>;
    hidden: boolean;
    protected _id: string;
    get id(): string;
    constructor(id?: string);
    hide(): this;
    show(): this;
    isShown(): boolean;
    find(id: string): MenuElementsCollection<T> | T | undefined;
    add(data: Array<MenuElementsCollection<T> | T>): this;
}

declare class Button extends MenuElement {
    attributes: MenuButtonAttributes;
    setAttributes(attribute: 'label' | 'icon' | 'class' | 'hidden' | 'disabled' | 'svg_icon' | 'icon_font', // TODO: improve typing
    value: string | boolean): this;
    addAttributes(attributes: MenuButtonAttributes): this;
}
interface MenuButtonAttributes extends Record<string, unknown> {
    label: string;
    icon?: string;
    class?: string;
    hidden?: boolean;
    disabled?: boolean;
    svg_icon?: string;
    icon_font?: string;
}

declare class Section extends MenuElementsCollection<Button> {
    data: Array<Button>;
    title: Record<string, unknown>;
    addButtons(buttons: Array<Button>): this;
    hasShownElements(): boolean;
}

declare class Menu extends MenuElementsCollection<Section> {
    data: Array<Section>;
    main_image: {
        url: string;
        styles?: {
            [key: string]: string;
        };
    };
    findSection: (arg: string) => Section;
    addSections: (data: Array<Section | MenuElementsCollection<Section>>) => Menu;
    removeEmptySections(): boolean;
    setMainImage(image_data: {
        url: string;
        styles?: {
            [key: string]: string;
        };
    }): Menu;
}

declare class DropdownMenuComponent {
    sections: Array<Section>;
    main_image: {
        url: string;
        styles: {
            [key: string]: string;
        };
    };
    selected: EventEmitter<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownMenuComponent, "jam-dropdown-menu", never, { "sections": { "alias": "sections"; "required": true; }; "main_image": { "alias": "main_image"; "required": false; }; }, { "selected": "selected"; }, never, never, true, never>;
}

declare class MenuComponent implements OnInit, OnDestroy {
    private matBottomSheet;
    menu: Menu;
    source_data: Array<unknown>;
    selected: EventEmitter<{
        key: string;
        data?: Array<unknown>;
    }>;
    destroyer: Destroyer;
    constructor(matBottomSheet: MatBottomSheet);
    ngOnInit(): void;
    ngOnDestroy(): void;
    open(): void;
    selectedOption(selected: string): void;
    private formatEmission;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "jam-menu", never, { "menu": { "alias": "menu"; "required": true; }; "source_data": { "alias": "source_data"; "required": false; }; }, { "selected": "selected"; }, never, never, true, never>;
}

declare class FloatingButtonComponent {
    show: boolean;
    rsBackground: string;
    iconName: string;
    tooltip: string;
    target: string;
    rsRouterLink: string;
    rsQueryParams: object;
    classPrimary: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FloatingButtonComponent, "jam-floating-button", never, { "rsBackground": { "alias": "rsBackground"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "target": { "alias": "target"; "required": false; }; "rsRouterLink": { "alias": "rsRouterLink"; "required": false; }; "rsQueryParams": { "alias": "rsQueryParams"; "required": false; }; "classPrimary": { "alias": "classPrimary"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DynamicInput implements FormlyFieldConfig {
    readonly model: unknown;
    readonly parent: FormlyFieldConfig;
    key: string;
    id: string;
    name: string;
    templateOptions: FormlyTemplateOptions;
    optionsTypes: Array<string>;
    validation: {
        messages?: {
            [messageProperties: string]: string | ((error: unknown, field: FormlyFieldConfig) => string);
        };
        show?: boolean;
        [additionalProperties: string]: unknown;
    };
    validators: Record<string, (control: AbstractControl) => unknown>;
    asyncValidators: Record<string, (control: AbstractControl) => unknown>;
    template: string;
    wrappers: Array<string>;
    hide: boolean;
    hideExpression: boolean | string | ((model: unknown, formState: unknown) => boolean);
    expressionProperties: {
        [property: string]: string | ((model: unknown, formState: unknown) => boolean);
    };
    formControl: AbstractControl;
    className: string;
    fieldGroupClassName: string;
    fieldGroup: Array<FormlyFieldConfig>;
    fieldArray: FormlyFieldConfig;
    type: string;
    component: unknown;
    focus: boolean;
    modelOptions: {
        debounce?: {
            default: number;
        };
        updateOn?: 'change' | 'blur' | 'submit';
    };
    defaultValue: unknown;
    parsers: Array<(value: unknown) => object>;
    constructor(key: string);
    setFocus(): this;
    required(): this;
    fxFlex(value: number | string): this;
    set(property: string, value: unknown): this;
    setTemplateOption(property: string, value: unknown): this;
    addTemplateOptions(template_options: FormlyTemplateOptions): this;
    setTranslatedTemplateOptions(_translateService: TranslateService): this;
    load(fieldConfig: FormlyFieldConfig): this;
}
declare class TextDynamicInput extends DynamicInput implements FormlyFieldConfig {
    key: string;
    constructor(key: string);
    setTranslatedTemplateOptions(translateService: TranslateService): this;
}
declare class NumberDynamicInput extends DynamicInput implements FormlyFieldConfig {
    key: string;
    constructor(key: string);
    setTranslatedTemplateOptions(translateService: TranslateService): this;
}
declare class CheckboxDynamicInput extends DynamicInput implements FormlyFieldConfig {
    key: string;
    constructor(key: string);
    setTranslatedTemplateOptions(translateService: TranslateService): this;
}
declare class TextareaDynamicInput extends DynamicInput implements FormlyFieldConfig {
    key: string;
    constructor(key: string);
    setTranslatedTemplateOptions(translateService: TranslateService): this;
}
declare class SelectDynamicInput extends DynamicInput implements FormlyFieldConfig {
    key: string;
    constructor(key: string);
    setTranslatedTemplateOptions(translateService: TranslateService): this;
    setOptions(options: Array<{
        value: unknown;
        label: string;
    }>): SelectDynamicInput;
}

declare class FormlyFormFlexComponent extends FormlyForm {
    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFormFlexComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFormFlexComponent, "jam-formly-form-flex", never, {}, {}, never, ["*"], true, never>;
}

declare class JamTabsDirective implements AfterViewInit {
    protected router: Router;
    protected activatedRoute: ActivatedRoute;
    tabNames: {
        [key: string]: number;
    };
    tabGroup: MatTabGroup;
    defaultTabIndex: number;
    selected_tab: number;
    query_params: Params;
    constructor(router: Router, activatedRoute: ActivatedRoute);
    ngAfterViewInit(): void;
    onTabChange(new_index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamTabsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<JamTabsDirective, "[jamTabs]", never, { "tabNames": { "alias": "tabNames"; "required": false; }; "tabGroup": { "alias": "tabGroup"; "required": false; }; "defaultTabIndex": { "alias": "defaultTabIndex"; "required": false; }; }, {}, never, never, true, never>;
}

declare class RemembermeStateDirective implements AfterViewInit {
    private router;
    private elementRef;
    mat_expansion_panel: MatExpansionPanel;
    private mat_expansion_pane_id;
    constructor(router: Router, elementRef: ElementRef);
    ngAfterViewInit(): void;
    onClick(_event: Event): void;
    private changeExpandedExpansionPanel;
    private updateLocalStorage;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemembermeStateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RemembermeStateDirective, "[jamExpansionPanelStatus]", never, {}, {}, ["mat_expansion_panel"], never, true, never>;
}

declare class FloatingInputComponent {
    router: Router;
    searchParams: UrlTree;
    status: boolean;
    entryValue: number;
    resource: Resource;
    horPosition: 'start' | 'end';
    lock: boolean;
    entryValueChange: EventEmitter<number>;
    resourceChange: EventEmitter<Resource>;
    constructor(router: Router);
    statusToggle(status: boolean): void;
    bindingEntryValue(value: number): void;
    keyPress(keyCode: number): void;
    private focusInput;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FloatingInputComponent, "jam-floating-input", never, { "entryValue": { "alias": "entryValue"; "required": false; }; "resource": { "alias": "resource"; "required": true; }; "horPosition": { "alias": "horPosition"; "required": false; }; "lock": { "alias": "lock"; "required": false; }; }, { "entryValueChange": "entryValueChange"; "resourceChange": "resourceChange"; }, never, ["*"], true, never>;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */
interface FilterOption {
    text: string | object;
}

interface RangeFilterInterface {
    eq?: string | number | null;
    ne?: string | number | null;
}

interface StringFilterInterface extends RangeFilterInterface {
    eq?: string;
    ne?: string;
    contains?: string;
    nc?: string;
    like?: string;
}

interface NumberFilterInterface extends RangeFilterInterface {
    eq?: number;
    ne?: number;
    gt?: number;
    lt?: number;
    le?: number;
    ge?: number;
}

interface DateRangeFilterInterface extends RangeFilterInterface {
    eq?: string;
    since?: string;
    until?: string;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

type ResourceFilter = string | number | Array<string> | object | RangeFilterInterface | StringFilterInterface | NumberFilterInterface | DateRangeFilterInterface;
interface Filter {
    type: 'options' | 'checks' | 'range_date';
    attribute: string;
    options: {
        [jsonvalue: string]: FilterOption;
    };
    selected: ResourceFilter;
    title?: string;
    loaded?: boolean;
}
declare class FilterConfig {
    type: 'options' | 'checks' | 'range_date';
    attribute: string;
    options: {
        [jsonvalue: string]: FilterOption;
    };
    selected: ResourceFilter;
    title: string;
}

interface FilterDateRange extends Filter {
    type: 'range_date';
    selected: DateRangeFilterInterface;
}
declare const FILTER_DATE_RANGE_TYPE: 'date-range';
declare class JsonapiFilterRangedateConfig extends FilterConfig implements FilterDateRange {
    type: 'range_date';
    attribute: string;
    options: {
        [jsonvalue: string]: FilterOption;
    };
    selected: {
        [key: string]: string;
    };
    constructor();
    setProperty(property_name: string, property_value: unknown): this;
}

interface FilterChecks extends Filter {
    type: 'checks';
    selected: Array<string>;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

declare class JamFilterOptionsComponent implements OnInit {
    filterConfig: Filter;
    remoteFilter: object;
    remoteFilterChange: EventEmitter<object>;
    filterConfigArray: Array<FilterOption>;
    ngOnInit(): void;
    optionSelected(jsonvalue: unknown, filter_list: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamFilterOptionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JamFilterOptionsComponent, "jam-filter-options", never, { "filterConfig": { "alias": "filterConfig"; "required": true; }; "remoteFilter": { "alias": "remoteFilter"; "required": false; }; }, { "remoteFilterChange": "remoteFilterChange"; }, never, never, true, never>;
}

interface IOption {
    key: string;
    name: string;
}
declare class JamFilterChecksComponent implements OnInit {
    filterConfig: FilterChecks;
    remoteFilter: object;
    filterConfigChange: EventEmitter<FilterChecks>;
    remoteFilterChange: EventEmitter<object>;
    filter_config_options: Array<FilterOption>;
    searchText: string;
    show_input_search: boolean;
    ngOnInit(): void;
    showInputSearch(): void;
    filterConfigOptionsUpdate(): void;
    clearSelected(): void;
    optionSelected(jsonvalue: unknown, filter_list: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamFilterChecksComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JamFilterChecksComponent, "jam-filter-checks", never, { "filterConfig": { "alias": "filterConfig"; "required": false; }; "remoteFilter": { "alias": "remoteFilter"; "required": false; }; }, { "filterConfigChange": "filterConfigChange"; "remoteFilterChange": "remoteFilterChange"; }, never, never, true, never>;
}

/** Used to flag slide labels for use with the portal directive */
declare class JamSlideElementDirective extends CdkPortal {
    static ɵfac: i0.ɵɵFactoryDeclaration<JamSlideElementDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<JamSlideElementDirective, "[jam-slide-element], [jamSlideElement]", never, {}, {}, never, never, true, never>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

interface CanDisable$1 {
    disabled: boolean;
}
/** @docs-private */
declare class JamSlideBase {
    disabled: boolean;
}
declare class JamSlideComponent extends JamSlideBase implements OnInit, CanDisable$1, OnChanges, OnDestroy {
    private _viewContainerRef;
    /** Content for the slide element given by `<ng-template jam-slide-element>`. */
    templateLabel: JamSlideElementDirective;
    /**
     * Template provided in the slide content that will be used if present, used to enable lazy-loading
     */
    /** Plain text element for the slide, used when there is no template label. */
    textLabel: string;
    /** Aria element for the slide. */
    ariaLabel: string;
    /**
     * Reference to the element that the slide is labelled by.
     * Will be cleared if `aria-label` is set at the same time.
     */
    ariaLabelledby: string;
    /** @docs-private */
    get content(): TemplatePortal | null;
    /** Emits whenever the internal state of the slide changes. */
    readonly _stateChanges: Subject<void>;
    /**
     * The relatively indexed position where 0 represents the center, negative is left, and positive
     * represents the right.
     */
    position: number | null;
    /**
     * The initial relatively index origin of the slide if it was created and selected after there
     * was already a selected slide. Provides context of what position the slide should originate from.
     */
    origin: number | null;
    /**
     * Whether the slide is currently active.
     */
    isActive: boolean;
    /** Portal that will be the hosted content of the slide */
    protected _contentPortal: TemplatePortal | null;
    protected _explicitContent: TemplateRef<unknown>;
    /** Template inside the JamSlide view that contains an `<ng-content>`. */
    protected _implicitContent: TemplateRef<unknown>;
    constructor(_viewContainerRef: ViewContainerRef);
    disabled: boolean;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamSlideComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JamSlideComponent, "jam-slide", ["jamSlide"], { "disabled": { "alias": "disabled"; "required": false; }; "textLabel": { "alias": "label"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; }, {}, ["templateLabel"], ["*"], true, never>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

interface CanDisable {
    disabled: boolean;
}
/** @docs-private */
declare class JamSlideElementWrapperBase {
    disabled: boolean;
}
/**
 * Used in the `jam-slide-group` view to display slide labels.
 *
 * @docs-private
 */
declare class JamSlideElementWrapperDirective extends JamSlideElementWrapperBase implements CanDisable {
    elementRef: ElementRef;
    constructor(elementRef: ElementRef);
    disabled: boolean;
    /** Sets focus on the wrapper element */
    focus(): void;
    getOffsetLeft(): number;
    getOffsetWidth(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamSlideElementWrapperDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<JamSlideElementWrapperDirective, "[jamSlideElementWrapper]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

interface CanDisableRipple$1 {
    disableRipple: boolean;
}
type ModifierKey = 'altKey' | 'shiftKey' | 'ctrlKey' | 'metaKey';
/**
 * Checks whether a modifier key is pressed.
 *
 * @param event Event to be checked.
 */
declare function hasModifierKey(event: KeyboardEvent, ...modifiers: Array<ModifierKey>): boolean;
/**
 * The directions that scrolling can go in when the header's slides exceed the header width. 'After'
 * will scroll the header towards the end of the slides list and 'before' will scroll towards the
 * beginning of the list.
 */
type ScrollDirection = 'after' | 'before';
/** @docs-private */
declare class JamSlideHeaderBase {
    disableRipple: boolean;
}
/**
 * The header of the slide group which displays a list of all the slides in the slide group. Includes
 * an ink bar that follows the currently selected slide. When the slides list's width exceeds the
 * width of the header container, then arrows will be displayed to allow the user to scroll
 * left and right across the header.
 *
 * @docs-private
 */
declare class JamSlideHeaderComponent extends JamSlideHeaderBase implements AfterContentChecked, AfterContentInit, AfterViewInit, OnDestroy, CanDisableRipple$1 {
    private _elementRef;
    private _changeDetectorRef;
    private _viewportRuler;
    private _dir;
    private _ngZone?;
    private _platform?;
    _elementWrappers: QueryList<JamSlideElementWrapperDirective>;
    _slideListContainer: ElementRef;
    _slideList: ElementRef;
    _nextPaginator: ElementRef<HTMLElement>;
    _previousPaginator: ElementRef<HTMLElement>;
    /** Event emitted when the option is selected. */
    readonly selectFocusedIndex: EventEmitter<number>;
    /** Event emitted when a element is focused. */
    readonly indexFocused: EventEmitter<number>;
    /** Whether the controls for pagination should be displayed */
    _showPaginationControls: boolean;
    /** Whether the slide list can be scrolled more towards the end of the slide element list. */
    _disableScrollAfter: boolean;
    /** Whether the slide list can be scrolled more towards the beginning of the slide element list. */
    _disableScrollBefore: boolean;
    /** The distance in pixels that the slide labels should be translated to the left. */
    private _scrollDistance;
    /** Whether the header should scroll to the selected index after the view has been checked. */
    private _selectedIndexChanged;
    /** Emits when the component is destroyed. */
    private readonly _destroyed;
    /**
     * The number of slide labels that are displayed on the header. When this changes, the header
     * should re-evaluate the scroll position.
     */
    private _slideElementCount;
    /** Whether the scroll distance has changed and should be applied after the view is checked. */
    private _scrollDistanceChanged;
    /** Used to manage focus between the slides. */
    private _keyManager;
    /** Cached text content of the header. */
    private _currentTextContent;
    /** Stream that will stop the automated scrolling. */
    private _stopScrolling;
    /** The index of the active slide. */
    get selectedIndex(): number;
    set selectedIndex(value: number);
    private _selectedIndex;
    constructor(_elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, _viewportRuler: ViewportRuler, _dir: Directionality, _ngZone?: NgZone | undefined, _platform?: Platform | undefined);
    disableRipple: boolean;
    ngAfterContentChecked(): void;
    /** Handles keyboard events on the header. */
    _handleKeydown(event: KeyboardEvent): void;
    /**
     * Aligns the ink bar to the selected slide on load.
     */
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Callback for when the MutationObserver detects that the content has changed.
     */
    _onContentChanges(): void;
    /**
     * Updates the view whether pagination should be enabled or not.
     *
     * WARNING: Calling this method can be very costly in terms of performance.  It should be called
     * as infrequently as possible from outside of the Tabs component as it causes a reflow of the
     * page.
     */
    updatePagination(): void;
    /** Tracks which element has focus; used for keyboard navigation */
    get focusIndex(): number;
    /** When the focus index is set, we must manually send focus to the correct element */
    set focusIndex(value: number);
    /**
     * Determines if an index is valid.  If the slides are not ready yet, we assume that the user is
     * providing a valid index and return true.
     */
    _isValidIndex(index: number): boolean;
    /**
     * Sets focus on the HTML element for the element wrapper and scrolls it into the view if
     * scrolling is enabled.
     */
    _setTabFocus(slideIndex: number): void;
    /** The layout direction of the containing app. */
    _getLayoutDirection(): Direction;
    /** Performs the CSS transformation on the slide list that will cause the list to scroll. */
    _updateTabScrollPosition(): void;
    /** Sets the distance in pixels that the slide header should be transformed in the X-axis. */
    get scrollDistance(): number;
    set scrollDistance(value: number);
    /**
     * Moves the slide list in the 'before' or 'after' direction (towards the beginning of the list or
     * the end of the list, respectively). The distance to scroll is computed to be a third of the
     * length of the slide list view window.
     *
     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
     * should be called sparingly.
     */
    _scrollHeader(direction: ScrollDirection): {
        [keys: string]: number;
    };
    /** Handles click events on the pagination arrows. */
    _handlePaginatorClick(direction: ScrollDirection): void;
    /**
     * Moves the slide list such that the desired slide element (marked by index) is moved into view.
     *
     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
     * should be called sparingly.
     */
    _scrollToLabel(labelIndex: number): void;
    /**
     * Evaluate whether the pagination controls should be displayed. If the scroll width of the
     * slide list is wider than the size of the header container, then the pagination controls should
     * be shown.
     *
     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
     * should be called sparingly.
     */
    _checkPaginationEnabled(): void;
    /**
     * Evaluate whether the before and after controls should be enabled or disabled.
     * If the header is at the beginning of the list (scroll distance is equal to 0) then disable the
     * before button. If the header is at the end of the list (scroll distance is equal to the
     * maximum distance we can scroll), then disable the after button.
     *
     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
     * should be called sparingly.
     */
    _checkScrollingControls(): void;
    /**
     * Determines what is the maximum length in pixels that can be set for the scroll distance. This
     * is equal to the difference in width between the slide list container and slide header container.
     *
     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
     * should be called sparingly.
     */
    _getMaxScrollDistance(): number;
    /** Tells the ink-bar to align itself to the current element wrapper */
    /** Stops the currently-running paginator interval.  */
    _stopInterval(): void;
    /**
     * Handles the user pressing down on one of the paginators.
     * Starts scrolling the header after a certain amount of time.
     *
     * @param direction In which direction the paginator should be scrolled.
     */
    _handlePaginatorPress(direction: ScrollDirection): void;
    /**
     * Scrolls the header to a given position.
     *
     * @param position Position to which to scroll.
     * @returns Information on the current scroll distance and the maximum.
     */
    private _scrollTo;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamSlideHeaderComponent, [null, null, null, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JamSlideHeaderComponent, "jam-slide-header", never, { "disableRipple": { "alias": "disableRipple"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "selectFocusedIndex": "selectFocusedIndex"; "indexFocused": "indexFocused"; }, ["_elementWrappers"], ["*"], true, never>;
}

interface CanColor {
    color: ThemePalette;
}
interface CanDisableRipple {
    disableRipple: boolean;
}
/** A simple change event emitted on focus or selection changes. */
declare class JamSlideChangeEvent {
    /** Index of the currently-selected slide. */
    index: number;
    /** Reference to the currently-selected slide. */
    slide: JamSlideComponent;
}
/** Possible positions for the slide header. */
type JamSlideHeaderPosition = 'above' | 'below';
/** Object that can be used to configure the default options for the slides module. */
interface JamSlidesConfig {
    /** Duration for the slide animation. Must be a valid CSS value (e.g. 600ms). */
    animationDuration?: string;
}
/** Injection token that can be used to provide the default options the slides module. */
declare const MAT_TABS_CONFIG: InjectionToken<JamSlidesConfig>;
/** @docs-private */
declare class JamSlideGroupBase {
    _elementRef: ElementRef;
    color: ThemePalette;
    disableRipple: boolean;
    constructor(_elementRef: ElementRef);
}
/**
 * Material design slide-group component.  Supports basic slide pairs (label + content) and includes
 * animated ink-bar, keyboard navigation, and screen reader.
 * See: https://material.io/design/components/slides.html
 */
declare class JamSlideGroupComponent extends JamSlideGroupBase implements AfterContentInit, AfterContentChecked, OnDestroy, CanColor, CanDisableRipple {
    private _changeDetectorRef;
    defaultConfig?: JamSlidesConfig | undefined;
    _slides: QueryList<JamSlideComponent>;
    _slideBodyWrapper: ElementRef;
    _slideHeader: JamSlideHeaderComponent;
    /** Output to enable support for two-way binding on `[(selectedIndex)]` */
    readonly selectedIndexChange: EventEmitter<number>;
    /** Event emitted when focus has changed within a slide group. */
    readonly focusChange: EventEmitter<JamSlideChangeEvent>;
    /** Event emitted when the body animation has completed */
    readonly animationDone: EventEmitter<void>;
    /** Event emitted when the slide selection has changed. */
    readonly selectedTabChange: EventEmitter<JamSlideChangeEvent>;
    /** Position of the slide header. */
    headerPosition: JamSlideHeaderPosition;
    /** The slide index that should be selected after the content has been checked. */
    private _indexToSelect;
    /** Snapshot of the height of the slide body wrapper before another slide is activated. */
    private _slideBodyWrapperHeight;
    /** Subscription to slides being added/removed. */
    private _slidesSubscription;
    /** Subscription to changes in the slide labels. */
    private _slideElementSubscription;
    /** Whether the slide group should grow to the size of the active slide. */
    get dynamicHeight(): boolean;
    set dynamicHeight(value: boolean);
    private _dynamicHeight;
    /** The index of the active slide. */
    get selectedIndex(): number | null;
    set selectedIndex(value: number | null);
    private _selectedIndex;
    /** Duration for the slide animation. Will be normalized to milliseconds if no units are set. */
    get animationDuration(): string;
    set animationDuration(value: string);
    private _animationDuration;
    /** Background color of the slide group. */
    get backgroundColor(): ThemePalette;
    set backgroundColor(value: ThemePalette);
    private _backgroundColor;
    private _groupId;
    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, defaultConfig?: JamSlidesConfig | undefined);
    disableRipple: boolean;
    color: ThemePalette;
    defaultColor: ThemePalette;
    /**
     * After the content is checked, this component knows what slides have been defined
     * and what the selected index should be. This is where we can know exactly what position
     * each slide should be in according to the new selected index, and additionally we know how
     * a new selected slide should transition in (from the left or right).
     */
    ngAfterContentChecked(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    /** Re-aligns the ink bar to the selected slide element. */
    _focusChanged(index: number): void;
    /** Returns a unique id for each slide element element */
    _getTabLabelId(i: number): string;
    /** Returns a unique id for each slide content element */
    _getTabContentId(i: number): string;
    /**
     * Sets the height of the body wrapper to the height of the activating slide if dynamic
     * height property is true.
     */
    _setTabBodyWrapperHeight(slideHeight: number): void;
    /** Removes the height of the slide body wrapper. */
    _removeTabBodyWrapperHeight(): void;
    /** Handle click events, setting new selected index if appropriate. */
    _handleClick(slide: JamSlideComponent, slideHeader: JamSlideHeaderComponent, index: number): void;
    /** Retrieves the slideindex for the slide. */
    _getTabIndex(slide: JamSlideComponent, idx: number): number | null;
    private _createChangeEvent;
    /**
     * Subscribes to changes in the slide labels. This is needed, because the @Input for the element is
     * on the JamSlide component, whereas the data binding is inside the JamSlideGroup. In order for the
     * binding to be updated, we need to subscribe to changes in it and trigger change detection
     * manually.
     */
    private _subscribeToTabLabels;
    /** Clamps the given index to the bounds of 0 and the slides length. */
    private _clampTabIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamSlideGroupComponent, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JamSlideGroupComponent, "jam-slide-group", ["jamSlideGroup"], { "headerPosition": { "alias": "headerPosition"; "required": false; }; "dynamicHeight": { "alias": "dynamicHeight"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "focusChange": "focusChange"; "animationDone": "animationDone"; "selectedTabChange": "selectedTabChange"; }, ["_slides"], never, true, never>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/**
 * Animations used by the Material slides.
 *
 * @docs-private
 */
declare const jamSlidesAnimations: {
    readonly translateTab: AnimationTriggerMetadata;
};

interface IPinButton {
    index: number;
    label: string;
    key?: string;
    id?: string;
}
declare class PinOptionButtonComponent implements OnInit {
    private matIconRegistry;
    private domSanitizer;
    options: Array<string>;
    specialKey: string;
    jamColor: 'primary' | 'accent' | 'warn' | 'default';
    selected: EventEmitter<IPinButton>;
    index: number;
    buttons: Array<IPinButton>;
    selected_option: IPinButton;
    constructor(matIconRegistry: MatIconRegistry, domSanitizer: DomSanitizer);
    ngOnInit(): void;
    pinnedOption(event: Event, button: IPinButton): void;
    selectOption(button: IPinButton): void;
    trackByButton(_index: number, item: IPinButton): number | string;
    pinButton(): void;
    private populateMenu;
    private defaultSelectedOption;
    static ɵfac: i0.ɵɵFactoryDeclaration<PinOptionButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PinOptionButtonComponent, "jam-pin-option-button", never, { "options": { "alias": "options"; "required": false; }; "specialKey": { "alias": "specialKey"; "required": false; }; "jamColor": { "alias": "jamColor"; "required": false; }; }, { "selected": "selected"; }, never, never, true, never>;
}

declare class JamAutocompleteComponent implements OnInit, OnDestroy {
    private changeDetectorRef;
    /**
     * @param  {boolean} previewSelected
     * @usageNotes By default it is `false`.
     * In case it is `true`, the autocomplete,
     * shows in the placeholder or matLabel a preview of the selected item.
     */
    previewSelected: boolean;
    /**
     * @param {string} displayText
     * @usageNotes Text of the selected item.
     */
    toggleResource: Resource | null;
    placeholder: string;
    services: Service;
    displayAttributes: Array<string>;
    remoteFilter: Record<string, unknown>;
    include: Array<string>;
    sort: Array<string>;
    icon: string;
    showList: boolean;
    toggleResourceChange: EventEmitter<Resource>;
    autocompleteResource: MatAutocompleteTrigger;
    autocompleteResourceInput: ElementRef;
    collection: DocumentCollection;
    filtered_resource: Observable<Array<Resource>>;
    dataArrived: Subject<string>;
    myForm: FormGroup;
    autocompleteCtrl: FormControl;
    resourceArray: Array<Resource>;
    use_is_loading: boolean;
    trackByFn: TrackByFunction<Resource>;
    resourceArrayLastFilterValue: string;
    private destroyer;
    private readonly collectionPerPage;
    private readonly resource_max_on_list;
    constructor(changeDetectorRef: ChangeDetectorRef);
    ngOnDestroy(): void;
    ngOnInit(): void;
    closeAutocomplete(): void;
    selectedResource(resource: Resource): void;
    displayFn(_resource?: Resource): string;
    refresh(): void;
    getAll(search_text: string): Observable<DocumentCollection>;
    clearDisplay(): void;
    private filterResourceByName;
    static ɵfac: i0.ɵɵFactoryDeclaration<JamAutocompleteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JamAutocompleteComponent, "jam-autocomplete", never, { "previewSelected": { "alias": "previewSelected"; "required": false; }; "toggleResource": { "alias": "toggleResource"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "services": { "alias": "services"; "required": true; }; "displayAttributes": { "alias": "displayAttributes"; "required": true; }; "remoteFilter": { "alias": "remoteFilter"; "required": false; }; "include": { "alias": "include"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "showList": { "alias": "showList"; "required": false; }; }, { "toggleResourceChange": "toggleResourceChange"; }, never, never, true, never>;
}

declare class ResponsiveColumns {
    xs?: Array<string>;
    sm?: Array<string>;
    md?: Array<string>;
    lg?: Array<string>;
    xl?: Array<string>;
    setXs(columns: Array<string>): this;
    setSm(columns: Array<string>): this;
    setMd(columns: Array<string>): this;
    setLg(columns: Array<string>): this;
    setXl(columns: Array<string>): this;
}

declare class Action {
    key: string;
    name: string;
    tooltip: string;
    icon: {
        svg?: string;
        material?: string;
    };
    classes?: string | undefined;
    constructor(key: string, name: string, tooltip: string, icon: {
        svg?: string;
        material?: string;
    }, classes?: string | undefined);
}
declare class Column {
    key: string;
    title?: string | undefined;
    tooltip?: string | undefined;
    classes: {
        header?: string;
        cell?: string;
        cell_data?: string;
    };
    styles: {
        header?: Record<string, string>;
        cell?: Record<string, string>;
        cell_data?: Record<string, string>;
    };
    pipe?: IColumnPipe | undefined;
    template?: TemplateRef<unknown> | undefined;
    default_value?: unknown | undefined;
    icon?: {
        tooltip?: string;
        name?: string;
        style?: Record<string, unknown>;
        classes?: Array<string>;
        type?: "material" | "svg";
        getIconTooltipFromResource?(resource: Resource): string;
        getIconNameFromResource?(resource: Resource): string;
    } | undefined;
    mobile_title?: string | undefined;
    cell_value_from_relationship_attribute: {
        relationship: string;
        attribute: string;
        related_resource_id?: string;
        has_one?: boolean;
    };
    template_only: boolean;
    show_mobile_title: boolean;
    hide_mobile_cell: boolean;
    sort_key: string;
    form_field: {
        input?: {
            type: string;
        };
        select?: {
            options: Array<unknown>;
        };
        checkbox?: {
            text: string;
        };
    };
    constructor(key: string, title?: string | undefined, tooltip?: string | undefined, classes?: {
        header?: string;
        cell?: string;
        cell_data?: string;
    }, styles?: {
        header?: Record<string, string>;
        cell?: Record<string, string>;
        cell_data?: Record<string, string>;
    }, pipe?: IColumnPipe | undefined, template?: TemplateRef<unknown> | undefined, default_value?: unknown | undefined, icon?: {
        tooltip?: string;
        name?: string;
        style?: Record<string, unknown>;
        classes?: Array<string>;
        type?: "material" | "svg";
        getIconTooltipFromResource?(resource: Resource): string;
        getIconNameFromResource?(resource: Resource): string;
    } | undefined, mobile_title?: string | undefined);
    setKey(key: string): Column;
    setTitle(title: string): Column;
    setTooltip(tooltip: string): Column;
    setHeaderClasses(header_classes: string): Column;
    setHeaderStyles(header_styles: {
        [key: string]: string;
    }): Column;
    setCellClasses(classes: string): Column;
    setCellStyles(classes: {
        [key: string]: string;
    }): Column;
    setCellDataClasses(classes: string): Column;
    setCellDataStyles(classes: {
        [key: string]: string;
    }): Column;
    setPipe(pipe: IColumnPipe): Column;
    setTemplate(template: TemplateRef<unknown>): Column;
    setFormField(type: 'text' | 'number'): Column;
    setDefault(default_value: unknown): Column;
    setIcon(icon: Column['icon']): Column;
    setCellValueFromRelationshipAttribute(relationship_attribute: Column['cell_value_from_relationship_attribute']): Column;
    getValueFromRelationshipAttribute(resource: Resource): unknown;
    templateOnly(value: boolean): Column;
    showMobileTitle(): this;
    hidemobileTitle(): this;
    hideOnMobile(): this;
    setSortKey(key?: string): this;
}
interface IColumnPipe {
    pipe: PipeTransform;
    arg?: unknown;
    attribute_key_arg?: string;
}

declare class AppDatePipe extends DatePipe implements PipeTransform {
    transform(value: string | number | Date, format?: string, timezone?: string, locale?: string): string;
    transform(value: null, format?: string, timezone?: string, locale?: string): null;
    transform(value: string | number | Date | null | undefined, format?: string, timezone?: string, locale?: string): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AppDatePipe, "appdate", true>;
}
declare class AppDateTimePipe extends DatePipe implements PipeTransform {
    transform(value: string | number | Date, format?: string, timezone?: string, locale?: string): string;
    transform(value: null, format?: string, timezone?: string, locale?: string): null;
    transform(value: string | number | Date | null | undefined, format?: string, timezone?: string, locale?: string): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppDateTimePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AppDateTimePipe, "appdatetime", true>;
}

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

declare class AppCurrencyPipe implements PipeTransform {
    transform(value: number, currencyCode?: string, currencyId?: number, digitsInfo?: string, locale?: string): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppCurrencyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AppCurrencyPipe, "appcurrency", true>;
}

declare class DynamicPipe implements PipeTransform {
    private injector;
    constructor(injector: Injector);
    transform(value: unknown, pipeName: unknown, pipeArgs?: Array<unknown>): unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DynamicPipe, "dynamic", true>;
}

declare class UpdateFiltersService {
    router: Router;
    constructor(router: Router);
    getRemoteFilter(queryParams: Record<string, unknown>, remoteFilterObject: Record<string, unknown>): Record<string, unknown>;
    getPaginationData(queryParams: Record<string, unknown>, page: Record<string, unknown>): Record<string, unknown>;
    filterByText(text: string, filterName: string, remoteFilter: Record<string, unknown>, page: Record<string, unknown>): void;
    applyFilters(filter: Record<string, unknown>): void;
    parseQueryParams(queryParams: Record<string, unknown>): Record<string, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateFiltersService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateFiltersService>;
}

interface IChildConfig {
    inputs: object;
    outputs: object;
}
declare class DomService {
    private componentFactoryResolver;
    private appRef;
    private injector;
    private childComponentRef;
    private child_dom_element_id;
    constructor(componentFactoryResolver: ComponentFactoryResolver, appRef: ApplicationRef, injector: Injector);
    appendComponentTo(parentId: string, child: unknown, childConfig?: IChildConfig): ComponentRef<unknown>;
    removeComponent(): void;
    private attachConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<DomService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DomService>;
}

interface IMethodRef {
    method: string;
    params?: Record<string, unknown>;
}
declare class SelectionBarService {
    private domService;
    selected$: BehaviorSubject<SelectionModel<unknown>>;
    callMethod$: BehaviorSubject<IMethodRef>;
    private selectionBarElementId;
    constructor(domService: DomService);
    selected<T>(selected: SelectionModel<T>): void;
    callMethod(methodRef: IMethodRef): void;
    clearMethod(): void;
    init(component: unknown, inputs: object, outputs: object): ComponentRef<unknown> | undefined;
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionBarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionBarService>;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

interface IPage {
    length?: number;
    pageIndex?: number;
    pageSize?: number;
}
interface IRequestCollectionOptions {
    service: Service;
    filter: object;
    clear_data?: boolean;
    include: Array<string>;
    beforepath: string | undefined;
    page?: PageEvent | IPage;
    sort?: Array<string>;
    disable_query_params_update?: boolean;
    ttl?: number;
}
declare class ListBaseComponent implements OnInit, OnDestroy {
    protected router: Router;
    protected selectionBarService: SelectionBarService;
    updateFiltersService: UpdateFiltersService;
    activatedRoute: ActivatedRoute;
    protected changeDetectorRef?: ChangeDetectorRef | undefined;
    collection: DocumentCollection;
    collectionInfiniteScroll: Array<Resource>;
    page: IPage;
    service: Service;
    limit: number;
    pageSize: number;
    pagIndex: number;
    pageSizeOptions: Array<number>;
    remoteFilter: Record<string, unknown>;
    queryParams: Record<string, unknown>;
    disableQueryParamsUpdate: boolean;
    initialSelection: Array<Resource>;
    allowMultiSelect: boolean;
    selection: SelectionModel<Resource>;
    selection_bar_component: unknown;
    selection_bar_inputs: Record<string, unknown>;
    dataTableSource: MatTableDataSource<Resource>;
    protected essential_filters: Record<string, unknown>;
    protected destroyer: Destroyer;
    protected block_query_params: boolean;
    protected deprecate_collection_subscription: Subject<void>;
    protected last_remote_filter: Record<string, unknown>;
    protected last_page: IPage;
    constructor(router: Router, selectionBarService: SelectionBarService, updateFiltersService: UpdateFiltersService, activatedRoute: ActivatedRoute, changeDetectorRef?: ChangeDetectorRef | undefined);
    ngOnInit(): void;
    updateFilter(current_filter: Record<string, unknown>): void;
    updatePagination(page: IPage): void;
    resetFilters(): void;
    realReload(page?: IPage): void;
    fillPageData(page: IPage | PageEvent): void;
    requestCollectionAndUpdatePagination(request_options: IRequestCollectionOptions): Observable<DocumentCollection>;
    ngOnDestroy(): void;
    /** Checks if the number of selected rows matches the total number of rows */
    isAllSelected(): boolean;
    /** Selects all rows if they are not all selected; otherwise clear selection. */
    masterToggle(): void;
    callCheckboxEvents(event: {
        checked: boolean;
    }, row?: Resource): void;
    openSelection(): void;
    selectedMenuOption(option: {
        key: string;
        data?: Array<unknown>;
    }): void;
    protected compare(a: string | number, b: string | number, isAsc: boolean): number;
    protected clearSelected(): void;
    protected subscribeToSelectionBarEvents(selection_bar_component: ComponentRef<{
        reload: EventEmitter<void>;
        clearSelection: EventEmitter<void>;
    }>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListBaseComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

declare class ListBaseCommonComponent extends ListBaseComponent implements OnInit, OnChanges, OnDestroy {
    router: Router;
    activatedRoute: ActivatedRoute;
    updateFiltersService: UpdateFiltersService;
    selectionBarService: SelectionBarService;
    private breakpointObserver;
    private translateService;
    protected changeDetectorRef: ChangeDetectorRef;
    tableColumns: Array<Column>;
    displayedColumns: Array<string>;
    expandableRow: TemplateRef<unknown>;
    expandedElement: Resource | null;
    editElement: Resource | null;
    overrideEditableCellsSave: boolean;
    ngContentColumns: Array<string>;
    columnPipes: Record<string, unknown>;
    service: Service;
    include: Array<string>;
    beforePath: string;
    remoteFilter: Record<string, unknown>;
    actions: Array<Action>;
    showTableLoader: boolean;
    showActionsMenu: boolean;
    actions_menu: Menu;
    selectionBarComponent: Component;
    selectionBarComponentInputs: Record<string, unknown>;
    checkbox: boolean;
    responsiveColumns: ResponsiveColumns;
    resizeContent: boolean;
    page: IPage;
    sort: Array<string>;
    disableQueryParamsUpdate: boolean;
    nothingHereClasses: string;
    nothingHereText: string;
    imageOrIcon: 'image' | 'icon';
    nothingHereIcon: string;
    nothingHereImageUrl: string;
    reloadPageData: IPage;
    collectionInfiniteScroll: Array<Resource>;
    dataTableSource: MatTableDataSource<Resource>;
    saveEditableCell: EventEmitter<Resource>;
    pageLengthChange: EventEmitter<number>;
    pageSizeOptionsEmit: EventEmitter<Array<number>>;
    collectionChange: EventEmitter<DocumentCollection>;
    actionsClick: EventEmitter<unknown>;
    rowClick: EventEmitter<unknown>;
    rowDoubleClick: EventEmitter<unknown>;
    selectionBarComponentCreated: EventEmitter<ComponentRef<unknown>>;
    openedActionsMenu: EventEmitter<Resource>;
    trackById: (_index: number, resource: Resource) => string;
    masterCheckbox: SelectionModel<Resource>;
    Breakpoints: typeof Breakpoints;
    constructor(router: Router, activatedRoute: ActivatedRoute, updateFiltersService: UpdateFiltersService, selectionBarService: SelectionBarService, breakpointObserver: BreakpointObserver, translateService: TranslateService, changeDetectorRef: ChangeDetectorRef);
    columnHeaderClasses: (column: string, element: Resource) => Record<string, string>;
    columnHeaderStyles: (column: string, element: Resource) => Record<string, string>;
    cellClasses: (column: string, element: Resource) => Record<string, string>;
    cellStyles: (column: string, element: Resource) => Record<string, string>;
    cellDataClasses: (column: string, element: Resource) => Record<string, string>;
    cellDataStyles: (column: string, element: Resource) => Record<string, string> | null;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private changeReloadPageData;
    private changeCollectionInfiniteScroll;
    realReload(page?: PageEvent | IPage, options?: IParamsCollection, clear_data?: boolean): void;
    mainRowClick(row: Resource): void;
    editTableElement(element: Resource): void;
    clearEditElement(): void;
    saveTableElement(element: Resource, column: Column, value: unknown): void;
    actionClick(element: Resource, key: string): void;
    openSelection(): void;
    getDisplayedColumns(table_columns: Array<Column>, displayed_columns_array?: Array<string>): Array<string>;
    sortByColumn(sort: Sort): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListBaseCommonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListBaseCommonComponent, "jam-list-base-common", never, { "tableColumns": { "alias": "tableColumns"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "expandableRow": { "alias": "expandableRow"; "required": false; }; "expandedElement": { "alias": "expandedElement"; "required": false; }; "editElement": { "alias": "editElement"; "required": false; }; "overrideEditableCellsSave": { "alias": "overrideEditableCellsSave"; "required": false; }; "ngContentColumns": { "alias": "ngContentColumns"; "required": false; }; "columnPipes": { "alias": "columnPipes"; "required": false; }; "service": { "alias": "service"; "required": false; }; "include": { "alias": "include"; "required": false; }; "beforePath": { "alias": "beforePath"; "required": false; }; "remoteFilter": { "alias": "remoteFilter"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "showTableLoader": { "alias": "showTableLoader"; "required": false; }; "showActionsMenu": { "alias": "showActionsMenu"; "required": false; }; "actions_menu": { "alias": "actions_menu"; "required": false; }; "selectionBarComponent": { "alias": "selectionBarComponent"; "required": false; }; "selectionBarComponentInputs": { "alias": "selectionBarComponentInputs"; "required": false; }; "checkbox": { "alias": "checkbox"; "required": false; }; "responsiveColumns": { "alias": "responsiveColumns"; "required": false; }; "resizeContent": { "alias": "resizeContent"; "required": false; }; "page": { "alias": "page"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "disableQueryParamsUpdate": { "alias": "disableQueryParamsUpdate"; "required": false; }; "nothingHereClasses": { "alias": "nothingHereClasses"; "required": false; }; "nothingHereText": { "alias": "nothingHereText"; "required": false; }; "imageOrIcon": { "alias": "imageOrIcon"; "required": false; }; "nothingHereIcon": { "alias": "nothingHereIcon"; "required": false; }; "nothingHereImageUrl": { "alias": "nothingHereImageUrl"; "required": false; }; "reloadPageData": { "alias": "reloadPageData"; "required": false; }; "collectionInfiniteScroll": { "alias": "collectionInfiniteScroll"; "required": false; }; "dataTableSource": { "alias": "dataTableSource"; "required": false; }; "columnHeaderClasses": { "alias": "columnHeaderClasses"; "required": false; }; "columnHeaderStyles": { "alias": "columnHeaderStyles"; "required": false; }; "cellClasses": { "alias": "cellClasses"; "required": false; }; "cellStyles": { "alias": "cellStyles"; "required": false; }; "cellDataClasses": { "alias": "cellDataClasses"; "required": false; }; "cellDataStyles": { "alias": "cellDataStyles"; "required": false; }; }, { "saveEditableCell": "saveEditableCell"; "pageLengthChange": "pageLengthChange"; "pageSizeOptionsEmit": "pageSizeOptionsEmit"; "collectionChange": "collectionChange"; "actionsClick": "actionsClick"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "selectionBarComponentCreated": "selectionBarComponentCreated"; "openedActionsMenu": "openedActionsMenu"; }, never, ["*"], true, never>;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

declare class ListBaseCommonPaginatorComponent implements AfterViewInit, OnChanges {
    private changeDetectorRef;
    private rsRefreshService;
    reloadPageData: IPage | undefined;
    pageSizeOptions: Array<number>;
    dataTableSource: MatTableDataSource<Resource>;
    table: ListBaseCommonComponent;
    tableColumns: Array<Column>;
    displayedColumns: Array<string>;
    expandableRow: TemplateRef<unknown>;
    expandedElement: Resource;
    editElement: Resource;
    overrideEditableCellsSave: boolean;
    ngContentColumns: Array<string>;
    columnPipes: Record<string, unknown>;
    service: Service;
    include: Array<string>;
    beforePath: string;
    remoteFilter: Record<string, unknown>;
    actions: Array<Action>;
    showTableLoader: boolean;
    showActionsMenu: boolean;
    actions_menu: Menu;
    selectionBarComponent: Component;
    selectionBarComponentInputs: Record<string, unknown>;
    checkbox: boolean;
    responsiveColumns: ResponsiveColumns;
    resizeContent: boolean;
    page: IPage;
    sort: Array<string>;
    disableQueryParamsUpdate: boolean;
    nothingHereClasses: string;
    nothingHereText: string;
    imageOrIcon: 'image' | 'icon';
    nothingHereIcon: string;
    nothingHereImageUrl: string;
    saveEditableCell: EventEmitter<Resource>;
    collectionChange: EventEmitter<DocumentCollection>;
    actionsClick: EventEmitter<unknown>;
    rowClick: EventEmitter<unknown>;
    rowDoubleClick: EventEmitter<unknown>;
    selectionBarComponentCreated: EventEmitter<ComponentRef<unknown>>;
    openedActionsMenu: EventEmitter<Resource>;
    columnHeaderClasses: (column: string, element: Resource) => Record<string, string>;
    columnHeaderStyles: (column: string, element: Resource) => Record<string, string>;
    cellClasses: (column: string, element: Resource) => Record<string, string>;
    cellStyles: (column: string, element: Resource) => Record<string, string>;
    cellDataClasses: (column: string, element: Resource) => Record<string, string>;
    cellDataStyles: (column: string, element: Resource) => Record<string, string> | null;
    private destroyer;
    constructor(changeDetectorRef: ChangeDetectorRef, rsRefreshService: JamRefreshService);
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    realReload(page?: PageEvent | IPage, options?: IParamsCollection, clear_data?: boolean): void;
    updateFilter(current_filter: Record<string, unknown>): void;
    pageLengthChange(length: number): void;
    pageSizeOptionsEmit(pageSizeOptions: Array<number>): void;
    reloadPage(page: IPage): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListBaseCommonPaginatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListBaseCommonPaginatorComponent, "jam-list-base-common-paginator", never, { "tableColumns": { "alias": "tableColumns"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "expandableRow": { "alias": "expandableRow"; "required": false; }; "expandedElement": { "alias": "expandedElement"; "required": false; }; "editElement": { "alias": "editElement"; "required": false; }; "overrideEditableCellsSave": { "alias": "overrideEditableCellsSave"; "required": false; }; "ngContentColumns": { "alias": "ngContentColumns"; "required": false; }; "columnPipes": { "alias": "columnPipes"; "required": false; }; "service": { "alias": "service"; "required": true; }; "include": { "alias": "include"; "required": false; }; "beforePath": { "alias": "beforePath"; "required": false; }; "remoteFilter": { "alias": "remoteFilter"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "showTableLoader": { "alias": "showTableLoader"; "required": false; }; "showActionsMenu": { "alias": "showActionsMenu"; "required": false; }; "actions_menu": { "alias": "actions_menu"; "required": false; }; "selectionBarComponent": { "alias": "selectionBarComponent"; "required": false; }; "selectionBarComponentInputs": { "alias": "selectionBarComponentInputs"; "required": false; }; "checkbox": { "alias": "checkbox"; "required": false; }; "responsiveColumns": { "alias": "responsiveColumns"; "required": false; }; "resizeContent": { "alias": "resizeContent"; "required": false; }; "page": { "alias": "page"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "disableQueryParamsUpdate": { "alias": "disableQueryParamsUpdate"; "required": false; }; "nothingHereClasses": { "alias": "nothingHereClasses"; "required": false; }; "nothingHereText": { "alias": "nothingHereText"; "required": false; }; "imageOrIcon": { "alias": "imageOrIcon"; "required": false; }; "nothingHereIcon": { "alias": "nothingHereIcon"; "required": false; }; "nothingHereImageUrl": { "alias": "nothingHereImageUrl"; "required": false; }; "columnHeaderClasses": { "alias": "columnHeaderClasses"; "required": false; }; "columnHeaderStyles": { "alias": "columnHeaderStyles"; "required": false; }; "cellClasses": { "alias": "cellClasses"; "required": false; }; "cellStyles": { "alias": "cellStyles"; "required": false; }; "cellDataClasses": { "alias": "cellDataClasses"; "required": false; }; "cellDataStyles": { "alias": "cellDataStyles"; "required": false; }; }, { "saveEditableCell": "saveEditableCell"; "collectionChange": "collectionChange"; "actionsClick": "actionsClick"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "selectionBarComponentCreated": "selectionBarComponentCreated"; "openedActionsMenu": "openedActionsMenu"; }, never, never, true, never>;
}

/***
 * Copyright (C) 1997-2017 Reyesoft <info@reyesoft.com>
 *
 * This file is part of Multinexo. Multinexo can not be copied and/or
 * distributed without the express permission of Reyesoft
 */

declare class ListBaseCommonInfiniteScrollComponent implements AfterViewInit {
    private changeDetectorRef;
    private rsRefreshService;
    private translateService;
    reloadPageData: IPage;
    collection: Array<Resource>;
    disableQueryParamsUpdate: boolean;
    disabledButton: boolean;
    pageIndex: number;
    dataTableSource: MatTableDataSource<Resource>;
    private destroyer;
    table: ListBaseCommonComponent;
    tableColumns: Array<Column>;
    displayedColumns: Array<string>;
    expandableRow: TemplateRef<unknown>;
    expandedElement: Resource;
    editElement: Resource;
    overrideEditableCellsSave: boolean;
    ngContentColumns: Array<string>;
    columnPipes: Record<string, unknown>;
    service: Service;
    include: Array<string>;
    beforePath: string;
    remoteFilter: Record<string, unknown>;
    actions: Array<Action>;
    showTableLoader: boolean;
    showActionsMenu: boolean;
    actions_menu: Menu;
    selectionBarComponent: Component;
    selectionBarComponentInputs: Record<string, unknown>;
    checkbox: boolean;
    responsiveColumns: ResponsiveColumns;
    resizeContent: boolean;
    page: IPage;
    sort: Array<string>;
    nothingHereClasses: string;
    nothingHereText: string;
    imageOrIcon: 'image' | 'icon';
    nothingHereIcon: string;
    nothingHereImageUrl: string;
    saveEditableCell: EventEmitter<Resource>;
    collectionChange: EventEmitter<DocumentCollection>;
    actionsClick: EventEmitter<unknown>;
    rowClick: EventEmitter<unknown>;
    rowDoubleClick: EventEmitter<unknown>;
    selectionBarComponentCreated: EventEmitter<ComponentRef<unknown>>;
    openedActionsMenu: EventEmitter<Resource>;
    columnHeaderClasses: (column: string, element: Resource) => Record<string, string>;
    columnHeaderStyles: (column: string, element: Resource) => Record<string, string>;
    cellClasses: (column: string, element: Resource) => Record<string, string>;
    cellStyles: (column: string, element: Resource) => Record<string, string>;
    cellDataClasses: (column: string, element: Resource) => Record<string, string>;
    cellDataStyles: (column: string, element: Resource) => Record<string, string> | null;
    constructor(changeDetectorRef: ChangeDetectorRef, rsRefreshService: JamRefreshService, translateService: TranslateService);
    ngAfterViewInit(): void;
    realReload(page?: PageEvent | IPage, options?: IParamsCollection, clear_data?: boolean): void;
    updateFilter(current_filter: Record<string, unknown>): void;
    private observerAutoRefresh;
    private observerRefresh;
    pageLengthChange(length: number): void;
    reloadPage(): void;
    setCollection(collection: DocumentCollection): void;
    private disableButton;
    private cutAndReload;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListBaseCommonInfiniteScrollComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListBaseCommonInfiniteScrollComponent, "jam-list-base-common-infinite-scroll", never, { "tableColumns": { "alias": "tableColumns"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "expandableRow": { "alias": "expandableRow"; "required": false; }; "expandedElement": { "alias": "expandedElement"; "required": false; }; "editElement": { "alias": "editElement"; "required": false; }; "overrideEditableCellsSave": { "alias": "overrideEditableCellsSave"; "required": false; }; "ngContentColumns": { "alias": "ngContentColumns"; "required": false; }; "columnPipes": { "alias": "columnPipes"; "required": false; }; "service": { "alias": "service"; "required": true; }; "include": { "alias": "include"; "required": false; }; "beforePath": { "alias": "beforePath"; "required": false; }; "remoteFilter": { "alias": "remoteFilter"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "showTableLoader": { "alias": "showTableLoader"; "required": false; }; "showActionsMenu": { "alias": "showActionsMenu"; "required": false; }; "actions_menu": { "alias": "actions_menu"; "required": false; }; "selectionBarComponent": { "alias": "selectionBarComponent"; "required": false; }; "selectionBarComponentInputs": { "alias": "selectionBarComponentInputs"; "required": false; }; "checkbox": { "alias": "checkbox"; "required": false; }; "responsiveColumns": { "alias": "responsiveColumns"; "required": false; }; "resizeContent": { "alias": "resizeContent"; "required": false; }; "page": { "alias": "page"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "nothingHereClasses": { "alias": "nothingHereClasses"; "required": false; }; "nothingHereText": { "alias": "nothingHereText"; "required": false; }; "imageOrIcon": { "alias": "imageOrIcon"; "required": false; }; "nothingHereIcon": { "alias": "nothingHereIcon"; "required": false; }; "nothingHereImageUrl": { "alias": "nothingHereImageUrl"; "required": false; }; "columnHeaderClasses": { "alias": "columnHeaderClasses"; "required": false; }; "columnHeaderStyles": { "alias": "columnHeaderStyles"; "required": false; }; "cellClasses": { "alias": "cellClasses"; "required": false; }; "cellStyles": { "alias": "cellStyles"; "required": false; }; "cellDataClasses": { "alias": "cellDataClasses"; "required": false; }; "cellDataStyles": { "alias": "cellDataStyles"; "required": false; }; }, { "saveEditableCell": "saveEditableCell"; "collectionChange": "collectionChange"; "actionsClick": "actionsClick"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "selectionBarComponentCreated": "selectionBarComponentCreated"; "openedActionsMenu": "openedActionsMenu"; }, never, never, true, never>;
}

declare class InfoButtonComponent implements OnInit {
    private translateService;
    /** @param externalUrl required property */
    externalUrl: string;
    /**
     * @param icon optional property -
     * @description By default acquires as icon "info"
     */
    icon: 'info' | 'help';
    /** @param jamTooltip optional property */
    jamTooltip: string;
    constructor(translateService: TranslateService);
    ngOnInit(): void;
    /** @method checkIcon Checks arriving icon, if not supported, then returns info. */
    private checkIcon;
    static ɵfac: i0.ɵɵFactoryDeclaration<InfoButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InfoButtonComponent, "jam-info-button", never, { "externalUrl": { "alias": "externalUrl"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "jamTooltip": { "alias": "jamTooltip"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SelectionBarContainerComponent {
    protected selectionBarService: SelectionBarService;
    protected router: Router;
    constructor(selectionBarService: SelectionBarService, router: Router);
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionBarContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionBarContainerComponent, "jam-selection-bar-container", never, {}, {}, never, never, true, never>;
}

declare class SelectionBarInfoComponent implements OnDestroy {
    protected selectionBarService: SelectionBarService;
    private translateService;
    selection: SelectionModel<unknown>;
    label: string;
    private destroyer;
    constructor(selectionBarService: SelectionBarService, translateService: TranslateService);
    ngOnDestroy(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionBarInfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionBarInfoComponent, "jam-selection-bar-info", never, {}, {}, never, never, true, never>;
}

declare class NgxJsonapiMaterialComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxJsonapiMaterialComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxJsonapiMaterialComponent, "jam-ngx-jsonapi-material", never, {}, {}, never, never, true, never>;
}

export { Action, AppCapitalizePipe, AppCurrencyPipe, AppDatePipe, AppDateTimePipe, AvoidDisabledStyleDirective, Button, CheckboxDynamicInput, ChipsAutocompleteComponent, Column, ConfirmationDialogComponent, CustomValidators, DeleteConfirmationComponent, Destroyer, DomService, DropdownMenuComponent, DynamicInput, DynamicPipe, EditTextAttributeDialogComponent, FILTER_DATE_RANGE_TYPE, FabSpeedDialComponent, FabSpeedDialMiniButton, FilterConfig, FilterPipe, FloatingButtonComponent, FloatingFiltersComponent, FloatingInputComponent, FormlyFormFlexComponent, GalleryManagerComponent, InfoButtonComponent, JamAutocompleteComponent, JamFilterChecksComponent, JamFilterOptionsComponent, JamOptionFooterComponent, JamRefreshService, JamSlideComponent as JamSlide, JamSlideBase, JamSlideChangeEvent, JamSlideComponent, JamSlideElementDirective as JamSlideElement, JamSlideElementDirective, JamSlideElementWrapperDirective as JamSlideElementWrapper, JamSlideElementWrapperBase, JamSlideElementWrapperDirective, JamSlideGroupBase, JamSlideGroupComponent, JamSlideHeaderComponent as JamSlideHeader, JamSlideHeaderBase, JamSlideHeaderComponent, JamTabsDirective, JsonapiFilterRangedateConfig, ListBaseCommonComponent, ListBaseCommonInfiniteScrollComponent, ListBaseCommonPaginatorComponent, ListBaseComponent, MAT_TABS_CONFIG, Menu, MenuComponent, NGX_JSONAPI_MATERIAL_I18N_EN_FILE, NGX_JSONAPI_MATERIAL_I18N_ES_FILE, NgxJsonapiMaterialComponent, NumberDynamicInput, PictureManagerComponent, PinOptionButtonComponent, RefreshComponent, RemembermeStateDirective, ResponsiveColumns, SearchInputComponent, Section, SelectComponent, SelectDynamicInput, SelectionBarContainerComponent, SelectionBarInfoComponent, SelectionBarService, SingleWarningComponent, SubmitComponent, TextDynamicInput, TextareaDynamicInput, TopWarningComponent, TopWarningService, UpdateFiltersService, batchAll, filterOrRequest, hasModifierKey, jamSlidesAnimations, loadNgxJsonapiMaterialTranslationsFromAssets, provideNgxJsonapiMaterial, registerNgxJsonapiMaterialTranslations, registerNgxJsonapiMaterialTranslationsFromAssets, trackById };
export type { Filter, FilterChecks, FilterDateRange, FilterOption, IColumnPipe, IEditTextAttributeData, IMethodRef, IOption, IPage, IPinButton, IRequestCollectionOptions, IWarning, ImageChange, JamSlideHeaderPosition, JamSlidesConfig, MenuButtonAttributes, NgxJsonapiMaterialTranslations, ResourceFilter, ScrollDirection };