bc-primeng-ui 0.0.1

package/index.d.ts

@@ -0,0 +1,1264 @@
+import { TableFilterButtonPropsOptions, Table, TableRowExpandEvent, TableLazyLoadEvent } from 'primeng/table';
+import { SelectItem, MessageService, Confirmation, SortMeta } from 'primeng/api';
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, Injector, AfterViewInit, DestroyRef, Type, WritableSignal, Signal, TemplateRef, OnChanges, InputSignal, SimpleChanges, PipeTransform, OutputEmitterRef } from '@angular/core';
+import { ControlValueAccessor, ControlContainer, AbstractControl, FormControl, FormGroup, FormArray, FormBuilder } from '@angular/forms';
+import { Router } from '@angular/router';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { HttpClient, HttpParams, HttpInterceptorFn } from '@angular/common/http';
+import { TranslocoService, TranslocoLoader, Translation } from '@jsverse/transloco';
+import { DialogService, DynamicDialogRef, DynamicDialogConfig } from 'primeng/dynamicdialog';
+
+declare abstract class BCBaseModel {
+    id: number;
+    active?: boolean;
+    /**
+     * Converts a date string (ex: "YYYY-MM-DD") coming from a DateOnly from the API
+     * to a Date object, safely, avoiding timezone problems.
+     */
+    protected fromApiDateOnly(dateOnlyString: string | Date | null | undefined): Date | null;
+    /**
+     * Very simple constructor: just assigns any key from `init` to this.
+     * If the JSON comes with dateUpdate as a string and you want to convert it to Date,
+     * you can handle it manually where needed. Here we just throw everything into the object.
+     */
+    constructor(init?: Partial<BCBaseModel>);
+    /**
+     If you still want to have an encapsulated fromJson, you can use this method.
+     * But, if you prefer, just always do `new FooModel(obj)`.
+     */
+    static fromJson<T extends BCBaseModel>(this: new (init?: Partial<T>) => T, json: Partial<T>): T;
+    /**
+     * Transforms the instance into a "plain" object (for example, to send back
+     * to the server). Here we just return a simple clone, without date conversion.
+     */
+    toJson(): any;
+}
+
+interface ISelectItem {
+    id: any;
+    label: string;
+    groupBy?: string | null;
+    disabled?: boolean;
+}
+
+interface ApiResponse<T> {
+    success: boolean;
+    statusCode: number;
+    data: T;
+    messages: string[];
+    dateTimeUtc: string;
+}
+
+/**
+ * Represents the display options for a column filter in a table or grid layout.
+ *
+ * The `ColumnFilterDisplay` type allows specifying how a column filter will be displayed.
+ * It provides two options:
+ * - `'row'`: The filter will be displayed inline as part of the row.
+ * - `'menu'`: The filter will be displayed within a menu.
+ */
+type ColumnFilterDisplay = 'row' | 'menu';
+/**
+ * Represents the type of a column filter in a data table or similar structure.
+ * Allows specifying different types of filters for columns, enabling appropriate
+ * filtering based on the data type of the column.
+ *
+ * - 'text': Defines a filter where data can be filtered based on plain string matching.
+ * - 'numeric': Specifies a filter for numeric values.
+ * - 'decimal': Represents a filter for decimal or floating-point numbers.
+ * - 'date': Used for filtering date values.
+ * - 'boolean': Allows filtering data based on boolean values (true/false).
+ * - 'select': Indicates a dropdown or selectable options-type filter.
+ * - string: Extends support for custom filter types as a string.
+ *
+ * This type is useful for configuring and managing dynamic filtering mechanisms
+ * in UI components or APIs.
+ */
+type ColumnFilterType = 'text' | 'numeric' | 'decimal' | 'date' | 'boolean' | 'select' | string;
+/**
+ * Represents a type definition for input filtering strategies.
+ *
+ * The `FilterOn` type is used to determine when a filter should be applied
+ * based on user interaction. It provides the following predefined options:
+ * - 'enter': Indicates that the filter should be applied when the user presses Enter.
+ * - 'input': Indicates that the filter should be applied dynamically as the user types.
+ */
+type FilterOn = 'enter' | 'input';
+interface ColumnFilter {
+    /** Defines the aria-label of the form element. */
+    ariaLabel?: string | null;
+    /** Enables currency input (ex.: 'BRL'). */
+    currency?: string | null;
+    /** Defines the display of the currency input. */
+    currencyDisplay?: string | null;
+    /**
+     * An object that represents customizable options for a specific feature or functionality.
+     * This variable can store various configuration settings or user-defined values.
+     * The structure and type of the content are flexible and depend on the implementation context.
+     */
+    customOptions?: any;
+    /** Filter display. */
+    display?: ColumnFilterDisplay;
+    /** Property represented by the column. */
+    field?: string;
+    /**
+     * Used to pass all filter button property object
+     * @default
+     * {
+     *   filter: { severity: 'secondary', text: true, rounded: true },
+     *   inline: { clear: { severity: 'secondary', text: true, rounded: true } },
+     *   popover: {
+     *     addRule: { severity: 'info', text: true, size: 'small' },
+     *     removeRule: { severity: 'danger', text: true, size: 'small' },
+     *     apply: { size: 'small' },
+     *     clear: { outlined: true, size: 'small' }
+     *   }
+     * }
+     */
+    filterButtonProps?: TableFilterButtonPropsOptions;
+    /**
+     * Default trigger to run filtering on built-in text and numeric filters.
+     * Valid values: 'enter' | 'input'
+     */
+    filterOn?: FilterOn;
+    /** Decides whether to close the popup on clear button click. */
+    hideOnClear?: boolean;
+    /** Defines filter locale (ex.: 'pt-BR'). */
+    locale?: string | null;
+    /** Defines filter locale matcher. */
+    localeMatcher?: string | null;
+    /** Filter match mode. */
+    matchMode?: string | null;
+    /** Filter match mode options. */
+    matchModeOptions?: SelectItem<any>[] | null;
+    /** Defines maximum number of constraints. */
+    maxConstraints?: number;
+    /** Defines a maximum fraction of digits. */
+    maxFractionDigits?: number | null;
+    /** Defines a minimum fraction of digits. */
+    minFractionDigits?: number | null;
+    /** Filter operator. */
+    operator?: string;
+    /** Filter placeholder. */
+    placeholder?: string;
+    /** Defines prefix of the filter (ex.: "R$"). */
+    prefix?: string;
+    /** Decides whether to display add filter button when display is a menu. */
+    showAddButton?: boolean;
+    /** Decides whether to display the applied filter button when display is a menu. */
+    showApplyButton?: boolean;
+    /** Defines the visibility of buttons. */
+    showButtons?: boolean;
+    /** Decides whether to display the clear filter button when display is a menu. */
+    showClearButton?: boolean;
+    /** Decides whether to display filter match modes when display is a menu. */
+    showMatchModes?: boolean;
+    /** Decides whether to display the filter menu popup. */
+    showMenu?: boolean;
+    /** Decides whether to display a filter operator. */
+    showOperator?: boolean;
+    /** Defines suffix of the filter (ex.: "%"). */
+    suffix?: string;
+    /**
+     * Defines the type of filter applied to a column.
+     * The value must be of a type compatible with the `ColumnFilterType` interface or type definition.
+     * This property determines the specific filtering mechanism or logic used for the column.
+     */
+    type?: ColumnFilterType;
+    /** Defines if grouping is enabled in numeric/currency inputs. */
+    useGrouping?: boolean;
+    /** Defines minimum value for  inputs. */
+    minValue?: any;
+    /** Defines minimum value for  inputs. */
+    maxValue?: any;
+}
+/**
+ * Defines the configuration for a column in the generic table.
+ * @template T The data object type of the row.
+ */
+interface BCColumnHeader<T> {
+    /** The name of the property in the data object to be displayed. */
+    field: keyof T | (string & {});
+    /** The translation key for the column header title. */
+    header: string;
+    /**
+     * Additional parameters for the header translation, if needed.
+     */
+    headerParams?: {};
+    hasTranslate?: boolean;
+    /**
+     * Defines how the cell content should be rendered.
+     * - 'text' (default): Just text.
+     * - 'badge': Renders as a <p-badge> component.
+     * - 'image': Renders an avatar with an image and a name next to it.
+     */
+    displayAs?: 'text' | 'number' | 'currency' | 'date' | 'yesNo' | 'badge' | 'image';
+    /**
+     * Used when displayAs is 'image'. Specifies which field of the data object
+     * contains the name/text to be displayed next to the avatar.
+     */
+    nameField?: keyof T | (string & {});
+    /**
+     * Used when displayAs is 'badge'. Maps the cell values to the
+     * "severities" (colors) of the PrimeNG Badge.
+     * Example: { 'Complete': 'success', 'Pending': 'warning' }
+     */
+    badgeSeverityMap?: {
+        [key: string]: string;
+    };
+    /** An Angular pipe to be applied to the value (e.g., 'currency', 'date'). */
+    pipe?: string;
+    /** Arguments for the pipe (e.g., date or currency format). */
+    pipeArgs?: any;
+    /** A custom formatting function. Has priority over pipes. */
+    formatter?: (value: any, item?: T) => string;
+    /** For the 'lookup' pipe, specifies the type of lookup to be used. */
+    lookupType?: string;
+    /** Used by formatters/pipes to know the type of the enum. */
+    enumType?: string;
+    /** If the column can be hidden by the column selector. */
+    optional?: boolean;
+    /** If the optional column should be selected by default. */
+    defaultSelected?: boolean;
+    /** Inline CSS styles for the column (e.g., 'min-width: 150px;'). */
+    style?: string;
+    /** The order of display for the column. */
+    order?: number;
+    /** If the column should have a filter in the header. */
+    filter?: ColumnFilter;
+    /** If the column can be sorted. */
+    sortable?: boolean;
+}
+
+declare class CustomDatepickerComponent implements ControlValueAccessor, OnInit {
+    private controlContainer;
+    private injector;
+    formControlName: string;
+    control: any;
+    placeholder?: string;
+    label: string;
+    secondLabel?: string;
+    required: boolean;
+    isDisabled: boolean;
+    dateFormat: string;
+    showTime: boolean;
+    hourFormat: '12' | '24';
+    dataType: 'date' | 'string' | 'number';
+    blur: EventEmitter<any>;
+    dateSelect: EventEmitter<Date>;
+    valueChange: EventEmitter<any>;
+    private onChange;
+    private onTouched;
+    constructor(controlContainer: ControlContainer, injector: Injector);
+    private ngControlInstance;
+    ngOnInit(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInputBlur(): void;
+    onSelect(event: Date): void;
+    onInput(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomDatepickerComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CustomDatepickerComponent, "app-custom-datepicker", never, { "formControlName": { "alias": "formControlName"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "secondLabel": { "alias": "secondLabel"; "required": false; }; "required": { "alias": "required"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "hourFormat": { "alias": "hourFormat"; "required": false; }; "dataType": { "alias": "dataType"; "required": false; }; }, { "blur": "blur"; "dateSelect": "dateSelect"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class FormFieldErrorComponent {
+    /** The control that has errors (it could be FormControl, FormGroup, FormArray…) */
+    control: AbstractControl | null;
+    /** "Readable" field name to display in the message (e.g., "CNPJ", "Email", etc.) */
+    fieldName: string;
+    /** "Extra class" to add to the <small> element */
+    style: string;
+    /** Parameter value (e.g., requiredLength, min, max) for the message */
+    _validatorValue?: string | number | {};
+    /**
+     *  Returns the exact translation key (e.g., "core.validation.required")
+     *  or `null` if there is no error to display.
+     */
+    get errorKey(): string | null;
+    get validatorValue(): any;
+    /** Preenche `_validatorValue` de acordo com o tipo de erro */
+    private extractValidatorValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldErrorComponent, "bc-form-field-error", never, { "control": { "alias": "control"; "required": false; }; "fieldName": { "alias": "fieldName"; "required": false; }; "style": { "alias": "style"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class Country extends BCBaseModel {
+    name: string;
+    aossId?: string;
+    code?: string;
+    isoCode?: string;
+    cultureCode?: string;
+    flag?: string;
+    constructor(init?: Partial<Country>);
+}
+
+declare class CountryCustom extends BCBaseModel {
+    locale: string;
+    utc: number;
+    hasProvince: boolean;
+    currencyCode: string;
+    currencyDigitsInfo: string;
+    dateFormat: string;
+    dateTimeFormat: string;
+    zipCodeFormat: string;
+    zipCodeRegExpFormat: string;
+    zipCodeReplaceValue: string;
+    documentFormat: string;
+    documentRegExpFormat: string;
+    documentReplaceValue: string;
+    personDocumentFormat: string;
+    personDocumentRegExpFormat: string;
+    personDocumentReplaceValue: string;
+    zipCodeRequired: boolean;
+    addressNumberRequired: boolean;
+    country?: Country;
+    constructor(init?: Partial<CountryCustom>);
+}
+
+declare class Session extends BCBaseModel {
+    acceptedTerms: boolean;
+    entityId?: string;
+    countryId?: string;
+    userLoggedIn: boolean;
+    countryCustom?: CountryCustom;
+    environment?: string;
+    constructor(init?: Partial<Session>);
+}
+
+declare class CryptoService {
+    private readonly iterations;
+    private readonly hash;
+    private readonly salt;
+    /** Gera uma CryptoKey AES-GCM a partir da senha (sessionSecret). */
+    private getKey;
+    /** Encripta um texto com AES-GCM. Retorna Base64(nonce + ciphertext). */
+    encrypt(plain: string, password: string): Promise<string>;
+    /** Decripta Base64(nonce + ciphertext) e retorna o texto puro. */
+    decrypt(base64: string, password: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CryptoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CryptoService>;
+}
+
+declare class StorageService {
+    private crypto;
+    private sessionSecret;
+    constructor(crypto: CryptoService);
+    setLocalStorage(key: string, value: any): Promise<void>;
+    getLocalStorage<T = any>(key: string): Promise<T | undefined>;
+    removeLocalStorage(key: string): void;
+    setSessionStorage(key: string, value: any): Promise<void>;
+    getSessionStorage<T = any>(key: string): Promise<T | undefined>;
+    removeSessionStorage(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
+}
+
+declare class SessionService {
+    private http;
+    private storageService;
+    private readonly sessionKey;
+    private sessionSubject;
+    session$: Observable<Session | null>;
+    constructor(http: HttpClient, storageService: StorageService);
+    /** Initializes the BehaviorSubject with the locally saved session. */
+    private initializeSession;
+    /**
+     * store encripted session without sessionStorage and update the BehaviorSubject.
+     */
+    saveSession(session: Session | null | undefined): Promise<void>;
+    getSession(): Promise<Session | undefined>;
+    /** reactive version with observable*/
+    getSession$(): Observable<Session | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionService>;
+}
+
+declare class SessionStoreService {
+    private sessionService;
+    private _session$;
+    session$: rxjs.Observable<Session | null>;
+    constructor(sessionService: SessionService);
+    private loadFromStorage;
+    /** Search in backend and stores in brwoser Storage*/
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionStoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionStoreService>;
+}
+
+declare class NotificationService {
+    private messageService;
+    constructor(messageService: MessageService);
+    success(detail: string, summary?: string): void;
+    error(detail: string, summary?: string): void;
+    info(detail: string, summary?: string): void;
+    warn(detail: string, summary?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+declare abstract class BCBaseComponent {
+    pageTitle: string;
+    session: Session | null;
+    disableControl: boolean;
+    writeAccess: boolean;
+    deleteAccess: boolean;
+    protected router: Router;
+    protected sessionStoreService: SessionStoreService;
+    protected notificationService: NotificationService;
+    ngOnInit(): void;
+    /** Toast notifications with PrimeNG MessageService */
+    protected showSuccess(msg: string): void;
+    protected showError(msg: string): void;
+    protected showInfo(msg: string): void;
+    protected showWarn(msg: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCBaseComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BCBaseComponent, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class AppConfirmationService {
+    private primeConfirmation;
+    private transloco;
+    /**
+     * MUDANÇA: Um novo método genérico para qualquer tipo de confirmação.
+     * Usa padrões neutros que podem ser sobrescritos.
+     */
+    confirm(config: Partial<Confirmation>): Promise<boolean>;
+    /**
+     * MUDANÇA: O método de exclusão agora simplesmente chama o método genérico
+     * com suas próprias configurações padrão para exclusão.
+     */
+    confirmDelete(config?: Partial<Confirmation> & {
+        data?: any;
+    }): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppConfirmationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppConfirmationService>;
+}
+
+declare class SearchStateService {
+    private readonly STORAGE_KEY_PREFIX;
+    private searchSubjects;
+    constructor();
+    /**
+     * Sets the search parameters for a specific key.
+     * @param key The unique key for this search (e.g., 'products', 'users').
+     * @param params The search parameters.
+     */
+    setSearchParams(key: string, params: any): void;
+    /**
+     * Returns an Observable of the search parameters for a specific key.
+     * @param key The unique key for this search.
+     * @returns An Observable of the search parameters.
+     */
+    getSearchParams(key: string): Observable<any>;
+    /**
+     * Clears the search parameters for a specific key.
+     * @param key The unique key for this search.
+     */
+    clearSearchParams(key: string): void;
+    private saveToStorage;
+    private loadFromStorage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchStateService>;
+}
+
+interface SearchFieldConfig {
+    key: string;
+    label?: string;
+    type: 'text' | 'number' | 'date' | 'dropdown' | 'multiselect' | 'boolean';
+    placeholder?: string;
+    options?: {
+        label: string;
+        value: any;
+    }[];
+    filterBy?: string;
+    optionLabel?: string;
+    optionValue?: string;
+    showClear?: boolean;
+    disabled?: boolean | ((params: any) => boolean);
+    dateFormat?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    size?: 'small' | 'medium' | 'large' | 'full' | 'auto' | string;
+}
+
+declare class BCFormItemBase {
+    value?: any;
+    key: string;
+    currentId: string;
+    label: string;
+    placeholder: string;
+    required: boolean;
+    order: number;
+    controlType: string;
+    type: string;
+    options: ISelectItem[];
+    buildInForm: boolean;
+    constructor(options?: {
+        value?: any;
+        key?: string;
+        currentId?: string;
+        label?: string;
+        placeholder?: string;
+        required?: boolean;
+        order?: number;
+        controlType?: string;
+        type?: string;
+        options?: ISelectItem[];
+        buildInForm?: boolean;
+    });
+}
+
+declare class Search extends BCBaseModel {
+    page?: number;
+    size?: number;
+    filter?: string;
+    url?: string;
+    isCollapsed: boolean;
+    mediaType?: 'PDF' | 'EXCEL';
+    groupByRegion?: boolean;
+    usedFilterReport: string;
+    activeTab: number;
+    activeSecoundTab: number;
+    activeThirdTab: number;
+    activeTerrainTab: number;
+    filterValue: string;
+    pageIndex: number;
+    pageSize: number;
+    matSortActive: string;
+    matSortDirection: any;
+    userSearchId?: string;
+    userSearchName?: string;
+    accessGroupId?: string;
+    accessGroupName?: string;
+    userName?: string;
+    deactivatedItems?: boolean;
+    description?: string;
+    dateStart?: Date;
+    dateStart2?: Date;
+    dateEnd?: Date;
+    dateEnd2?: Date;
+    companyId?: string;
+    companyName?: string;
+    ieId?: string;
+    imId?: string;
+    pjId?: string;
+    cadastralSituation?: number;
+    cadastralSituationName?: string;
+    cnae?: string;
+    cnaeId?: number;
+    searchEntityId?: string;
+    entityId?: string;
+    divisionId?: string;
+    unionId?: string;
+    associationId?: string;
+    departamentId?: string;
+    legalEntityId?: string;
+    mainLegalEntityId?: string;
+    entityTypeId?: string;
+    entityTypeName?: string;
+    entityStatus?: number;
+    fileTypeId?: string;
+    identificationId?: string;
+    documentType?: number;
+    fileTypeName?: string;
+    notificationTypeId?: string;
+    notificationTypeName?: string;
+    propertyTypeId?: string;
+    propertyTypeName?: string;
+    possessionTitleId?: string;
+    possessionTitleName?: string;
+    nomenclatureName?: string;
+    cnoId?: string;
+    minArea?: number;
+    maxArea?: number;
+    projetoAprovado?: number;
+    constructionPermit?: number;
+    cno?: number;
+    avcb?: number;
+    habitese?: number;
+    businessLicense?: number;
+    occurrenceType?: number;
+    street?: string;
+    streetNumber?: string;
+    district?: string;
+    zipCode?: string;
+    city?: string;
+    cityId?: string;
+    state?: string;
+    stateId?: string;
+    country?: string;
+    countryId?: string;
+    isAdmin?: boolean;
+    isDivision?: boolean;
+    isUnion?: boolean;
+    archivedItems?: boolean;
+    userIds?: string[];
+    conservationCategory?: string;
+    propertyCategory?: number;
+    frequency?: number;
+    value?: string;
+    viewMode?: number;
+    open?: boolean;
+    conservationItemIds?: string[];
+    propertyId?: string;
+    typeOfProperty?: number;
+    constructor(init?: Partial<Search>);
+}
+
+declare class SearchService {
+    storageService: StorageService;
+    getSearch(url: string): Search;
+    setSearch(url: string, search: Search): void;
+    clearSearch(url: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
+}
+
+declare class BaseHttpService {
+    protected http: HttpClient;
+    protected envBaseUrl: string;
+    protected apiName: string;
+    constructor(http: HttpClient, envBaseUrl: string, apiName: string);
+    protected get baseUrl(): string;
+    protected buildHttpParams(params: any): HttpParams;
+}
+
+interface FilterDto {
+    field: string;
+    value: string;
+    matchMode: string;
+    operator: string;
+}
+
+interface OrderDto {
+    field: string;
+    order: number;
+}
+
+interface PaginationRequestDto {
+    globalFilter?: string;
+    pageNumber: number;
+    pageSize: number;
+    filters: FilterDto[];
+    orders: OrderDto[];
+}
+
+interface PaginationResponseDto<TDto = any> {
+    data: TDto[];
+    pageNumber: number;
+    pageSize: number;
+    totalCount: number;
+}
+
+declare abstract class BCBaseService<T> extends BaseHttpService {
+    protected http: HttpClient;
+    protected envBaseUrl: string;
+    protected apiName: string;
+    private modelType?;
+    constructor(http: HttpClient, envBaseUrl: string, apiName: string, modelType?: (new (init?: Partial<T>) => T) | undefined);
+    list(params: any): Observable<T[]>;
+    getFilteredPages(paginationRequest: PaginationRequestDto): Observable<PaginationResponseDto<T>>;
+    getAllForSelect(): Observable<ISelectItem[]>;
+    getByFilterForSelect(filter: string): Observable<ISelectItem[]>;
+    get(id: number): Observable<T>;
+    create(obj: T): Observable<T>;
+    update(obj: T, id: number): Observable<boolean>;
+    delete(id: number): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCBaseService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BCBaseService<any>>;
+}
+
+declare abstract class BCBaseDataComponent<T extends BCBaseModel, TService extends BCBaseService<T>> extends BCBaseComponent implements AfterViewInit {
+    private baseService;
+    search: Search | null;
+    protected dialogService: DialogService;
+    protected confirmationService: AppConfirmationService;
+    protected searchStateService: SearchStateService;
+    protected searchService: SearchService;
+    protected transloco: TranslocoService;
+    protected destroyRef: DestroyRef;
+    protected abstract storageKey?: string;
+    protected searchConfig: SearchFieldConfig[];
+    currentSearchParams: any;
+    items: T[];
+    constructor(baseService: TService);
+    /**
+     * if the search should be executed automatically on initialization. Default is true
+     */
+    protected loadDataOnInitialization: boolean;
+    protected abstract getFormDialogComponent(): Type<any>;
+    ngOnInit(): void;
+    /******************pagination ****************/
+    paginationResponse: WritableSignal<PaginationResponseDto<T> | null>;
+    private paginationRequest;
+    onLazyLoad(paginationRequest: PaginationRequestDto): void;
+    /******************************************/
+    load(): Promise<void>;
+    ngAfterViewInit(): void;
+    /**
+     * Hook for subclasses to perform asynchronous actions before the initial load.
+     * Can be asynchronous (return Promise<void>) or synchronous (return void).
+     */
+    protected beforeInitialLoad(): Promise<void> | void;
+    list(params: any): void;
+    /** Returns an Observable<T[]> with all items; implemented by the child class */
+    protected abstract loadData(params: any): Observable<T[]>;
+    handleSearch(params: any): void;
+    openDialog(object?: T): void;
+    private handleSave;
+    protected getRowClass: (row: T) => string;
+    protected getFormItems(object?: T): BCFormItemBase[];
+    protected onAdd(object: T): Observable<any>;
+    protected onEdit(object: T, id: number): Observable<any>;
+    protected getObjectName(object?: T): string | undefined;
+    onRemove(object: T): Promise<void>;
+    protected onDelete(id: number): Observable<void>;
+    openFormDialog(objectModel?: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCBaseDataComponent<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BCBaseDataComponent<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+type ControlValue<C> = C extends FormControl<infer V> ? V : C extends FormGroup<infer G> ? {
+    [K in keyof G]: ControlValue<G[K]>;
+} : C extends FormArray<infer A> ? ReadonlyArray<ControlValue<A>> : never;
+type SignalsFromForm<T> = {
+    [K in keyof T]: T[K] extends FormControl<infer V> ? Signal<V> : T[K] extends FormGroup<infer G> ? SignalsFromForm<G> : T[K] extends FormArray<infer A> ? Signal<ReadonlyArray<ControlValue<A>>> : never;
+};
+
+declare abstract class BCBaseFormDialogComponent<T> extends BCBaseComponent implements OnInit {
+    form: FormGroup;
+    formSignal: SignalsFromForm<any>;
+    protected injector: Injector;
+    protected formBuilder: FormBuilder;
+    protected ref: DynamicDialogRef<any>;
+    protected config: DynamicDialogConfig<any, any>;
+    protected translate: TranslocoService;
+    invalidControls: string[];
+    ngOnInit(): void;
+    /**
+     * called after form creation
+     * @param data contains data of DynamicDialogConfig.
+     */
+    protected abstract onInitDialog(data: T | null): void;
+    /**
+     * creates a FormGroup with its controls. Implemented by the child class.
+     * @returns formGroup
+     */
+    protected abstract newForm(): FormGroup;
+    /**
+     * builds the object of type T from the FormGroup values. Implemented by the child class.
+     * @returns object filled form.
+     */
+    protected abstract getFormValue(): T;
+    /**
+     * handles form submission.
+     */
+    onSubmit(): void;
+    /**
+     * closes the dialog without saving
+     */
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCBaseFormDialogComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BCBaseFormDialogComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class BCTextboxComponent implements ControlValueAccessor, OnInit {
+    private injector;
+    label: string;
+    placeholder?: string;
+    type: string;
+    /** can set manually, but is undefined, willbe detected in runtime */
+    required: boolean;
+    maxlength?: number;
+    value: string;
+    isDisabled: boolean;
+    inputId: string;
+    validatorValue?: string;
+    readonly: i0.InputSignal<boolean>;
+    fluid: i0.InputSignal<boolean>;
+    addOnBeforeTemplate: TemplateRef<any> | null;
+    addOnAfterTemplate: TemplateRef<any> | null;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    private ngControlInstance;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    get control(): AbstractControl | null;
+    get showError(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCTextboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BCTextboxComponent, "bc-textbox", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "type": { "alias": "type"; "required": false; }; "required": { "alias": "required"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; }, {}, ["addOnBeforeTemplate", "addOnAfterTemplate"], never, true, never>;
+}
+
+declare class BCCustomSelectComponent implements ControlValueAccessor, OnInit, OnChanges {
+    private injector;
+    valueChange: EventEmitter<any>;
+    /** text label (or translation key) */
+    label: string;
+    subLabel: InputSignal<string | undefined>;
+    /** list of options: { label: string, value: any } */
+    options: ISelectItem[];
+    /** Placeholder (if not informed, uses label) */
+    placeholder?: string;
+    /** can force manually */
+    required: boolean;
+    readonly showErrorInTooltip: InputSignal<boolean>;
+    /** internal value (selected value) */
+    value: any;
+    /** disabled status */
+    isDisabled: boolean;
+    /** input for  Input para carregar establishments ao selecionar company */
+    fetchEstablishmentsFromCompany: string | null | undefined;
+    /** Gera um ID único para associar label + select */
+    inputId: string;
+    /** Callbacks fornecidos pelo Angular Forms */
+    onChange: (v: any) => void;
+    onTouched: () => void;
+    /**
+     * Target element to attach the overlay, valid values are "body" or a local ng-template variable of another element.
+     * Note: use binding with brackets for template variables, e.g. [appendTo]="mydiv" for a div element having #mydiv as variable name.
+     */
+    appendTo: InputSignal<any>;
+    /**
+     * Represents an input signal that holds a boolean value.
+     * The signal is initialized with a default value of `false`.
+     * This signal can be used to track or manage the flow of a boolean-driven process.
+     *
+     * @type {InputSignal<boolean>}
+     */
+    fluid: InputSignal<boolean>;
+    /**
+     * Represents a read-only boolean input signal.
+     * The value cannot be modified directly and reflects the
+     * current state of the boolean signal.
+     *
+     * @type {InputSignal<boolean>}
+     */
+    readonly: InputSignal<boolean>;
+    /** references to NgControl, if there is a formControlName in the parent component */
+    private ngControlInstance;
+    addOnBeforeTemplate: TemplateRef<any> | null;
+    addOnAfterTemplate: TemplateRef<any> | null;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private loadEstablishments;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onSelectChange(event: any): void;
+    get control(): AbstractControl | null;
+    get showError(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCCustomSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BCCustomSelectComponent, "bc-select", never, { "label": { "alias": "label"; "required": false; }; "subLabel": { "alias": "subLabel"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "fetchEstablishmentsFromCompany": { "alias": "fetchEstablishmentsFromCompany"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, ["addOnBeforeTemplate", "addOnAfterTemplate"], never, true, never>;
+}
+
+declare class BCDatePickerComponent implements ControlValueAccessor {
+    label: string;
+    placeholder: string;
+    formControl: FormControl;
+    dateFormat: string;
+    showTime: boolean;
+    hourFormat: '12' | '24';
+    dataType: 'date' | 'string' | 'number';
+    blur: EventEmitter<any>;
+    dateSelect: EventEmitter<Date>;
+    valueChange: EventEmitter<any>;
+    inputId: string;
+    value: any;
+    disabled: boolean;
+    onChange: any;
+    onTouched: any;
+    required: boolean;
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    onDateChange(event: any): void;
+    onInputBlur(): void;
+    onSelect(event: Date): void;
+    onInput(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCDatePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BCDatePickerComponent, "bc-datePicker", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "formControl": { "alias": "formControl"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "hourFormat": { "alias": "hourFormat"; "required": false; }; "dataType": { "alias": "dataType"; "required": false; }; }, { "blur": "blur"; "dateSelect": "dateSelect"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class CurrencyFormatPipe implements PipeTransform {
+    private globalLocaleId;
+    constructor(globalLocaleId: string);
+    transform(value: number | string | null | undefined, countryCustom?: CountryCustom, defaultCurrencyCode?: string, defaultDigitsInfo?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CurrencyFormatPipe, "currencyFormat", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CurrencyFormatPipe>;
+}
+
+declare class DateFormatPipe implements PipeTransform {
+    private globalLocaleId;
+    constructor(globalLocaleId: string);
+    transform(value?: Date | string | number, countryCustom?: CountryCustom, defaultFormat?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateFormatPipe, "dateFormat", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateFormatPipe>;
+}
+
+declare class DateTimeFormatPipe implements PipeTransform {
+    private globalLocaleId;
+    constructor(globalLocaleId: string);
+    transform(value?: Date | string | number, countryCustom?: CountryCustom, defaultFormat?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateTimeFormatPipe, "dateTimeFormat", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateTimeFormatPipe>;
+}
+
+declare class DocumentFormatPipe implements PipeTransform {
+    transform(value: string | number, countryCustom?: CountryCustom): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DocumentFormatPipe, "documentFormat", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentFormatPipe>;
+}
+
+declare class EnumLabelPipe implements PipeTransform {
+    private translate;
+    constructor(translate: TranslocoService);
+    transform(value: number, enumType: string | any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumLabelPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumLabelPipe, "enumLabel", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EnumLabelPipe>;
+}
+
+declare class LookupPipe implements PipeTransform {
+    private lookupService;
+    transform(value: number | undefined | null, lookupType: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LookupPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LookupPipe, "lookup", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LookupPipe>;
+}
+
+declare class PersonDocumentFormatPipe implements PipeTransform {
+    transform(value: string | number, countryCustom?: CountryCustom, hideSomeValues?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PersonDocumentFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PersonDocumentFormatPipe, "personDocumentFormat", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PersonDocumentFormatPipe>;
+}
+
+declare class StatusPipe implements PipeTransform {
+    private translate;
+    constructor(translate: TranslocoService);
+    transform(value: any, args?: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<StatusPipe, "status", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StatusPipe>;
+}
+
+declare class YesNoPipe implements PipeTransform {
+    private translate;
+    constructor(translate: TranslocoService);
+    transform(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<YesNoPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<YesNoPipe, "yesNo", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<YesNoPipe>;
+}
+
+declare class ZipCodeFormatPipe implements PipeTransform {
+    transform(value: string | number, countryCustom?: CountryCustom): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZipCodeFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ZipCodeFormatPipe, "zipCodeFormat", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ZipCodeFormatPipe>;
+}
+
+declare class TableFormattingService {
+    private translate;
+    private yesNoPipe;
+    private zipCodePipe;
+    private currencyFormatPipe;
+    private dateFormatPipe;
+    private dateTimeFormatPipe;
+    private documentPipe;
+    private personDocumentPipe;
+    private statusPipe;
+    private enumLabelPipe;
+    private lookupPipe;
+    constructor(translate: TranslocoService, yesNoPipe: YesNoPipe, zipCodePipe: ZipCodeFormatPipe, currencyFormatPipe: CurrencyFormatPipe, dateFormatPipe: DateFormatPipe, dateTimeFormatPipe: DateTimeFormatPipe, documentPipe: DocumentFormatPipe, personDocumentPipe: PersonDocumentFormatPipe, statusPipe: StatusPipe, enumLabelPipe: EnumLabelPipe, lookupPipe: LookupPipe);
+    formatCell<T extends BCBaseModel>(item: T, column: BCColumnHeader<T>, countryCustom?: CountryCustom): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFormattingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableFormattingService>;
+}
+
+declare class BCGenericPTableComponent<T extends BCBaseModel> implements OnInit, OnChanges {
+    private notificationService;
+    private formattingService;
+    private _tableData;
+    set tableData(value: T[]);
+    get tableData(): T[];
+    customActionsTemplate: TemplateRef<any> | undefined;
+    dt: Table | undefined;
+    totalRecords: number;
+    rows: number;
+    serverSidePagination: boolean;
+    columnDefinition: BCColumnHeader<T>[];
+    optionsColumns: BCColumnHeader<T>[];
+    tableName?: string | undefined;
+    titleBtnCreate: string;
+    hasBtnCreate: boolean;
+    displayCreateAction: boolean;
+    hasExpandedRows: InputSignal<boolean>;
+    expandedRowKey: InputSignal<string | 'index'>;
+    expandedRows: InputSignal<{
+        [p: string]: boolean;
+    }>;
+    expandedRowTemplate: TemplateRef<any> | null;
+    visibleColumns: BCColumnHeader<T>[];
+    optionalColumnOptions: BCColumnHeader<T>[];
+    selectedColumns: BCColumnHeader<T>[];
+    stripedRows: boolean;
+    /**
+     * Receipt function for applicate css classes dinamycalle to a line.
+     * The function receives the data of the line and should return a string with the classes.
+     */
+    rowStyleClass?: (rowData: T) => string;
+    /**
+     * Properties for selection
+     */
+    /** Enable the display of the selection column (checkboxes). */
+    enableSelection: boolean;
+    /** Receipt function to determine if a line can be selected. */
+    isRowSelectable?: (event: {
+        data: T;
+    }) => boolean;
+    /** 1. Receipt the selection from the parent component. */
+    selection: T[];
+    /** 2. Emit the changes back to the parent. The 'Change' suffix is crucial. */
+    selectionChange: EventEmitter<T[]>;
+    /**
+     * Internal method to propagate the change of the p-table to the parent component.
+     */
+    onInternalSelectionChange(currentSelection: T[]): void;
+    /**
+     * Can be boolean (all) or function (by line)
+     */
+    displayDetailAction: boolean | ((item: any) => boolean);
+    disableDetailCondition: InputSignal<((item: any) => boolean) | null>;
+    displayEditAction: boolean;
+    disableEditCondition: InputSignal<((item: any) => boolean) | null>;
+    displayEditCondition: InputSignal<((item: any) => boolean) | null>;
+    displayDeleteAction: boolean;
+    disableDeleteCondition: InputSignal<((item: any) => boolean) | null>;
+    displayDeleteCondition?: (item: any) => boolean;
+    countryCustom?: CountryCustom;
+    genericEvent: EventEmitter<T>;
+    detail: EventEmitter<T>;
+    add: EventEmitter<void>;
+    edit: EventEmitter<T>;
+    delete: EventEmitter<T>;
+    readonly changeColumns: EventEmitter<BCColumnHeader<T>[]>;
+    lazyLoad: OutputEmitterRef<PaginationRequestDto>;
+    onRowExpand: OutputEmitterRef<TableRowExpandEvent>;
+    onRowCollapse: OutputEmitterRef<TableRowExpandEvent>;
+    private sortState;
+    filteredTableData: T[];
+    filter: string;
+    rowsPerPageOptions: number[];
+    private imageFields;
+    private filterSubject;
+    private hasFormattingErrorOccurred;
+    private transloco;
+    constructor(notificationService: NotificationService, formattingService: TableFormattingService);
+    /**
+     * Verify if the "New" button should be disabled
+     *
+     * PROFILES:
+     * - Support: disable all (maximum priority)
+     * - Requery: enable New, Send for Analysis and Reopen
+     * - Approval: enable all
+     */
+    get isCreateButtonDisabled(): boolean;
+    get displayActionsColumn(): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private readonly maxSelectedLabels;
+    /**
+     * Prepare the lists of required, optional and visible columns.
+     */
+    private initializeColumns;
+    /**
+     * Getter that transforms the array of selected columns into a string for display,
+     * respecting the limit of 'maxSelectedLabels'.
+     */
+    get selectedColumnsLabel(): string;
+    onColumnSelectionChange(): void;
+    private updateVisibleColumns;
+    isImageField(field: string): boolean;
+    getImageSrc(field: string, rowData: any): string;
+    getFormattedValue(item: T, column: BCColumnHeader<T>): string;
+    getPrioritySeverity(priority: number | string): 'info' | 'success' | 'warn' | 'danger' | 'secondary' | 'contrast';
+    onLazyLoad(event: TableLazyLoadEvent): void;
+    onGlobalFilter(table: Table, event: any): void;
+    private filterGlobalWithFormatters;
+    onFilterChange(value: string): void;
+    changeColumnHeaders(cols: BCColumnHeader<T>[]): void;
+    onGenericEvent(object: T): void;
+    onDetail(object: T): void;
+    onAdd(): void;
+    onEdit(object: T): void;
+    onDelete(object: T): void;
+    trackByField(_index: number, col: BCColumnHeader<T>): (string & {}) | keyof T;
+    protected canShowEditButton(item: any): boolean | undefined;
+    canShowDeleteButton(item: any): boolean;
+    isDetailActionVisible(item: any): boolean;
+    /**
+     * NEW PUBLIC METHOD: Clears the selection and the table's saved state.
+     * This method can be called by the parent component.
+     */
+    clearSelectionAndState(): void;
+    customSort(multiSortMeta: SortMeta[]): void;
+    /**
+     * Sorts a list of objects based on multiple field and order criteria.
+     * @param {Array<object>} list - The list of objects to sort.
+     * @param {Array<{ field: string, order: 1 | -1 }>} sortRules - Fields and sort directions (1 = ASC, -1 = DESC).
+     * @returns {Array<object>} - A new sorted list.
+     */
+    private sortGenericList;
+    hasColumnsFilter(): boolean;
+    hasFiltersApplied(dt: Table): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCGenericPTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BCGenericPTableComponent<any>, "bc-generic-p-table", never, { "tableData": { "alias": "tableData"; "required": false; }; "totalRecords": { "alias": "totalRecords"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "serverSidePagination": { "alias": "serverSidePagination"; "required": false; }; "columnDefinition": { "alias": "columnDefinition"; "required": false; }; "optionsColumns": { "alias": "optionsColumns"; "required": false; }; "tableName": { "alias": "tableName"; "required": false; }; "titleBtnCreate": { "alias": "titleBtnCreate"; "required": false; }; "hasBtnCreate": { "alias": "hasBtnCreate"; "required": false; }; "displayCreateAction": { "alias": "displayCreateAction"; "required": false; }; "hasExpandedRows": { "alias": "hasExpandedRows"; "required": false; "isSignal": true; }; "expandedRowKey": { "alias": "expandedRowKey"; "required": false; "isSignal": true; }; "expandedRows": { "alias": "expandedRows"; "required": false; "isSignal": true; }; "stripedRows": { "alias": "stripedRows"; "required": false; }; "rowStyleClass": { "alias": "rowStyleClass"; "required": false; }; "enableSelection": { "alias": "enableSelection"; "required": false; }; "isRowSelectable": { "alias": "isRowSelectable"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "displayDetailAction": { "alias": "displayDetailAction"; "required": false; }; "disableDetailCondition": { "alias": "disableDetailCondition"; "required": false; "isSignal": true; }; "displayEditAction": { "alias": "displayEditAction"; "required": false; }; "disableEditCondition": { "alias": "disableEditCondition"; "required": false; "isSignal": true; }; "displayEditCondition": { "alias": "displayEditCondition"; "required": false; "isSignal": true; }; "displayDeleteAction": { "alias": "displayDeleteAction"; "required": false; }; "disableDeleteCondition": { "alias": "disableDeleteCondition"; "required": false; "isSignal": true; }; "displayDeleteCondition": { "alias": "displayDeleteCondition"; "required": false; }; }, { "selectionChange": "selectionChange"; "genericEvent": "genericEvent"; "detail": "detail"; "add": "add"; "edit": "edit"; "delete": "delete"; "changeColumns": "changeColumns"; "lazyLoad": "lazyLoad"; "onRowExpand": "onRowExpand"; "onRowCollapse": "onRowCollapse"; }, ["customActionsTemplate", "expandedRowTemplate"], ["*"], true, never>;
+}
+
+declare class BCAutoCompleteComponent implements ControlValueAccessor, OnInit {
+    private injector;
+    /** Label del campo */
+    label: string;
+    subLabel: InputSignal<string | undefined>;
+    /** Sugerencias que vienen del padre */
+    suggestions: any[];
+    /** Campo a mostrar del objeto */
+    field: string;
+    placeholder?: string;
+    minLength: number;
+    dropdown: boolean;
+    forceSelection: boolean;
+    required: boolean;
+    /** Evento para que el padre busque en el servicio */
+    completeMethod: EventEmitter<any>;
+    onSelect: EventEmitter<any>;
+    onClear: EventEmitter<any>;
+    value: any;
+    isDisabled: boolean;
+    inputId: string;
+    onChange: (v: any) => void;
+    onTouched: () => void;
+    private ngControlInstance;
+    addOnBeforeTemplate: TemplateRef<any> | null;
+    addOnAfterTemplate: TemplateRef<any> | null;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onSearch(event: any): void;
+    onItemSelect(event: any): void;
+    onBlur(): void;
+    get control(): AbstractControl | null;
+    get showError(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCAutoCompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BCAutoCompleteComponent, "bc-autocomplete", never, { "label": { "alias": "label"; "required": false; }; "subLabel": { "alias": "subLabel"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; }; "field": { "alias": "field"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "dropdown": { "alias": "dropdown"; "required": false; }; "forceSelection": { "alias": "forceSelection"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "completeMethod": "completeMethod"; "onSelect": "onSelect"; "onClear": "onClear"; }, ["addOnBeforeTemplate", "addOnAfterTemplate"], never, true, never>;
+}
+
+declare class BCConfirmDialogComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCConfirmDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BCConfirmDialogComponent, "bc-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class LoadingService {
+    private _loading$;
+    readonly loading$: rxjs.Observable<boolean>;
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingService>;
+}
+
+declare class BCLoadingComponent {
+    loadingService: LoadingService;
+    constructor(loadingService: LoadingService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCLoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BCLoadingComponent, "bc-loading", never, {}, {}, never, never, true, never>;
+}
+
+declare class BCCheckboxComponent implements ControlValueAccessor, OnInit {
+    private injector;
+    label: string;
+    required: boolean;
+    value: boolean;
+    isDisabled: boolean;
+    inputId: string;
+    private ngControlInstance;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    onCheckboxChange(event: any): void;
+    get control(): any;
+    get showError(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BCCheckboxComponent, "bc-checkbox", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BCCurrencyboxComponent implements ControlValueAccessor, OnInit {
+    private injector;
+    label: string;
+    placeholder?: string;
+    required: boolean;
+    mode: string;
+    currency: string;
+    locale: string;
+    value: number | null;
+    isDisabled: boolean;
+    inputId: string;
+    readonly: i0.InputSignal<boolean>;
+    fluid: i0.InputSignal<boolean>;
+    addOnBeforeTemplate: TemplateRef<any> | null;
+    addOnAfterTemplate: TemplateRef<any> | null;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    private ngControlInstance;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInputValueChange(val: number | null): void;
+    get control(): AbstractControl | null;
+    get showError(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BCCurrencyboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BCCurrencyboxComponent, "bc-currencybox", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "currency": { "alias": "currency"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; }, {}, ["addOnBeforeTemplate", "addOnAfterTemplate"], never, true, never>;
+}
+
+declare class TranslationHttpLoader implements TranslocoLoader {
+    private http;
+    getTranslation(lang: string): rxjs.Observable<Translation>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationHttpLoader, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationHttpLoader>;
+}
+
+declare const loadingInterceptor: HttpInterceptorFn;
+
+declare const errorInterceptor: HttpInterceptorFn;
+
+export { BCAutoCompleteComponent, BCBaseComponent, BCBaseDataComponent, BCBaseFormDialogComponent, BCBaseModel, BCBaseService, BCCheckboxComponent, BCConfirmDialogComponent, BCCurrencyboxComponent, BCCustomSelectComponent, BCDatePickerComponent, BCGenericPTableComponent, BCLoadingComponent, BCTextboxComponent, CustomDatepickerComponent, FormFieldErrorComponent, TranslationHttpLoader, errorInterceptor, loadingInterceptor };
+export type { ApiResponse, BCColumnHeader, ColumnFilter, ColumnFilterDisplay, ColumnFilterType, FilterOn, ISelectItem };