ui-core-abv 0.0.0-watch

package/lib/components/item-value/item-value.component.d.ts

@@ -0,0 +1,30 @@
+import { DoCheck, EventEmitter } from '@angular/core';
+import { ColumnTypes, TableRow, TableRowData } from '../table/table.models';
+import { AlertData } from '../tiny-alert/tiny-alert.model';
+import * as i0 from "@angular/core";
+export declare class ItemValueComponent implements DoCheck {
+    private readonly alers;
+    key: string | number;
+    type: ColumnTypes;
+    alignment: string;
+    row: TableRow;
+    disabled: boolean;
+    data: TableRowData | null;
+    switchValidation: AlertData[];
+    switchConfirmed: EventEmitter<boolean>;
+    expanded: boolean;
+    checked: boolean;
+    currentData: TableRowData | null;
+    private previousRow?;
+    private previousRowData?;
+    private previousKey;
+    private previousInputData;
+    ngDoCheck(): void;
+    private syncCurrentData;
+    private resolveCurrentData;
+    switchHandler(rowId: string | number, value: boolean): void;
+    expand(click: MouseEvent): void;
+    copyText(text: string, click: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemValueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItemValueComponent, "ui-item-value", never, { "key": { "alias": "key"; "required": false; }; "type": { "alias": "type"; "required": false; }; "alignment": { "alias": "alignment"; "required": false; }; "row": { "alias": "row"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "data": { "alias": "data"; "required": false; }; "switchValidation": { "alias": "switchValidation"; "required": false; }; }, { "switchConfirmed": "switchConfirmed"; }, never, never, true, never>;
+}

package/lib/components/kpi-card/kpi-card.component.d.ts

@@ -0,0 +1,15 @@
+import { ButtonColor } from '../button/button.component';
+import * as i0 from "@angular/core";
+export declare class UicKpiCardComponent {
+    data: UicKpiContet;
+    loading: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicKpiCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicKpiCardComponent, "ui-kpi-card", never, { "data": { "alias": "data"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, never, true, never>;
+}
+export interface UicKpiContet {
+    label: string;
+    value: string;
+    icon?: string;
+    iconColor?: ButtonColor;
+    textColor?: ButtonColor;
+}

package/lib/components/modal/floating-modal/modal.component.d.ts

@@ -0,0 +1,21 @@
+import { Injector, Type } from '@angular/core';
+import { CdkPortalOutlet } from '@angular/cdk/portal';
+import { ModalConfig } from './modalconfig.model';
+import { UiModalRef } from '../../../services/modaRef';
+import * as i0 from "@angular/core";
+export declare class UicModalComponent {
+    private readonly modalRef;
+    private readonly component;
+    private readonly congif;
+    private readonly injector;
+    myConfig: ModalConfig;
+    ready: boolean;
+    title: string;
+    portalOutlet: CdkPortalOutlet;
+    constructor(modalRef: UiModalRef, component: Type<any>, congif: ModalConfig, injector: Injector);
+    ngAfterViewInit(): void;
+    closeOuside(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicModalComponent, "ui-modal", never, {}, {}, never, never, true, never>;
+}

package/lib/components/modal/floating-modal/modalconfig.model.d.ts

@@ -0,0 +1,7 @@
+export interface ModalConfig<T = any> {
+    data?: T;
+    title?: string;
+    preventCloseingOutside?: boolean;
+    size?: 'small' | 'medium' | 'large';
+    noPadding?: boolean;
+}

package/lib/components/modal/side-modal/side-modal.component.d.ts

@@ -0,0 +1,30 @@
+import { CdkPortalOutlet } from '@angular/cdk/portal';
+import { Injector, Type } from '@angular/core';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { SideModalConfig } from './sideModalConfig.model';
+import { UiModalRef } from '../../../services/modaRef';
+import { UicModalService } from '../../../services/modal.service';
+import * as i0 from "@angular/core";
+export declare class UicSideModalComponent {
+    private readonly modalRef;
+    private readonly component;
+    private readonly congif;
+    private readonly injector;
+    private readonly modal;
+    overlayRef: OverlayRef;
+    state: 'visible' | 'hidden';
+    show: boolean;
+    myConfig: SideModalConfig;
+    ready: boolean;
+    portalOutlet: CdkPortalOutlet;
+    constructor(modalRef: UiModalRef, component: Type<any>, congif: SideModalConfig, injector: Injector, modal: UicModalService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    closeOuside(): void;
+    close(): void;
+    cancel(): void;
+    onAnimationDone(event: any): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicSideModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicSideModalComponent, "ui-side-modal", never, {}, {}, never, never, true, never>;
+}

package/lib/components/modal/side-modal/sideModalConfig.model.d.ts

@@ -0,0 +1,16 @@
+export interface SideModalConfig<T = any> {
+    data?: T;
+    title?: string;
+    subtitle?: string;
+    preventCloseingOutside?: boolean;
+    footerEnabled?: boolean;
+    footerOkButtonText?: string;
+    showCancelButton?: boolean;
+    preventCloseOnCancel?: boolean;
+    footerCancelButtonText?: string;
+    footerCancelIcon?: string;
+    footerOkIcon?: string;
+    headerEnabled?: boolean;
+    width?: string;
+    noPadding?: boolean;
+}

package/lib/components/overlay-card/overlay-card.component.d.ts

@@ -0,0 +1,17 @@
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class UicOverlayCardComponent {
+    menuTemplate: TemplateRef<any>;
+    private overlayRef;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly host;
+    selectedSet: Set<string | number>;
+    allSelected: boolean;
+    overlayPositions: ConnectedPosition[];
+    openMenu(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicOverlayCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicOverlayCardComponent, "ui-overlay-card", never, {}, {}, never, ["[button]", "[content]"], true, never>;
+}

package/lib/components/pool-options/pool-options.component.d.ts

@@ -0,0 +1,46 @@
+import { SimpleChanges } from '@angular/core';
+import { AppSelectOption } from '../inputs/select/select.component';
+import * as i0 from "@angular/core";
+type selectId = number | string;
+type selectedDetailed = {
+    id: selectId;
+    detail?: string;
+};
+declare const base: abstract new () => {
+    value: selectedDetailed[];
+    valueChange: import("@angular/core").EventEmitter<selectedDetailed[]>;
+    onChange: (value: selectedDetailed[]) => void;
+    onTouched: () => void;
+    writeValue(obj: selectedDetailed[]): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    notifyChange(value: selectedDetailed[]): void;
+};
+export declare class UicPoolOptionsComponent extends base {
+    icon: string;
+    iconColor: 'primary' | 'secondary';
+    size: 's' | 'm' | 'l';
+    label: string;
+    error: string;
+    tip: string;
+    disabled: boolean;
+    loading: boolean;
+    multy: boolean;
+    enabledListView: boolean;
+    listViewTitle: string;
+    options: AppSelectOption[];
+    private selectedItems;
+    get selectedValues(): selectedDetailed[];
+    updateOptions(id: selectId): void;
+    updateDetail(id: selectId, detail: string): void;
+    writeValue(value?: selectedDetailed[] | selectId[] | null): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    isSelected(id: selectId): boolean;
+    getItemName(id: selectId): selectId;
+    private emitSelectionChange;
+    private normalizeIncomingValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicPoolOptionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicPoolOptionsComponent, "ui-pool-options", never, { "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "size": { "alias": "size"; "required": false; }; "label": { "alias": "label"; "required": false; }; "error": { "alias": "error"; "required": false; }; "tip": { "alias": "tip"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "multy": { "alias": "multy"; "required": false; }; "enabledListView": { "alias": "enabledListView"; "required": false; }; "listViewTitle": { "alias": "listViewTitle"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/progress-bar/progress-bar.component.d.ts

@@ -0,0 +1,17 @@
+import { OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { ButtonColor } from '../button/button.component';
+import * as i0 from "@angular/core";
+export declare class UicProgressBarComponent implements OnChanges, OnDestroy {
+    progress: number;
+    color: ButtonColor;
+    height: number;
+    displayProgress: number;
+    private rafId;
+    get clampedProgress(): number;
+    get heightPx(): string;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private scheduleProgressUpdate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicProgressBarComponent, "ui-progress-bar", never, { "progress": { "alias": "progress"; "required": false; }; "color": { "alias": "color"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/push-alerts/alert/alert.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { Alert } from '../alert.model';
+import * as i0 from "@angular/core";
+export declare class UiAlertComponent implements OnInit {
+    alert: Alert;
+    closeAlert: EventEmitter<number>;
+    interval: any;
+    progressValue: number;
+    animationIntevalMs: number;
+    pauseAnimation: boolean;
+    id: number;
+    ngOnInit(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiAlertComponent, "ui-alert", never, { "alert": { "alias": "alert"; "required": false; }; }, { "closeAlert": "closeAlert"; }, never, never, true, never>;
+}

package/lib/components/push-alerts/alert-container/alert-container.component.d.ts

@@ -0,0 +1,13 @@
+import { OnInit } from '@angular/core';
+import { Alert } from '../alert.model';
+import { UicPushAlertService } from '../../../services/push-alert.service';
+import * as i0 from "@angular/core";
+export declare class UicAlertContainerComponent implements OnInit {
+    private readonly alertService;
+    alerts: Alert[];
+    constructor(alertService: UicPushAlertService);
+    ngOnInit(): void;
+    dismis(id: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicAlertContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicAlertContainerComponent, "ui-alert-container", never, {}, {}, never, never, true, never>;
+}

package/lib/components/push-alerts/alert.helpers.d.ts

@@ -0,0 +1,5 @@
+import { Alert } from './alert.model';
+export declare function createSuccessAlert(message: string, options?: Partial<Alert>): Alert;
+export declare function createErrorAlert(message: string, options?: Partial<Alert>): Alert;
+export declare function createWarningAlert(message: string, options?: Partial<Alert>): Alert;
+export declare function createInfoAlert(message: string, options?: Partial<Alert>): Alert;

package/lib/components/push-alerts/alert.model.d.ts

@@ -0,0 +1,29 @@
+export interface Alert {
+    id: number;
+    message: string;
+    type: 'success' | 'error' | 'warning' | 'info';
+    title?: string;
+    icon?: string;
+    okButtonText?: string;
+    showProgressBar?: boolean;
+    cancelButtonText?: string;
+    style?: 'filled' | 'bordered';
+    duration?: number;
+}
+export type AlertConfigParams = Omit<Alert, 'id'>;
+export type SuccessAlert = Omit<Alert, 'type'> & {
+    style: 'filled';
+    type: 'success';
+};
+export type ErrorAlert = Omit<Alert, 'type'> & {
+    style: 'filled';
+    type: 'error';
+};
+export type WarningAlert = Omit<Alert, 'type'> & {
+    style: 'filled';
+    type: 'warning';
+};
+export type InfoAlert = Omit<Alert, 'type'> & {
+    style: 'filled';
+    type: 'info';
+};

package/lib/components/push-alerts/tynyalert.helpers.d.ts

@@ -0,0 +1,6 @@
+import { AlertData } from '../tiny-alert/tiny-alert.model';
+export declare function createTinySuccess(body: string, options?: Partial<AlertData>): AlertData;
+export declare function createTinyError(body: string, options?: Partial<AlertData>): AlertData;
+export declare function createTinyDelete(body: string, options?: Partial<AlertData>): AlertData;
+export declare function createTinyWarning(body: string, options?: Partial<AlertData>): AlertData;
+export declare function createTinyInfo(body: string, options?: Partial<AlertData>): AlertData;

package/lib/components/rule-builder/rule-builder.component.d.ts

@@ -0,0 +1,111 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { AppSelectOption } from '../inputs/select/select.component';
+import * as i0 from "@angular/core";
+export declare class UicRuleBuilderComponent implements OnInit {
+    private conditionsInitialized;
+    private emitConditionsOnInit;
+    private emitRuleDefinitionOnInit;
+    private conditionsEmitScheduled;
+    private ruleDefinitionEmitScheduled;
+    private _conditions;
+    disabled: boolean;
+    customNamesEnabled: boolean;
+    set conditions(value: UicConditionDefinition[] | null | undefined);
+    get conditions(): UicConditionDefinition[];
+    conditionOperators: AppSelectOption[];
+    conditionFields: ConditionField[];
+    conditionLabels: Record<string, string>;
+    editing: boolean;
+    private nextTemporalConditionId;
+    private externalRuleDefinition;
+    ruleTitle: string;
+    set ruleDefinition(value: RuleBuilderValue | null | undefined);
+    get ruleDefinition(): RuleBuilderValue;
+    ruleDefinitionChange: EventEmitter<RuleBuilderValue>;
+    conditionsChange: EventEmitter<UicConditionDefinition[]>;
+    editorRules: Rule[];
+    private readonly translate;
+    private readonly modal;
+    get resolvedTitle(): string;
+    ngOnInit(): void;
+    addRule(rules?: Rule[]): void;
+    addGroup(rules?: Rule[]): void;
+    changeOperator(rules: Rule[], idx: number): void;
+    removeRule(rules: Rule[], idx: number): void;
+    manageRules(rules: Rule[], idx: number): void;
+    print(): void;
+    reset(): void;
+    getOutput(): RuleOutput;
+    getConditionLabel(value: string | number | null | undefined): string;
+    isConditionLabelPending(value: string | number | null | undefined): boolean;
+    getConditionDetailTip(value: string | number | null | undefined): string;
+    getOperatorLabel(value: Rule['value']): string;
+    private appendExpression;
+    private syncRuleDefinition;
+    private createConditionRule;
+    private createGroupRule;
+    private collectConditionValues;
+    private normalizeRules;
+    private cloneRules;
+    private buildExpression;
+    private isExpression;
+    private parseExpression;
+    private getRulesFromDefinition;
+    private markRulesAsSaved;
+    private tokenizeExpression;
+    private parseTokens;
+    private resolveConditionValue;
+    private resolveConditionLabel;
+    private hasConditionReference;
+    private upsertCondition;
+    private buildRuleOutput;
+    private emitRuleDefinitionState;
+    private emitConditionsState;
+    private scheduleRuleDefinitionStateEmit;
+    private scheduleConditionsStateEmit;
+    private normalizeRuleBuilderValue;
+    private createEmptyRuleBuilderValue;
+    private areRuleBuilderValuesEqual;
+    private refreshAvailableConditions;
+    private syncConditionsWithPersistedConditions;
+    private replaceConditionReferences;
+    private getConditionReference;
+    private getNextTemporalConditionId;
+    private syncNextTemporalConditionId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicRuleBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicRuleBuilderComponent, "ui-rule-builder", never, { "disabled": { "alias": "disabled"; "required": false; }; "customNamesEnabled": { "alias": "customNamesEnabled"; "required": false; }; "conditions": { "alias": "conditions"; "required": false; }; "conditionOperators": { "alias": "conditionOperators"; "required": false; }; "conditionFields": { "alias": "conditionFields"; "required": false; }; "ruleTitle": { "alias": "ruleTitle"; "required": false; }; "ruleDefinition": { "alias": "ruleDefinition"; "required": false; }; }, { "ruleDefinitionChange": "ruleDefinitionChange"; "conditionsChange": "conditionsChange"; }, never, never, true, never>;
+}
+export interface RuleBuilderValue {
+    definition: string;
+    rulesToCreate: RuleToCreate[];
+}
+export type RuleOutput = RuleBuilderValue;
+export interface RuleToCreate {
+    temporalId: string;
+    fieldCode: string;
+    operatorCode: string;
+    value: string;
+    description: string;
+}
+export interface Rule {
+    type: 'condition' | 'operator' | 'group';
+    value?: 'AND' | 'OR' | string | number | null;
+    rules?: Rule[];
+    unsaved?: boolean;
+}
+export interface UicConditionDefinition {
+    id: number;
+    fieldName: string;
+    fieldCode: string;
+    operatorName: string;
+    operatorCode: string;
+    value: string;
+    description: string;
+    temporalId?: string;
+}
+export interface ConditionField {
+    id: number | string;
+    text: string;
+    type?: 'number' | 'string' | 'date' | 'catalog';
+    options?: AppSelectOption[];
+}

package/lib/components/rule-builder/rule-definirion/rule-definirion.component.d.ts

@@ -0,0 +1,55 @@
+import { OnDestroy } from '@angular/core';
+import { AppSelectOption } from '../../inputs/select/select.component';
+import { FormField, FormResult, uicFormValuesRecord } from '../../dynamic-form/form.models';
+import { ConditionField, UicConditionDefinition } from '../rule-builder.component';
+import * as i0 from "@angular/core";
+export declare class RuleDefinirionComponent implements OnDestroy {
+    data: {
+        conditions: UicConditionDefinition[];
+        customNamesEnabled: boolean;
+        conditionOperators: AppSelectOption[];
+        conditionFields: ConditionField[];
+        selectedConditionReference?: string | number | null;
+    };
+    newRule: boolean;
+    fields: FormField[];
+    conditions: UicConditionDefinition[];
+    selectedConditionReference: string | null;
+    searchTerm: string;
+    currentPage: number;
+    readonly pageSize = 5;
+    customNamesEnabled: boolean;
+    private readonly translate;
+    private readonly ref;
+    private readonly languageSubscription;
+    mainConditionFieldsData: ConditionField[];
+    constructor(data: {
+        conditions: UicConditionDefinition[];
+        customNamesEnabled: boolean;
+        conditionOperators: AppSelectOption[];
+        conditionFields: ConditionField[];
+        selectedConditionReference?: string | number | null;
+    });
+    ngOnDestroy(): void;
+    trackingField: string;
+    initialValues: {};
+    updateFormNewRule(fr: uicFormValuesRecord): void;
+    get filteredConditions(): UicConditionDefinition[];
+    get paginatedConditions(): UicConditionDefinition[];
+    get totalPages(): number;
+    get canGoToPreviousPage(): boolean;
+    get canGoToNextPage(): boolean;
+    onSearchTermChange(): void;
+    goToPreviousPage(): void;
+    goToNextPage(): void;
+    createAndSelectRule(fr: FormResult): void;
+    select(condition: UicConditionDefinition): void;
+    isSelected(condition: UicConditionDefinition): boolean;
+    highlightSearch(value: string | null | undefined): string;
+    private buildFields;
+    private normalizeText;
+    private escapeHtml;
+    private getConditionReference;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleDefinirionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RuleDefinirionComponent, "lib-rule-definirion", never, {}, {}, never, never, true, never>;
+}

package/lib/components/short-table/short-table.component.d.ts

@@ -0,0 +1,15 @@
+import { TableColums, TableRow } from '../table/table.models';
+import { UicPortletData } from '../uic-portlet-card/uic-portlet-card.component';
+import * as i0 from "@angular/core";
+export declare class UicShortTableComponent {
+    columns: TableColums[];
+    data: TableRow;
+    loading: boolean;
+    disabled: boolean;
+    cols: number;
+    portlet: UicPortletData[];
+    ngOnInit(): void;
+    apTableToPortlets(columns: TableColums[], row: TableRow): UicPortletData[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicShortTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicShortTableComponent, "ui-short-table", never, { "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/signature-pad/signature-pad.component.d.ts

@@ -0,0 +1,36 @@
+import { AfterViewInit, ElementRef, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+declare const base: abstract new () => {
+    value: Blob | null;
+    valueChange: EventEmitter<Blob | null>;
+    onChange: (value: Blob | null) => void;
+    onTouched: () => void;
+    writeValue(obj: Blob | null): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    notifyChange(value: Blob | null): void;
+};
+export declare class UicSignaturePadComponent extends base implements AfterViewInit {
+    width: number;
+    height: number;
+    strokeColor: string;
+    strokeWidth: number;
+    disabled: boolean;
+    imageChange: EventEmitter<Blob | null>;
+    canvasRef: ElementRef<HTMLCanvasElement>;
+    private ctx;
+    private drawing;
+    ngAfterViewInit(): void;
+    startDraw(event: PointerEvent): void;
+    draw(event: PointerEvent): void;
+    endDraw(event: PointerEvent): void;
+    clear(): void;
+    private emitSignature;
+    private relativePosition;
+    writeValue(value: Blob | null): void;
+    private resetCanvas;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicSignaturePadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicSignaturePadComponent, "ui-signature-pad", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "imageChange": "imageChange"; }, never, never, true, never>;
+}
+export {};

package/lib/components/skeleton-cards/skeleton-cards.component.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+export declare class UicSkeletonCardsComponent {
+    cards: number;
+    gap: number;
+    minCardWidthPx: number;
+    get gridStyle(): {
+        'grid-template-columns': string;
+        gap: string;
+    };
+    get cardsCount(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicSkeletonCardsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicSkeletonCardsComponent, "ui-skeleton-cards", never, { "cards": { "alias": "cards"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "minCardWidthPx": { "alias": "minCardWidthPx"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/skeleton-loader/skeleton-loader.component.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class UicSkeletonLoaderComponent {
+    inputs: number;
+    cols: number;
+    get gridStyle(): {
+        'grid-template-columns': string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicSkeletonLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicSkeletonLoaderComponent, "ui-skeleton-loader", never, { "inputs": { "alias": "inputs"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/status-label/status-label.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class UicStatusLabelComponent {
+    color: string;
+    type: 'status' | 'tag';
+    icon: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicStatusLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicStatusLabelComponent, "ui-status-label", never, { "color": { "alias": "color"; "required": false; }; "type": { "alias": "type"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/lib/components/table/table-list/table-list.component.d.ts

@@ -0,0 +1,7 @@
+import { TableList } from '../table.models';
+import * as i0 from "@angular/core";
+export declare class UicTableListComponent {
+    list: TableList[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTableListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicTableListComponent, "uic-table-list", never, { "list": { "alias": "list"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/table/table-pagination/table-pagination.component.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class UicTablePaginationComponent {
+    buttonSize: 's' | 'm' | 'l';
+    currentPage: number;
+    totalPages: number;
+    size: number;
+    loading: boolean;
+    showText: boolean;
+    nextButtonText: string;
+    previousButtonText: string;
+    visiblePages: number;
+    pagesInView: number[];
+    pageChange: EventEmitter<number>;
+    sizeChange: EventEmitter<number>;
+    get pages(): (number | string)[];
+    changePage(newPage: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTablePaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicTablePaginationComponent, "uic-table-pagination", never, { "buttonSize": { "alias": "buttonSize"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "totalPages": { "alias": "totalPages"; "required": false; }; "size": { "alias": "size"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "showText": { "alias": "showText"; "required": false; }; "nextButtonText": { "alias": "nextButtonText"; "required": false; }; "previousButtonText": { "alias": "previousButtonText"; "required": false; }; }, { "pageChange": "pageChange"; "sizeChange": "sizeChange"; }, never, never, true, never>;
+}

package/lib/components/table/table-searcher/table-searcher.component.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class UicTableUicSearcherComponent {
+    placeholder: string;
+    label: string;
+    searchOnKeydown: boolean;
+    showButtonText: boolean;
+    showSearchButton: boolean;
+    filter: EventEmitter<string>;
+    text: string;
+    reset(): void;
+    updateText(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTableUicSearcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicTableUicSearcherComponent, "uic-table-searcher", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "searchOnKeydown": { "alias": "searchOnKeydown"; "required": false; }; "showButtonText": { "alias": "showButtonText"; "required": false; }; "showSearchButton": { "alias": "showSearchButton"; "required": false; }; }, { "filter": "filter"; }, never, never, true, never>;
+}

package/lib/components/table/table-user/table-user.component.d.ts

@@ -0,0 +1,7 @@
+import { TableUser } from '../table.models';
+import * as i0 from "@angular/core";
+export declare class UicTableUserComponent {
+    user: TableUser | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTableUserComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicTableUserComponent, "uic-table-user", never, { "user": { "alias": "user"; "required": false; }; }, {}, never, never, true, never>;
+}