import * as i0 from '@angular/core';
import { OnDestroy, OnChanges, SimpleChanges, ElementRef, NgZone, TemplateRef, EventEmitter, AfterViewInit, ChangeDetectorRef, OnInit, InjectionToken, DoCheck, AfterContentInit, QueryList, IterableDiffers, Renderer2, ViewContainerRef, PipeTransform } from '@angular/core';
import { BreakpointObserver } from '@angular/cdk/layout';
import { BooleanInput } from '@angular/cdk/coercion';
import * as i2 from '@angular/forms';
import { ControlValueAccessor, FormControl, NgControl } from '@angular/forms';
import * as i9 from '@angular/material/form-field';
import { MatFormFieldAppearance } from '@angular/material/form-field';
import { ThemePalette } from '@angular/material/core';
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import { Router } from '@angular/router';
import * as i4 from '@angular/material/sidenav';
import { MatDrawerMode } from '@angular/material/sidenav';
import * as i22 from '@angular/material/dialog';
import { MatDialogRef, MatDialog, MatDialogConfig } from '@angular/material/dialog';
import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
import * as i7 from '@angular/material/snack-bar';
import { MatSnackBarRef, MatSnackBar } from '@angular/material/snack-bar';
import * as i19 from '@angular/material/datepicker';
import { MatDatepickerInputEvent, MatDatepicker } from '@angular/material/datepicker';
import { NgxMaterialTimepickerTheme, NgxMaterialTimepickerComponent } from 'ngx-material-timepicker';
import { SelectionModel } from '@angular/cdk/collections';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import * as i1 from '@angular/common';
import * as i3 from '@angular/material/toolbar';
import * as i5 from '@angular/material/list';
import * as i6 from '@angular/material/button';
import * as i8 from '@angular/material/card';
import * as i10 from '@angular/material/input';
import * as i11 from '@angular/material/select';
import * as i12 from '@angular/material/table';
import * as i13 from '@angular/material/paginator';
import * as i14 from '@angular/material/sort';
import * as i15 from '@angular/material/icon';
import * as i16 from '@angular/material/divider';
import * as i17 from '@angular/material/tooltip';
import * as i18 from '@angular/material/menu';
import * as i20 from '@angular/material/progress-bar';
import * as i21 from '@angular/material/slide-toggle';
import * as i23 from '@angular/material/radio';
import * as i24 from '@angular/material/checkbox';
import * as i25 from '@angular/material/progress-spinner';

declare class PtechGridDirective implements OnDestroy, OnChanges {
    private bp;
    private destroy$;
    private _cols;
    set ptechCols(v: number | string | null | undefined);
    ptechColsXs?: number | string;
    ptechColsSm?: number | string;
    ptechColsMd?: number | string;
    ptechColsLg?: number | string;
    ptechColsXl?: number | string;
    private _gapPx;
    set ptechGap(v: number | string | null | undefined);
    get gapCss(): string;
    static ngAcceptInputType_ptechVertical: BooleanInput;
    private _vertical;
    set ptechVertical(v: any);
    display: string;
    columns: string;
    private activeBp;
    private viewportBp;
    constructor(bp: BreakpointObserver);
    ngOnDestroy(): void;
    ngOnChanges(_: SimpleChanges): void;
    private pickActive;
    private updateCols;
    private resolveColsForBp;
    private asNum;
    static ɵfac: i0.ɵɵFactoryDeclaration<PtechGridDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PtechGridDirective, "[ptechGrid]", never, { "ptechCols": { "alias": "ptechCols"; "required": false; }; "ptechColsXs": { "alias": "ptechColsXs"; "required": false; }; "ptechColsSm": { "alias": "ptechColsSm"; "required": false; }; "ptechColsMd": { "alias": "ptechColsMd"; "required": false; }; "ptechColsLg": { "alias": "ptechColsLg"; "required": false; }; "ptechColsXl": { "alias": "ptechColsXl"; "required": false; }; "ptechGap": { "alias": "ptechGap"; "required": false; }; "ptechVertical": { "alias": "ptechVertical"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PtechColDirective implements OnDestroy, OnChanges {
    private el;
    private ngZone;
    private bp;
    private destroy$;
    private ro?;
    private roScheduled;
    private lastSpan;
    /** Controla de onde vêm os breakpoints (viewport ou container). */
    ptechColMode: 'viewport' | 'container' | 'auto';
    private _col;
    set ptechCol(v: number | string | null | undefined);
    ptechColXs?: number | string;
    ptechColSm?: number | string;
    ptechColMd?: number | string;
    ptechColLg?: number | string;
    ptechColXl?: number | string;
    private activeBp;
    private activeSource;
    gridColumn: string;
    minWidth: string;
    constructor(el: ElementRef<HTMLElement>, ngZone: NgZone, bp: BreakpointObserver);
    ngOnDestroy(): void;
    ngOnChanges(_: SimpleChanges): void;
    private findGridParent;
    private pickActive;
    private updateSpan;
    private resolveColForBp;
    private asNum;
    static ɵfac: i0.ɵɵFactoryDeclaration<PtechColDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PtechColDirective, "[ptechCol]", never, { "ptechColMode": { "alias": "ptechColMode"; "required": false; }; "ptechCol": { "alias": "ptechCol"; "required": false; }; "ptechColXs": { "alias": "ptechColXs"; "required": false; }; "ptechColSm": { "alias": "ptechColSm"; "required": false; }; "ptechColMd": { "alias": "ptechColMd"; "required": false; }; "ptechColLg": { "alias": "ptechColLg"; "required": false; }; "ptechColXl": { "alias": "ptechColXl"; "required": false; }; }, {}, never, never, true, never>;
}

declare abstract class BaseField {
    protected el: ElementRef<HTMLElement>;
    private ptechColDirective?;
    constructor(el: ElementRef<HTMLElement>, ptechColDirective?: PtechColDirective | undefined);
    static ngAcceptInputType_required: BooleanInput;
    static ngAcceptInputType_disabled: BooleanInput;
    static ngAcceptInputType_readonly: BooleanInput;
    static ngAcceptInputType_loading: BooleanInput;
    static ngAcceptInputType_fullWidth: BooleanInput;
    private _required;
    get required(): boolean;
    set required(v: any);
    private _disabled;
    get disabled(): boolean;
    set disabled(v: any);
    private _readonly;
    get readonly(): boolean;
    set readonly(v: any);
    private _loading;
    get loading(): boolean;
    set loading(v: any);
    private _fullWidth;
    get fullWidth(): boolean;
    set fullWidth(v: any);
    label: string;
    placeholder: string;
    name?: string;
    /** Acessibilidade */
    ariaLabel?: string;
    ariaLabelledby?: string;
    /** Aparência padrão para campos Material */
    appearance: MatFormFieldAppearance;
    private _col;
    set col(v: number | string | null | undefined);
    /** Se a diretiva [ptechCol*] estiver presente, ela domina o layout. */
    protected hasPtechColAttrs(): boolean;
    get gridColumn(): string | null;
    hostDisplay: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseField, [null, { optional: true; self: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseField, never, never, { "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "col": { "alias": "col"; "required": false; }; }, {}, never, never, true, never>;
}

declare class InputComponent extends BaseField implements ControlValueAccessor {
    constructor(el: ElementRef<HTMLElement>);
    _elementRef?: ElementRef<HTMLInputElement>;
    suffixRef?: TemplateRef<any>;
    buttonClick: EventEmitter<void>;
    maxlength: string | number;
    min: any;
    max: any;
    type: string;
    /** Ícone */
    icon: string;
    iconColor: string;
    iconWidth: string;
    iconHeight: string;
    iconSize: string;
    iconPosition: 'left' | 'right';
    forceFixedIcon: boolean;
    /** Tooltip */
    tooltip: string;
    /** Extras */
    autocomplete: string;
    inputmode?: string;
    pattern?: string;
    private _val;
    get value(): any;
    set value(val: any);
    onChange: any;
    onTouch: any;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onButtonClick(): void;
    isThemeColor(c: string | null | undefined, theme: 'primary' | 'accent' | 'warn'): boolean;
    get customIconColor(): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "ptech-input", never, { "maxlength": { "alias": "maxlength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "type": { "alias": "type"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "iconWidth": { "alias": "iconWidth"; "required": false; }; "iconHeight": { "alias": "iconHeight"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "forceFixedIcon": { "alias": "forceFixedIcon"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "inputmode": { "alias": "inputmode"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; }, { "buttonClick": "buttonClick"; }, ["suffixRef"], ["[matPrefix]", "[matSuffix]", "mat-hint, [mat-hint]", "mat-error, [mat-error]"], true, never>;
}

declare class TextareaComponent extends BaseField implements ControlValueAccessor {
    constructor(el: ElementRef<HTMLElement>);
    taRef?: ElementRef<HTMLTextAreaElement>;
    maxlength: number | string;
    rows: number;
    appearance: MatFormFieldAppearance;
    tooltip: string;
    autocomplete: string;
    showCounter: boolean;
    resize: 'none' | 'vertical' | 'horizontal' | 'both';
    allowHorizontalResize: boolean;
    private _val;
    get value(): any;
    set value(v: any);
    onChange: any;
    onTouch: any;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    get effectiveResize(): 'none' | 'vertical' | 'horizontal' | 'both';
    static ɵfac: i0.ɵɵFactoryDeclaration<TextareaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextareaComponent, "ptech-textarea", never, { "maxlength": { "alias": "maxlength"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "showCounter": { "alias": "showCounter"; "required": false; }; "resize": { "alias": "resize"; "required": false; }; "allowHorizontalResize": { "alias": "allowHorizontalResize"; "required": false; }; }, {}, never, ["mat-hint, [mat-hint], mat-error, [mat-error]"], true, never>;
}

type ButtonVariant = 'basic' | 'raised' | 'stroked' | 'flat' | 'icon' | 'fab' | 'mini-fab' | 'extended' | 'link';
type BtnSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
declare class ButtonComponent extends BaseField {
    hostDisplay: string;
    get gridColumn(): string | null;
    constructor(el: ElementRef<HTMLElement>);
    /** Variante do botão */
    type: ButtonVariant;
    /** Tamanho: sm | md | lg */
    size: BtnSize;
    /** Tooltip */
    tooltip: string;
    /** Ícone do Material (nome) */
    icon: string;
    /** Cor do ícone (hex/rgb/etc.) */
    iconColor: string;
    /** Tamanho do ícone: se quiser forçar um valor específico */
    iconWidth: string;
    iconHeight: string;
    /** Cor do texto (aplica quando usamos bg custom) */
    textColor: string;
    /** Navegação para variant 'link' */
    link: string;
    target: string;
    /** Estética */
    shape: 'default' | 'pill';
    /** Cor do botão: ThemePalette (primary/accent/warn) ou cor CSS */
    color: ThemePalette | string;
    buttonClick: EventEmitter<MouseEvent>;
    onLinkClick(event: MouseEvent): void;
    private sizes;
    get sizeCfg(): {
        h: number;
        pad: string;
        icon: number;
        font: number;
        iconIconOnly: number;
        iconFab: number;
        iconMiniFab: number;
    };
    get isThemeColor(): boolean;
    get themeColor(): ThemePalette | undefined;
    get customBackground(): string | null;
    /** Se quiser forçar tamanho de ícone custom, ele sobrepõe o token */
    get iconStyle(): Record<string, string | null>;
    get spinnerDiameter(): number;
    onInnerClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "ptech-button", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "iconWidth": { "alias": "iconWidth"; "required": false; }; "iconHeight": { "alias": "iconHeight"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "link": { "alias": "link"; "required": false; }; "target": { "alias": "target"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
}

type BadgeVariant = 'filled' | 'outline' | 'soft';
type BadgeSize = 'sm' | 'md' | 'lg';
type BadgePreset = 'success' | 'warning' | 'error' | 'info' | 'neutral' | 'purple' | 'primary' | 'accent' | 'warn';
declare class BadgeComponent {
    /** Texto do badge (ou use <ng-content>) */
    label: string;
    /** mat-icon opcional */
    icon?: string;
    /** Tooltip opcional */
    tooltip?: string;
    /** Acessibilidade */
    ariaLabel?: string;
    static ngAcceptInputType_clickable: BooleanInput;
    static ngAcceptInputType_disabled: BooleanInput;
    static ngAcceptInputType_pill: BooleanInput;
    static ngAcceptInputType_uppercase: BooleanInput;
    private _clickable;
    get clickable(): any;
    set clickable(v: any);
    private _disabled;
    get disabled(): any;
    set disabled(v: any);
    private _pill;
    get pill(): any;
    set pill(v: any);
    private _uppercase;
    get uppercase(): any;
    set uppercase(v: any);
    /** Forma/estilo */
    size: BadgeSize;
    variant: BadgeVariant;
    /** Cor: preset (success, warning, …) ou qualquer CSS color (#hex, rgb, hsl, var(...)) */
    color: BadgePreset | string;
    badgeClick: EventEmitter<MouseEvent>;
    badgeKey: EventEmitter<KeyboardEvent>;
    /** papel ARIA: se clicável, vira “button” */
    get role(): "button" | "status";
    get tab(): 0 | -1;
    private _col;
    set col(v: number | string | null | undefined);
    get gridColumn(): string | null;
    onClick(ev: MouseEvent): void;
    onKey(ev: KeyboardEvent): void;
    get cssVars(): {
        bg: string;
        fg: string;
        bd: string;
    };
    private resolveBaseColor;
    private isCssVar;
    private softFromVar;
    /** Parseia hex/rgb/hsl. Evita DOM/Canvas (SSR-safe). */
    private toRgb;
    private hslToRgb;
    private contrastOn;
    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeComponent, "ptech-badge", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "clickable": { "alias": "clickable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "pill": { "alias": "pill"; "required": false; }; "uppercase": { "alias": "uppercase"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "col": { "alias": "col"; "required": false; }; }, { "badgeClick": "badgeClick"; "badgeKey": "badgeKey"; }, never, ["*"], true, never>;
}

type Dir = 'row' | 'column';
type AlignItems = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
type Justify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
declare class BadgeStackComponent {
    /** Direção dos itens (padrão: column) */
    direction: Dir;
    /** Espaçamento entre itens. Aceita número (px) ou string ('1rem', '8px', etc.) */
    gap: number | string;
    /** Quebrar linha quando em row (wrap) */
    static ngAcceptInputType_wrap: BooleanInput;
    private _wrap;
    get wrap(): any;
    set wrap(v: any);
    /** Alinhamento vertical (align-items) */
    align: AlignItems;
    /** Alinhamento horizontal (justify-content) */
    justify: Justify;
    /** A11y opcional */
    ariaLabel?: string;
    private _col;
    set col(v: number | string | null | undefined);
    get gridColumn(): string | null;
    role: string;
    get aria(): string | null;
    disp: string;
    get dir(): Dir;
    get fwrap(): "wrap" | "nowrap";
    get cssGap(): string;
    get ai(): "center" | "stretch" | "baseline" | "flex-end" | "flex-start";
    get jc(): "center" | "flex-end" | "flex-start" | "space-between" | "space-around" | "space-evenly";
    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeStackComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeStackComponent, "ptech-badge-stack", never, { "direction": { "alias": "direction"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; }; "align": { "alias": "align"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "col": { "alias": "col"; "required": false; }; }, {}, never, ["*"], true, never>;
}

type ThemeColor = 'primary' | 'accent' | 'warn';
declare class IconComponent {
    /** Nome do ícone (ex.: 'home', 'search'…) */
    icon: string;
    /** Pode ser 'primary' | 'accent' | 'warn' ou qualquer cor CSS (#hex, rgb, etc.) */
    color: string;
    /** Tamanho: número (px) ou string CSS (ex.: '1.5rem') */
    size: number | string;
    /** A11y */
    static ngAcceptInputType_ariaHidden: BooleanInput;
    private _ariaHidden;
    get ariaHidden(): boolean;
    set ariaHidden(v: any);
    ariaLabel?: string;
    /** Grid opcional: span de colunas quando usado dentro de CSS Grid */
    private _col;
    set col(v: number | string | null | undefined);
    get gridColumn(): string | null;
    get sizePx(): string;
    isThemeColor(c: string | null | undefined, theme: ThemeColor): boolean;
    get customColor(): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "ptech-icon", never, { "icon": { "alias": "icon"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "ariaHidden": { "alias": "ariaHidden"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "col": { "alias": "col"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ActionRowComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActionRowComponent, "ptech-action-row", never, {}, {}, never, ["*"], true, never>;
}

declare class QuantityItemsComponent extends BaseField implements ControlValueAccessor {
    constructor(el: ElementRef<HTMLElement>);
    min: number;
    max: number | null;
    step: number;
    /** Compat c/ [(quantity)] */
    get quantity(): number;
    set quantity(v: number);
    quantityChange: EventEmitter<number>;
    current: number;
    private onChange;
    private onTouched;
    writeValue(v: number | null): void;
    registerOnChange(fn: (v: number) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    decrement(): void;
    increment(): void;
    private clamp;
    private setValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<QuantityItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<QuantityItemsComponent, "ptech-quantity-items", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "quantity": { "alias": "quantity"; "required": false; }; }, { "quantityChange": "quantityChange"; }, never, never, true, never>;
}

declare class SelectQuantityItemsComponent extends BaseField implements ControlValueAccessor {
    constructor(el: ElementRef<HTMLElement>);
    appearance: MatFormFieldAppearance;
    min: number;
    max: number;
    step: number;
    quantity: number;
    quantityChange: EventEmitter<number>;
    get quantityOptions(): number[];
    private onChange;
    private onTouched;
    onSelect(value: number): void;
    writeValue(value: number | null): void;
    registerOnChange(fn: (value: number) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectQuantityItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectQuantityItemsComponent, "ptech-select-quantity-items", never, { "appearance": { "alias": "appearance"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "quantity": { "alias": "quantity"; "required": false; }; }, { "quantityChange": "quantityChange"; }, never, never, true, never>;
}

type Entity = Record<string, any>;
declare class SelectEntityComponent extends BaseField implements ControlValueAccessor, OnChanges {
    constructor(el: ElementRef<HTMLElement>);
    multiple: boolean;
    property: string;
    propertyEnum?: Record<string, any>;
    propertyFn?: (obj: any) => string;
    idProp: string;
    searchPlaceholder: string;
    multipleTriggerMax: number;
    entities: Entity[];
    selectClick: EventEmitter<MouseEvent>;
    selectionChange: EventEmitter<any>;
    loadingChange: EventEmitter<boolean>;
    filteredEntities: Entity[];
    model: any;
    searchText: string;
    private onTouched;
    private onChange;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    setValue(v: any): void;
    compareFn: (a: any, b: any) => boolean;
    trackById: (_: number, item: any) => any;
    isArray(v: any): v is any[];
    private filterModel;
    private displayOf;
    getPropertyValue(entity: any): string;
    private getDeep;
    private resolveId;
    displayMultipleTrigger(items: any[]): string;
    onSearch(value: string): void;
    emitClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectEntityComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectEntityComponent, "ptech-select-entity", never, { "multiple": { "alias": "multiple"; "required": false; }; "property": { "alias": "property"; "required": false; }; "propertyEnum": { "alias": "propertyEnum"; "required": false; }; "propertyFn": { "alias": "propertyFn"; "required": false; }; "idProp": { "alias": "idProp"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "multipleTriggerMax": { "alias": "multipleTriggerMax"; "required": false; }; "entities": { "alias": "entities"; "required": false; }; }, { "selectClick": "selectClick"; "selectionChange": "selectionChange"; "loadingChange": "loadingChange"; }, never, never, true, never>;
}

interface BreadcrumbRoute {
    description: string;
    route?: string;
}
declare class BreadcrumbComponent {
    routes: BreadcrumbRoute[];
    isLast(route: BreadcrumbRoute): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "ptech-breadcrumb", never, { "routes": { "alias": "routes"; "required": false; }; }, {}, never, ["[start-icon]"], true, never>;
}

interface HeaderData {
    title: string;
    icon?: string;
    routeUrl?: string;
    imageHeader?: string;
}
declare class HeaderComponent {
    data: HeaderData;
    toggleNav: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "ptech-header", never, { "data": { "alias": "data"; "required": false; }; }, { "toggleNav": "toggleNav"; }, never, ["[user-profile]"], true, never>;
}

declare class NavService {
    private navVisible;
    get navState$(): rxjs.Observable<boolean>;
    get isNavOpen(): boolean;
    toggleNav(): void;
    open(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NavService>;
}

interface NavLink {
    icon: string;
    name: string;
    path?: string;
    children?: NavLink[];
}
interface FooterItem {
    icon: string;
    text: string;
}
declare class NavComponent implements AfterViewInit, OnDestroy {
    navService: NavService;
    private readonly cdr;
    private readonly breakpointObserver;
    private readonly router;
    links: NavLink[];
    currentModuleName: string;
    fixedTopGap: number;
    fixedBottomGap: number;
    footerItems: FooterItem[];
    hasBackdrop: boolean;
    mode: MatDrawerMode;
    backdropClick: EventEmitter<void>;
    headerClick: EventEmitter<void>;
    navigate: EventEmitter<NavLink>;
    logout: EventEmitter<void>;
    navListEl?: ElementRef<HTMLElement>;
    stack: NavLink[];
    navListOverflow: boolean;
    isMobile: boolean;
    readonly navOpen$: Observable<boolean>;
    private readonly destroy$;
    private resizeObserver?;
    private recalculationRafId;
    get effectiveMode(): MatDrawerMode;
    get effectiveHasBackdrop(): boolean;
    constructor(navService: NavService, cdr: ChangeDetectorRef, breakpointObserver: BreakpointObserver, router: Router);
    get currentLevel(): NavLink[];
    get currentTitle(): string;
    clickItem(item: NavLink, ev: MouseEvent): void;
    onHeaderClick(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private scheduleOverflowRecalc;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavComponent, "ptech-nav", never, { "links": { "alias": "links"; "required": false; }; "currentModuleName": { "alias": "currentModuleName"; "required": false; }; "fixedTopGap": { "alias": "fixedTopGap"; "required": false; }; "fixedBottomGap": { "alias": "fixedBottomGap"; "required": false; }; "footerItems": { "alias": "footerItems"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; }, { "backdropClick": "backdropClick"; "headerClick": "headerClick"; "navigate": "navigate"; "logout": "logout"; }, never, never, true, never>;
}

declare class FooterComponent {
    version: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FooterComponent, "ptech-footer", never, { "version": { "alias": "version"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LoadingService {
    private _isLoading;
    isLoading$: rxjs.Observable<boolean>;
    showLoading(): void;
    hideLoading(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingService>;
}

declare class LoadingOverlayComponent {
    private loadingService;
    isLoading: Observable<boolean>;
    constructor(loadingService: LoadingService);
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingOverlayComponent, "ptech-loading-overlay", never, {}, {}, never, never, true, never>;
}

declare class ProgressBarComponent implements OnChanges {
    progressStart: number;
    progressEnd: number;
    progressPercentage: number;
    ngOnChanges(changes: SimpleChanges): void;
    private calculateProgress;
    get dynamicColorPrimary(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressBarComponent, "ptech-progress-bar", never, { "progressStart": { "alias": "progressStart"; "required": false; }; "progressEnd": { "alias": "progressEnd"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ProgressBarMultipleComponent implements OnChanges {
    progressStartPrimary: number;
    progressEndPrimary: number;
    labelPrimary: string;
    progressStartSecondary?: number;
    progressEndSecondary?: number;
    labelSecondary?: string;
    progressPercentagePrimary: number;
    progressPercentageSecondary?: number;
    ngOnChanges(changes: SimpleChanges): void;
    private calculateProgress;
    private compute;
    get dynamicColorPrimary(): string;
    get dynamicColorSecondary(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarMultipleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressBarMultipleComponent, "ptech-progress-bar-multiple", never, { "progressStartPrimary": { "alias": "progressStartPrimary"; "required": false; }; "progressEndPrimary": { "alias": "progressEndPrimary"; "required": false; }; "labelPrimary": { "alias": "labelPrimary"; "required": false; }; "progressStartSecondary": { "alias": "progressStartSecondary"; "required": false; }; "progressEndSecondary": { "alias": "progressEndSecondary"; "required": false; }; "labelSecondary": { "alias": "labelSecondary"; "required": false; }; }, {}, never, never, true, never>;
}

type EnumArray = Array<{
    key: any;
    value: any;
}>;
type EnumMap = Record<string, any>;
declare class RadioGroupEnumComponent extends BaseField implements ControlValueAccessor {
    constructor(el: ElementRef<HTMLElement>);
    /** 'row' (padrão) ou 'column' */
    orientation: 'row' | 'column';
    /** Pode ser: { KEY: 'Rótulo' } ou [{ key, value }] */
    enums: EnumArray | EnumMap;
    valueChange: EventEmitter<any>;
    private _val;
    onChange: (val: any) => void;
    onTouch: () => void;
    get value(): any;
    set value(v: any);
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    get items(): EnumArray;
    trackByKey: (_: number, item: {
        key: any;
    }) => any;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupEnumComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupEnumComponent, "ptech-radio-group-enum", never, { "orientation": { "alias": "orientation"; "required": false; }; "enums": { "alias": "enums"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class RadioGroupEntityComponent extends BaseField implements ControlValueAccessor, OnChanges {
    constructor(el: ElementRef<HTMLElement>);
    property: string;
    idProp: string;
    entities: any[];
    private _value;
    get value(): any;
    set value(val: any);
    ngOnChanges(changes: SimpleChanges): void;
    getPropertyValue(entity: any): string;
    onChange: (value: any) => void;
    onTouch: () => void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    private syncModelReference;
    private resolveId;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupEntityComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupEntityComponent, "ptech-radio-group-entity", never, { "property": { "alias": "property"; "required": false; }; "idProp": { "alias": "idProp"; "required": false; }; "entities": { "alias": "entities"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SelectEnumComponent extends BaseField implements ControlValueAccessor, OnInit, OnChanges {
    constructor(el: ElementRef<HTMLElement>);
    multiple: boolean;
    enum: Record<string, any>;
    disabledOptions: string[];
    sort: (a: any, b: any) => number;
    labelMap: Record<string, string>;
    selectionChange: EventEmitter<any>;
    enumList: Array<{
        key: string;
        value: any;
    }>;
    private _val;
    get value(): any;
    set value(v: any);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private refreshEnumList;
    onSelectionChange(entity: any): void;
    private onChange;
    private onTouch;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectEnumComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectEnumComponent, "ptech-select-enum", never, { "multiple": { "alias": "multiple"; "required": false; }; "enum": { "alias": "enum"; "required": false; }; "disabledOptions": { "alias": "disabledOptions"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "labelMap": { "alias": "labelMap"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
}

declare class SlideToggleComponent extends BaseField implements ControlValueAccessor {
    constructor(el: ElementRef<HTMLElement>);
    /** Aparência padronizada (mesmo que mat-slide-toggle não use diretamente) */
    appearance: MatFormFieldAppearance;
    /** 'primary' | 'accent' | 'warn' */
    color: ThemePalette;
    /** Posição do rótulo */
    labelPosition: 'before' | 'after';
    /** Ripple */
    static ngAcceptInputType_disableRipple: BooleanInput;
    private _disableRipple;
    get disableRipple(): boolean;
    set disableRipple(v: any);
    /** Emissão adicional */
    change: EventEmitter<boolean>;
    private _value;
    get value(): boolean;
    set value(v: boolean);
    onChange: (v: any) => void;
    onTouch: () => void;
    writeValue(v: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onMatChange(checked: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlideToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlideToggleComponent, "ptech-slide-toggle", never, { "appearance": { "alias": "appearance"; "required": false; }; "color": { "alias": "color"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class TitleComponent implements OnChanges {
    private cd;
    title: string;
    subtitle: string;
    constructor(cd: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TitleComponent, "ptech-title", never, { "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface ConfirmationDTO {
    title: string;
    message: string;
    accept: () => void;
    cancelText?: string;
    confirmText?: string;
}

declare class ConfirmationDialogComponent {
    dialogRef: MatDialogRef<ConfirmationDialogComponent>;
    confirmation: ConfirmationDTO;
    constructor(dialogRef: MatDialogRef<ConfirmationDialogComponent>, confirmation: ConfirmationDTO);
    confirm(): void;
    cancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmationDialogComponent, "ptech-confirmation-dialog", never, {}, {}, never, never, true, never>;
}

interface PtechCurrencyConfig {
    align?: 'left' | 'right' | 'center';
    allowNegative?: boolean;
    allowZero?: boolean;
    locale?: string;
    currency?: string;
    currencyDisplay?: 'symbol' | 'narrowSymbol' | 'code' | 'name';
    useGrouping?: boolean;
    decimal?: string;
    precision?: number;
    prefix?: string;
    suffix?: string;
    thousands?: string;
    nullable?: boolean;
}
declare class InputCurrencyComponent extends BaseField implements ControlValueAccessor {
    constructor(el: ElementRef<HTMLElement>);
    /** Config por input (parcial) */
    options: Partial<PtechCurrencyConfig>;
    valueChange: EventEmitter<any>;
    private defaultOptions;
    get resolvedOptions(): PtechCurrencyConfig;
    private _val;
    displayValue: string;
    onChange: (val: any) => void;
    onTouch: () => void;
    private parseToNumber;
    private formatNumber;
    onInput(raw: string): void;
    onBlur(): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    private getLocale;
    private getCurrency;
    private getIntlFormatter;
    private detectLocaleSeparators;
    private getDecimalSeparator;
    private getThousandsSeparator;
    private normalizeInput;
    private parseUsingSeparators;
    private parseFlexible;
    private parseInputAsCurrencyValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputCurrencyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputCurrencyComponent, "ptech-input-currency", never, { "options": { "alias": "options"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["mat-hint, [mat-hint], mat-error, [mat-error]"], true, never>;
}

interface ActionDialogField<T = any> {
    type: 'select' | 'number' | 'text' | 'checkbox' | 'currency' | 'quantity-select';
    label: string;
    value?: any;
    options?: T[];
    min?: number;
    max?: number;
    step?: number;
    placeholder?: string;
    currencyOptions?: Partial<PtechCurrencyConfig>;
}
interface ActionDialogConfig {
    title: string;
    subtitle?: string;
    fields: ActionDialogField[];
    infoBox?: string;
    content?: string;
    rawContent?: string;
    confirmText?: string;
    cancelText?: string;
}

interface IMessageService {
    successMessage(title: string, message: string, details?: string[], timestamp?: string, duration?: number): void;
    errorMessage(title: string, message: string, details?: string[], timestamp?: string, duration?: number): void;
    warnMessage(title: string, message: string, details?: string[], timestamp?: string, duration?: number): void;
}
declare const MESSAGE_SERVICE: InjectionToken<IMessageService>;
declare const DefaultConsoleMessageService: IMessageService;
declare const DefaultMessageService: IMessageService;

declare class ActionDialogComponent {
    data: ActionDialogConfig;
    private dialogRef;
    private messageService?;
    constructor(data: ActionDialogConfig, dialogRef: MatDialogRef<ActionDialogComponent>, messageService?: IMessageService | undefined);
    private get msg();
    onConfirm(): void;
    onCancel(): void;
    onQuantityChange(field: any, value: number): void;
    onSelectionChange($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionDialogComponent, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActionDialogComponent, "ptech-action-dialog", never, {}, {}, never, never, true, never>;
}

declare class InfoDetailComponent {
    private dialog;
    infoTitle: string;
    infoSubtitle: string;
    infoContent: string;
    infoRawContent: string;
    iconColor: string;
    constructor(dialog: MatDialog);
    openInfo(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InfoDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InfoDetailComponent, "ptech-info-detail", never, { "infoTitle": { "alias": "infoTitle"; "required": false; }; "infoSubtitle": { "alias": "infoSubtitle"; "required": false; }; "infoContent": { "alias": "infoContent"; "required": false; }; "infoRawContent": { "alias": "infoRawContent"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class InfoDetailDialogComponent {
    data: {
        title: string;
        subtitle?: string;
        content: string;
        rawContent?: string;
    };
    private dialogRef;
    whatsappUrl: string;
    private readonly msgService;
    constructor(data: {
        title: string;
        subtitle?: string;
        content: string;
        rawContent?: string;
    }, dialogRef: MatDialogRef<InfoDetailDialogComponent>, messageService: IMessageService | null);
    copyToClipboard(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InfoDetailDialogComponent, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InfoDetailDialogComponent, "ptech-info-detail-dialog", never, {}, {}, never, never, true, never>;
}

interface ActionResultData {
    title: string;
    subtitle?: string;
    content?: string;
    rawContent?: string;
    details?: unknown;
}

declare class ActionResultDialogComponent implements OnInit {
    data: ActionResultData;
    private dialogRef;
    private sanitizer;
    private messageService;
    whatsappUrl: string;
    sanitizedContent: SafeHtml;
    constructor(data: ActionResultData, dialogRef: MatDialogRef<ActionResultDialogComponent>, sanitizer: DomSanitizer, messageService: IMessageService);
    ngOnInit(): void;
    close(): void;
    copyToClipboard(): void;
    openWhatsApp(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionResultDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActionResultDialogComponent, "ptech-action-result-dialog", never, {}, {}, never, never, true, never>;
}

type AlertType = 'success' | 'error' | 'warn' | 'info';
interface AlertData {
    title: string;
    message: string;
    details?: string[];
    icon?: string;
    type: AlertType;
    timestamp?: string | Date;
}

declare class AlertComponent {
    data: AlertData;
    private snackBarRef;
    constructor(data: AlertData, snackBarRef: MatSnackBarRef<AlertComponent>);
    getIconColor(type: string): string;
    closeSnackbar(): void;
    formattedTimestamp(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "ptech-alert", never, {}, {}, never, never, true, never>;
}

interface ProfileMenuItem {
    label: string;
    icon?: string;
    flagCode?: string;
    flagSize?: number;
    flagSquared?: boolean;
    flagAriaLabel?: string;
    action: () => void;
    dividerBefore?: boolean;
}
declare class ProfileMenuComponent {
    icon: string;
    flagCode?: string;
    flagSize: number;
    flagSquared: boolean;
    flagAriaLabel?: string;
    displayName: string;
    items: ProfileMenuItem[];
    handle(item: ProfileMenuItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProfileMenuComponent, "ptech-profile-menu", never, { "icon": { "alias": "icon"; "required": false; }; "flagCode": { "alias": "flagCode"; "required": false; }; "flagSize": { "alias": "flagSize"; "required": false; }; "flagSquared": { "alias": "flagSquared"; "required": false; }; "flagAriaLabel": { "alias": "flagAriaLabel"; "required": false; }; "displayName": { "alias": "displayName"; "required": false; }; "items": { "alias": "items"; "required": false; }; }, {}, never, ["[extra-items]"], true, never>;
}

declare class CheckBoxComponent extends BaseField implements ControlValueAccessor {
    constructor(el: ElementRef<HTMLElement>);
    color: string;
    static ngAcceptInputType_indeterminate: BooleanInput;
    private _indeterminate;
    get indeterminate(): boolean;
    set indeterminate(v: any);
    change: EventEmitter<boolean>;
    indeterminateChange: EventEmitter<boolean>;
    _value: boolean;
    set value(v: any);
    get value(): boolean;
    private onChangeFn;
    private onTouchFn;
    writeValue(v: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onCheckboxChange(checked: boolean): void;
    private toBool;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckBoxComponent, "ptech-check-box", never, { "color": { "alias": "color"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "change": "change"; "indeterminateChange": "indeterminateChange"; }, never, never, true, never>;
}

declare class InputDateRangeComponent extends BaseField implements ControlValueAccessor {
    dateChange: EventEmitter<{
        start: string | null;
        end: string | null;
    }>;
    /** Placeholders específicos; caem no placeholder do BaseField se não definidos */
    firstPlaceholder: string;
    secondPlaceholder: string;
    hint: string;
    panelClass?: string | string[];
    get resolvedPanelClass(): string[];
    /** Valor interno como string com offset ou null */
    start: string | null;
    end: string | null;
    private onChange;
    private onTouch;
    writeValue(obj: {
        start: string | null;
        end: string | null;
    } | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onStartDateChange(event: MatDatepickerInputEvent<Date>): void;
    onEndDateChange(event: MatDatepickerInputEvent<Date>): void;
    private emitDateChange;
    /** Converte Date -> 'YYYY-MM-DDTHH:mm:ss±HH:MM' com offset local; retorna null quando sem data */
    private toIsoWithLocalOffset;
    private pad;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateRangeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateRangeComponent, "ptech-input-date-range", never, { "panelClass": { "alias": "panelClass"; "required": false; }; }, { "dateChange": "dateChange"; }, never, never, true, never>;
}

type EmitMode = 'date' | 'isoDate' | 'isoDateTimeZ' | 'isoDateTimeTZ' | 'localOffset';
declare class InputDateComponent extends BaseField implements ControlValueAccessor, OnChanges, OnInit, OnDestroy {
    private cdr;
    inputDateElement: ElementRef<HTMLInputElement>;
    picker: MatDatepicker<Date>;
    dateCtrl: FormControl<Date | null>;
    dateChange: EventEmitter<string | Date | null>;
    opened: EventEmitter<void>;
    closed: EventEmitter<void>;
    min?: Date;
    max?: Date;
    startAt?: Date | null;
    startView: 'month' | 'year' | 'multi-year';
    touchUi: boolean;
    panelClass?: string | string[];
    get resolvedPanelClass(): string[];
    dateFilter?: (d: Date | null) => boolean;
    withTime: boolean;
    seconds: boolean;
    timeLabel: string;
    defaultTime: string;
    timepickerTheme?: NgxMaterialTimepickerTheme;
    timeZone?: string | number;
    emit: EmitMode;
    timeString: string;
    private destroy$;
    onChange: (val: any) => void;
    onTouched: () => void;
    get isDisabled(): boolean;
    private readonly defaultTimepickerTheme;
    get resolvedTimepickerTheme(): NgxMaterialTimepickerTheme;
    get timePickerDefaultTime(): string;
    get timePickerValue(): string;
    constructor(el: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: string | Date | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onTimeInput(v: string): void;
    onTimeBlur(): void;
    onTimeSet(raw: string): void;
    openTimePicker(picker: NgxMaterialTimepickerComponent): void;
    private emitCombined;
    private combine;
    private normalizeTime;
    private tryParseTime;
    private isValidTime;
    private formatTimeParts;
    private clamp;
    private parseToDate;
    private toOutput;
    private pad;
    private formatIsoDate;
    private formatWithFixedOffset;
    private formatInTimeZone;
    private offsetStringToMinutes;
    private getTzOffsetMinutes;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateComponent, "ptech-input-date", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "startView": { "alias": "startView"; "required": false; }; "touchUi": { "alias": "touchUi"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "withTime": { "alias": "withTime"; "required": false; }; "seconds": { "alias": "seconds"; "required": false; }; "timeLabel": { "alias": "timeLabel"; "required": false; }; "defaultTime": { "alias": "defaultTime"; "required": false; }; "timepickerTheme": { "alias": "timepickerTheme"; "required": false; }; "timeZone": { "alias": "timeZone"; "required": false; }; "emit": { "alias": "emit"; "required": false; }; }, { "dateChange": "dateChange"; "opened": "opened"; "closed": "closed"; }, never, ["mat-hint, [mat-hint], mat-error, [mat-error]"], true, never>;
}

declare class InputTimeComponent extends BaseField implements ControlValueAccessor {
    private cdr;
    constructor(el: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
    /** 24 (padrão) ou 12 */
    format: 12 | 24;
    /** mostra/oculta seleção de segundos */
    seconds: boolean;
    /** evita focar/editar manualmente (só via picker) */
    disableClick: boolean;
    /** permite sobrescrever o tema do popup quando necessário */
    timepickerTheme?: NgxMaterialTimepickerTheme;
    private readonly defaultTimepickerTheme;
    get resolvedTimepickerTheme(): NgxMaterialTimepickerTheme;
    /** defaultTime dinâmico conforme seconds */
    get defaultTime(): string;
    get pickerDefaultTime(): string;
    /** two-way opcional via (valueChange) */
    valueChange: EventEmitter<string>;
    private _val;
    draftValue: string;
    onChange: (val: any) => void;
    onTouch: () => void;
    get value(): string | null;
    set value(v: string | null);
    get displayValue(): string;
    get pickerValue(): string;
    writeValue(val: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onTimeSet(raw: string): void;
    openPicker(picker: NgxMaterialTimepickerComponent): void;
    onInput(raw: string): void;
    onInputBlur(): void;
    private parseTime;
    private tryParseTime;
    private pad;
    private clamp;
    private normalizeIncomingValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputTimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputTimeComponent, "ptech-input-time", never, { "format": { "alias": "format"; "required": false; }; "seconds": { "alias": "seconds"; "required": false; }; "disableClick": { "alias": "disableClick"; "required": false; }; "timepickerTheme": { "alias": "timepickerTheme"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["mat-hint, [mat-hint], mat-error, [mat-error]"], true, never>;
}

declare class FlagComponent {
    /** ISO 3166-1 alpha-2 (ex.: 'BR', 'ES', 'US'). */
    code: string | null | undefined;
    /** Tamanho em px (controla a altura; largura acompanha 4:3). */
    size: number;
    /** Usa ícone quadrado do flag-icons. */
    static ngAcceptInputType_squared: BooleanInput;
    private _squared;
    get squared(): boolean;
    set squared(v: any);
    /** Tooltip (fallback para o próprio code). */
    tooltip?: string;
    /** Texto opcional ao lado da bandeira. */
    label?: string;
    /** A11y: rótulo para leitores de tela (ex.: "Bandeira do Brasil"). */
    ariaLabel?: string;
    /** Emite click opcionalmente e muda o cursor/teclado. */
    static ngAcceptInputType_clickable: BooleanInput;
    private _clickable;
    get clickable(): boolean;
    set clickable(v: any);
    flagClick: EventEmitter<string>;
    private _col;
    set col(v: number | string | null | undefined);
    get gridColumn(): string | null;
    /** Classe CSS final do flag-icons (normaliza UK->GB). */
    get classCode(): string;
    handleClick(): void;
    onKey(ev: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FlagComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FlagComponent, "ptech-flag", never, { "code": { "alias": "code"; "required": false; }; "size": { "alias": "size"; "required": false; }; "squared": { "alias": "squared"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "label": { "alias": "label"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "clickable": { "alias": "clickable"; "required": false; }; "col": { "alias": "col"; "required": false; }; }, { "flagClick": "flagClick"; }, never, never, true, never>;
}

declare class TableCellDirective {
    template: TemplateRef<any>;
    columnKey: string;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDirective, "ng-template[tableCell]", never, { "columnKey": { "alias": "tableCell"; "required": false; }; }, {}, never, never, true, never>;
}

type TableAlign = 'left' | 'center' | 'right';
type TableColType = 'text' | 'number' | 'date' | 'image' | 'badge' | 'toggle';
interface TableBadgeConfig<T> {
    label: string | ((row: T) => string);
    /** Preset da lib ou qualquer CSS color (#hex, rgb, var(...)) */
    color?: BadgePreset | string | ((row: T) => BadgePreset | string);
    /** filled | outline | soft */
    variant?: BadgeVariant | ((row: T) => BadgeVariant);
    /** sm | md | lg */
    size?: BadgeSize | ((row: T) => BadgeSize);
    /** controla se o badge aparece para a linha */
    visible?: (row: T) => boolean;
}
interface TableColumn<T> {
    key: string;
    header: string;
    type?: TableColType;
    align?: TableAlign;
    width?: string;
    /**
     * Para 'image': de onde tirar a URL/alt
     */
    imageKey?: keyof T | string;
    altKey?: keyof T | string;
    /**
     * Para text/number/date, permite customizar a célula
     */
    cell?: (row: T) => string | number | null | undefined;
    /**
     * Para colunas do tipo 'badge'
     * - pode ser um array fixo de configs
     * - ou uma função que recebe a linha e retorna os badges
     */
    badges?: TableBadgeConfig<T>[] | ((row: T) => TableBadgeConfig<T>[]);
    /** cor dinâmica para o texto */
    color?: string | ((row: T) => string);
    /** Para colunas do tipo 'toggle' */
    toggleValue?: (row: T) => boolean;
    toggleLabel?: string | ((row: T) => string);
    toggleDisabled?: boolean | ((row: T) => boolean);
}
interface TableAction<T> {
    icon: string;
    tooltip?: string;
    color?: string;
    handler: (row: T) => void;
    /** controla se a ação aparece para a linha */
    visible?: (row: T) => boolean;
}
interface TableReorderEvent<T> {
    previousIndex: number;
    currentIndex: number;
    item: T;
    data: T[];
}
interface TableSelectionChangeEvent<T> {
    mode: 'single' | 'multiple';
    row: T | null;
    rows: T[];
    ids: Array<string | number>;
}
interface TableToggleChangeEvent<T> {
    row: T;
    column: TableColumn<T>;
    value: boolean;
}
declare class TableComponent<T> implements OnChanges, DoCheck, AfterContentInit {
    private iterableDiffers;
    title: string;
    loading: boolean;
    data: T[];
    total: number;
    pageIndex: number;
    pageSize: number;
    pageSizeOptions: number[];
    columns: TableColumn<T>[];
    actions: TableAction<T>[];
    selectRow: boolean;
    selectMultipleRow: boolean;
    selectionMode: 'none' | 'single' | 'multiple' | null;
    usePtechSelectionControls: boolean;
    getRowId: (row: T) => string | number;
    /** imagem de fallback para <img> quebrada ou ausente */
    imageFallback: string;
    /** ativa visualização em cards no mobile */
    responsiveCards: boolean;
    reorderable: boolean;
    selectedRows: EventEmitter<T[]>;
    selectedRow: EventEmitter<T | null>;
    selectedIds: EventEmitter<(string | number)[]>;
    selectionChange: EventEmitter<TableSelectionChangeEvent<T>>;
    page: EventEmitter<{
        pageIndex: number;
        pageSize: number;
    }>;
    reorder: EventEmitter<TableReorderEvent<T>>;
    toggleChange: EventEmitter<TableToggleChangeEvent<T>>;
    displayedColumns: string[];
    renderData: T[];
    selection: SelectionModel<T>;
    private selectedIdSet;
    private dataDiffer?;
    private matTable?;
    cellTemplates: QueryList<TableCellDirective>;
    private cellTemplateMap;
    constructor(iterableDiffers: IterableDiffers);
    ngAfterContentInit(): void;
    private rebuildTemplateMap;
    getCellTemplate(key: string): TemplateRef<any> | null;
    ngOnChanges(changes: SimpleChanges): void;
    ngDoCheck(): void;
    private syncRenderData;
    toggleAllRows(): void;
    /** Verifica se todas estão selecionadas */
    isAllSelected(): boolean;
    clearSelection(): void;
    /** Marca/desmarca uma linha */
    toggleRow(row: T): void;
    /** Emite o estado atual */
    private emitSelected;
    /** Verifica se uma linha está selecionada */
    isSelected(row: T): boolean;
    onPage(ev: any): void;
    onDrop(event: CdkDragDrop<T[]>): void;
    cellTemplateContext(row: T, col: TableColumn<T>, rowIndex?: number): {
        $implicit: T;
        row: T;
        column: TableColumn<T>;
        value: any;
        index: number | undefined;
    };
    renderCell(row: T, col: TableColumn<T>): any;
    resolveImage(row: T, col: TableColumn<T>): string | null;
    resolveAlt(row: T, col: TableColumn<T>): string | null;
    resolveColor(row: T, col: TableColumn<T>): string | null;
    read(obj: any, path: string): any;
    onImgError(ev: Event): void;
    /** BADGES: resolve a lista de badges para a linha+coluna */
    getBadges(row: T, col: TableColumn<T>): Array<{
        label: string;
        color: BadgePreset | string;
        variant: BadgeVariant;
        size: BadgeSize;
    }>;
    badgeJustify(align?: TableAlign): 'start' | 'center' | 'end';
    resolveActionColor(action: TableAction<T>): string;
    resolveToggleValue(row: T, col: TableColumn<T>): boolean;
    resolveToggleLabel(row: T, col: TableColumn<T>): string;
    resolveToggleDisabled(row: T, col: TableColumn<T>): boolean;
    onToggleColumnChange(row: T, col: TableColumn<T>, value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "ptech-table", never, { "title": { "alias": "title"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "data": { "alias": "data"; "required": false; }; "total": { "alias": "total"; "required": false; }; "pageIndex": { "alias": "pageIndex"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "selectRow": { "alias": "selectRow"; "required": false; }; "selectMultipleRow": { "alias": "selectMultipleRow"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "usePtechSelectionControls": { "alias": "usePtechSelectionControls"; "required": false; }; "getRowId": { "alias": "getRowId"; "required": false; }; "imageFallback": { "alias": "imageFallback"; "required": false; }; "responsiveCards": { "alias": "responsiveCards"; "required": false; }; "reorderable": { "alias": "reorderable"; "required": false; }; }, { "selectedRows": "selectedRows"; "selectedRow": "selectedRow"; "selectedIds": "selectedIds"; "selectionChange": "selectionChange"; "page": "page"; "reorder": "reorder"; "toggleChange": "toggleChange"; }, ["cellTemplates"], ["[table-filters]", "[table-filters-actions]"], true, never>;
}

declare class ListPaginationComponent {
    totalItems: number;
    page: number;
    pageSize: number;
    pageSizeOptions: number[];
    pageSizeLabel: string;
    pageLabel: string;
    ofLabel: string;
    showingLabel: string;
    itemsLabel: string;
    firstLabel: string;
    previousLabel: string;
    nextLabel: string;
    lastLabel: string;
    pageChange: EventEmitter<number>;
    pageSizeChange: EventEmitter<number>;
    get totalPages(): number;
    get visibleRangeStart(): number;
    get visibleRangeEnd(): number;
    goFirst(): void;
    goPrev(): void;
    goNext(): void;
    goLast(): void;
    handlePageSizeChange(value: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListPaginationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListPaginationComponent, "ptech-list-pagination", never, { "totalItems": { "alias": "totalItems"; "required": false; }; "page": { "alias": "page"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "pageSizeLabel": { "alias": "pageSizeLabel"; "required": false; }; "pageLabel": { "alias": "pageLabel"; "required": false; }; "ofLabel": { "alias": "ofLabel"; "required": false; }; "showingLabel": { "alias": "showingLabel"; "required": false; }; "itemsLabel": { "alias": "itemsLabel"; "required": false; }; "firstLabel": { "alias": "firstLabel"; "required": false; }; "previousLabel": { "alias": "previousLabel"; "required": false; }; "nextLabel": { "alias": "nextLabel"; "required": false; }; "lastLabel": { "alias": "lastLabel"; "required": false; }; }, { "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
}

declare class DialogShellComponent {
    title: string;
    subtitle?: string;
    draggable: boolean;
    showDrag: boolean;
    showClose: boolean;
    dragRootElement: string;
    close: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogShellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogShellComponent, "ptech-dialog-shell", never, { "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "showDrag": { "alias": "showDrag"; "required": false; }; "showClose": { "alias": "showClose"; "required": false; }; "dragRootElement": { "alias": "dragRootElement"; "required": false; }; }, { "close": "close"; }, never, ["*"], true, never>;
}

declare const MY_DATE_FORMATS: {
    parse: {
        dateInput: string;
    };
    display: {
        dateInput: string;
        monthYearLabel: string;
        dateA11yLabel: string;
        monthYearA11yLabel: string;
    };
};
declare class CoreMaterialModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreMaterialModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreMaterialModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.MatToolbarModule, typeof i4.MatSidenavModule, typeof i5.MatListModule, typeof i6.MatButtonModule, typeof i7.MatSnackBarModule, typeof i8.MatCardModule, typeof i9.MatFormFieldModule, typeof i10.MatInputModule, typeof i11.MatSelectModule, typeof i12.MatTableModule, typeof i13.MatPaginatorModule, typeof i14.MatSortModule, typeof i15.MatIconModule, typeof i16.MatDividerModule, typeof i17.MatTooltipModule, typeof i18.MatMenuModule, typeof i19.MatDatepickerModule, typeof i20.MatProgressBarModule, typeof i21.MatSlideToggleModule, typeof i22.MatDialogModule, typeof i23.MatRadioModule, typeof i24.MatCheckboxModule, typeof i25.MatProgressSpinnerModule], [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.MatToolbarModule, typeof i4.MatSidenavModule, typeof i5.MatListModule, typeof i6.MatButtonModule, typeof i7.MatSnackBarModule, typeof i8.MatCardModule, typeof i9.MatFormFieldModule, typeof i10.MatInputModule, typeof i11.MatSelectModule, typeof i12.MatTableModule, typeof i13.MatPaginatorModule, typeof i14.MatSortModule, typeof i15.MatIconModule, typeof i16.MatDividerModule, typeof i17.MatTooltipModule, typeof i18.MatMenuModule, typeof i19.MatDatepickerModule, typeof i20.MatProgressBarModule, typeof i21.MatSlideToggleModule, typeof i22.MatDialogModule, typeof i23.MatRadioModule, typeof i24.MatCheckboxModule, typeof i25.MatProgressSpinnerModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CoreMaterialModule>;
}

declare class PumpkinTechModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PumpkinTechModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PumpkinTechModule, never, [typeof i1.CommonModule, typeof CoreMaterialModule, typeof InputComponent, typeof TextareaComponent, typeof InputDateComponent, typeof InputDateRangeComponent, typeof InputTimeComponent, typeof InputCurrencyComponent, typeof InfoDetailComponent, typeof InfoDetailDialogComponent, typeof ActionDialogComponent, typeof ActionResultDialogComponent, typeof ButtonComponent, typeof BadgeComponent, typeof BadgeStackComponent, typeof BreadcrumbComponent, typeof TitleComponent, typeof ActionRowComponent, typeof HeaderComponent, typeof NavComponent, typeof FooterComponent, typeof IconComponent, typeof SelectEntityComponent, typeof SelectEnumComponent, typeof RadioGroupEnumComponent, typeof RadioGroupEntityComponent, typeof SlideToggleComponent, typeof QuantityItemsComponent, typeof SelectQuantityItemsComponent, typeof LoadingOverlayComponent, typeof ProfileMenuComponent, typeof CheckBoxComponent, typeof ProgressBarComponent, typeof ProgressBarMultipleComponent, typeof FlagComponent, typeof TableComponent, typeof ListPaginationComponent, typeof DialogShellComponent], [typeof InputComponent, typeof TextareaComponent, typeof InputDateComponent, typeof InputDateRangeComponent, typeof InputTimeComponent, typeof InputCurrencyComponent, typeof InfoDetailComponent, typeof InfoDetailDialogComponent, typeof ActionDialogComponent, typeof ActionResultDialogComponent, typeof ButtonComponent, typeof BadgeComponent, typeof BadgeStackComponent, typeof BreadcrumbComponent, typeof TitleComponent, typeof ActionRowComponent, typeof HeaderComponent, typeof NavComponent, typeof FooterComponent, typeof IconComponent, typeof SelectEntityComponent, typeof SelectEnumComponent, typeof RadioGroupEnumComponent, typeof RadioGroupEntityComponent, typeof SlideToggleComponent, typeof QuantityItemsComponent, typeof SelectQuantityItemsComponent, typeof LoadingOverlayComponent, typeof ProfileMenuComponent, typeof CheckBoxComponent, typeof ProgressBarComponent, typeof ProgressBarMultipleComponent, typeof FlagComponent, typeof TableComponent, typeof ListPaginationComponent, typeof DialogShellComponent, typeof CoreMaterialModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PumpkinTechModule>;
}

declare class UpperCaseDirective {
    ngControl: NgControl;
    enabledUpperCase: boolean;
    constructor(ngControl: NgControl);
    onModelChange(event: string): void;
    onInput(event: Event): void;
    private apply;
    static ɵfac: i0.ɵɵFactoryDeclaration<UpperCaseDirective, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UpperCaseDirective, "[ptechUpperCase]", never, { "enabledUpperCase": { "alias": "ptechUpperCase"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LowerCaseDirective {
    ngControl: NgControl;
    enabledLowerCase: boolean;
    constructor(ngControl: NgControl);
    onModelChange(event: string): void;
    onInput(event: Event): void;
    private apply;
    static ɵfac: i0.ɵɵFactoryDeclaration<LowerCaseDirective, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LowerCaseDirective, "[ptechLowerCase]", never, { "enabledLowerCase": { "alias": "ptechLowerCase"; "required": false; }; }, {}, never, never, true, never>;
}

declare class RedDirective {
    private el;
    private renderer;
    constructor(el: ElementRef, renderer: Renderer2);
    static ɵfac: i0.ɵɵFactoryDeclaration<RedDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RedDirective, "[ptechRed]", never, {}, {}, never, never, true, never>;
}

declare class ClickCatcherDirective {
    onClick(id: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClickCatcherDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickCatcherDirective, "[ptechClickCatcher]", never, {}, {}, never, never, true, never>;
}

declare class ForDirective implements OnChanges {
    private container;
    private template;
    numbers: any[];
    constructor(container: ViewContainerRef, template: TemplateRef<any>);
    ngOnChanges(changes: SimpleChanges): void;
    private render;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ForDirective, "[ptechFor]", never, { "numbers": { "alias": "ptechForEm"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PhoneMaskBrazilDirective {
    ngControl: NgControl;
    constructor(ngControl: NgControl);
    onModelChange(event: string): void;
    onBackspace(event: KeyboardEvent): void;
    private apply;
    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneMaskBrazilDirective, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PhoneMaskBrazilDirective, "[ptechPhoneMaskBrazil]", never, {}, {}, never, never, true, never>;
}

declare class PhoneMaskSpainDirective {
    ngControl: NgControl;
    constructor(ngControl: NgControl);
    onModelChange(event: string): void;
    onBackspace(event: KeyboardEvent): void;
    private apply;
    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneMaskSpainDirective, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PhoneMaskSpainDirective, "[ptechPhoneMaskSpain]", never, {}, {}, never, never, true, never>;
}

declare class SpaceDropDirective {
    ngControl: NgControl;
    enabled: boolean;
    constructor(ngControl: NgControl);
    onModelChange(value: string): void;
    onInput(event: Event): void;
    private apply;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaceDropDirective, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SpaceDropDirective, "[ptechSpaceDrop]", never, { "enabled": { "alias": "ptechSpaceDrop"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DateMaskDirective {
    onInputChange(event: Event): void;
    onKeyDown(event: KeyboardEvent): void;
    private applyMask;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateMaskDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DateMaskDirective, "[ptechDateMask]", never, {}, {}, never, never, true, never>;
}

declare class DynamicTabDirective {
    viewContainer: ViewContainerRef;
    constructor(viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicTabDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicTabDirective, "[ptechDynamicTab]", never, {}, {}, never, never, true, never>;
}

declare class DirectivesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DirectivesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DirectivesModule, never, [typeof UpperCaseDirective, typeof LowerCaseDirective, typeof RedDirective, typeof ClickCatcherDirective, typeof ForDirective, typeof PhoneMaskBrazilDirective, typeof PhoneMaskSpainDirective, typeof SpaceDropDirective, typeof DateMaskDirective, typeof DynamicTabDirective, typeof PtechGridDirective, typeof PtechColDirective, typeof TableCellDirective], [typeof UpperCaseDirective, typeof LowerCaseDirective, typeof RedDirective, typeof ClickCatcherDirective, typeof ForDirective, typeof PhoneMaskBrazilDirective, typeof PhoneMaskSpainDirective, typeof SpaceDropDirective, typeof DateMaskDirective, typeof DynamicTabDirective, typeof PtechGridDirective, typeof PtechColDirective, typeof TableCellDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DirectivesModule>;
}

declare class CurrencyBrlPipe implements PipeTransform {
    private currencyPipe;
    transform(value: unknown, symbolDisplay?: boolean): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyBrlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CurrencyBrlPipe, "currencybrl", true>;
}

declare class DateAgoPipe implements PipeTransform {
    private readonly intervals;
    transform(value: unknown): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateAgoPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateAgoPipe, "dateAgo", true>;
}

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

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

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

declare class MemoryFormatPipe implements PipeTransform {
    transform(value: number | string | null | undefined, unit?: 'MB' | 'GB'): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MemoryFormatPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MemoryFormatPipe, "memoryFormat", true>;
}

declare class PhoneBrazilPipe implements PipeTransform {
    transform(tel: unknown): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneBrazilPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PhoneBrazilPipe, "phoneBrazil", true>;
}

declare class PhoneSpainPipe implements PipeTransform {
    transform(tel: unknown): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneSpainPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PhoneSpainPipe, "phoneSpain", true>;
}

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

declare class TimeDurationPipe implements PipeTransform {
    transform(input: Date | string | number | null | undefined, now?: Date | null): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeDurationPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TimeDurationPipe, "timeDuration", true>;
}

declare class IsLongerThanPipe implements PipeTransform {
    transform(input: Date | string | number | null | undefined, threshold: number | string, // horas (número) OU string: "00:30", "30m", "2h", "90s", "1:30:00"
    now?: Date | null): boolean;
    private parseThresholdToMs;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsLongerThanPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsLongerThanPipe, "isLongerThan", true>;
}

declare class PipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PipesModule, never, [typeof i1.CommonModule, typeof CurrencyBrlPipe, typeof DateAgoPipe, typeof GetFirstStringBeforeSpacePipe, typeof LineBreakAfterPeriodPipe, typeof LineBreakAfterPipe, typeof MemoryFormatPipe, typeof PhoneBrazilPipe, typeof PhoneSpainPipe, typeof UptimeFormatPipe, typeof TimeDurationPipe, typeof IsLongerThanPipe], [typeof CurrencyBrlPipe, typeof DateAgoPipe, typeof GetFirstStringBeforeSpacePipe, typeof LineBreakAfterPeriodPipe, typeof LineBreakAfterPipe, typeof MemoryFormatPipe, typeof PhoneBrazilPipe, typeof PhoneSpainPipe, typeof UptimeFormatPipe, typeof TimeDurationPipe, typeof IsLongerThanPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PipesModule>;
}

declare class SnackbarMessageService implements IMessageService {
    private snackBar;
    constructor(snackBar: MatSnackBar);
    private openSnackBar;
    successMessage(title: string, message: string, details?: string[], timestamp?: string, duration?: number): void;
    errorMessage(title: string, message: string, details?: string[], timestamp?: string, duration?: number): void;
    warnMessage(title: string, message: string, details?: string[], timestamp?: string, duration?: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SnackbarMessageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SnackbarMessageService>;
}

interface DialogModel<T = any, D = any> {
    component: any;
    data?: D;
    width?: string;
    height?: string;
    position?: MatDialogConfig['position'];
    panelClass?: string | string[];
    disableClose?: boolean;
}
declare class DialogService {
    private dialog;
    constructor(dialog: MatDialog);
    private resolvePanelClass;
    open<T = any, R = any>(model: DialogModel<T, any>): MatDialogRef<T, R>;
    openInfo(arg: {
        title: string;
        subtitle?: string;
        content: string;
        rawContent?: string;
    }, width?: string): MatDialogRef<InfoDetailDialogComponent>;
    openActionDialog(config: ActionDialogConfig, width?: string): MatDialogRef<ActionDialogComponent, any>;
    openResultDialog(arg: ActionResultData, width?: string): MatDialogRef<ActionResultDialogComponent>;
    confirm(confirmation: ConfirmationDTO, width?: string): Observable<boolean>;
    /**
     * Abre um ActionDialog e, se houver resultado, usa o builder para criar
     * o ActionResultData e abre o resultado.
     * Retorna um observable que emite quando o fluxo completo terminou.
     */
    openActionThenResult(actionConfig: Omit<ActionDialogConfig, 'fields'> & {
        fields?: any[];
    }, resultConfigBuilder: (actionResult: any) => ActionResultData): Observable<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}

declare class ModuleChangeService {
    private moduleChangedSource;
    moduleChanged$: rxjs.Observable<string>;
    notifyModuleChange(lastModule: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModuleChangeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModuleChangeService>;
}

type CurrencyCode = 'EUR' | 'USD' | 'BRL';
declare class CurrencyPreferenceService {
    private _currency;
    private readonly _subject;
    readonly currency$: rxjs.Observable<CurrencyCode>;
    constructor();
    private loadInitialCurrency;
    private isSupported;
    private _setCurrencyInternal;
    getCurrency(): CurrencyCode;
    setCurrency(newCurrency: CurrencyCode): void;
    getCurrencySymbol(): string;
    getThousandSeparator(): string;
    getDecimalMarker(): string;
    getPlaceholder(): string;
    formatAmount(value: number, options?: {
        minimumFractionDigits?: number;
        maximumFractionDigits?: number;
        useSymbol?: boolean;
    }): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyPreferenceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CurrencyPreferenceService>;
}

declare class BreadcrumbService {
    private router;
    private prefix$;
    private _crumbs;
    readonly breadcrumbs$: Observable<BreadcrumbRoute[]>;
    constructor(router: Router, prefix$: Observable<BreadcrumbRoute[]>);
    private buildDynamicCrumbs;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, [null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbService>;
}

/**
 * Se o app consumidor quiser inserir dinamicamente
 * o crumb de “módulo” (ou qualquer outro prefixo),
 * ele pode fornecer um Observable<BreadcrumbRoute[]> aqui.
 */
declare const BREADCRUMB_PREFIX$: InjectionToken<Observable<BreadcrumbRoute[]>>;

declare class ObjectUtil {
    static isNull(value: any): boolean;
    static isEmptyObject(obj: object): boolean;
    /**
     * Considera “novo” um modelo sem id ou com id não positivo.
     */
    static isNewModel(value: any): boolean;
    static clone<T extends object>(value: T | null | undefined): T | {};
}

declare class StringUtil {
    static readonly EMPTY = "";
    static replaceAccents(value: string): string;
    static removeAccents(value: string): string;
    static isEmpty(value: string | null | undefined): boolean;
    /**
     * Aplica máscara simples onde '9' é placeholder numérico.
     */
    static format(value: string, mask: string): string;
    /**
     * Corta por quantidade de caracteres.
     * Ex: ellipsisByChars('Vodafone Spain', 4) => 'Voda…'
     */
    static ellipsisByChars(value: string | null | undefined, maxChars: number, suffix?: string): string;
    /**
     * Corta por quantidade de palavras (separado por espaços).
     * Ex: ellipsisByWords('Vodafone Spain', 1) => 'Vodafone…'
     */
    static ellipsisByWords(value: string | null | undefined, maxWords: number, suffix?: string): string;
    /**
     * “Smart”: se tiver espaço, corta por palavras; se não, corta por caracteres.
     * Ex:
     *  smartEllipsis('Vodafone Spain', 4, 1) => 'Vodafone…'
     *  smartEllipsis('Vodafone', 4, 1)       => 'Voda…'
     */
    static smartEllipsis(value: string | null | undefined, maxChars: number, maxWords: number, suffix?: string): string;
}

declare class ArrayUtil {
    static isEmpty<T>(value: T[] | null | undefined): boolean;
    static clone<T>(value: T[] | null | undefined): T[];
    /**
     * Usar como predicate em filter para distinct por comparação de id
     * Ex: array.filter(ArrayUtil.distinctById)
     */
    static distinctById: (obj: any, index: number, self: any[]) => boolean;
}

declare class NumberUtil {
    static isPositive(value: number | null | undefined): boolean;
    static format(value: number | null | undefined, digitsInfo?: string): string;
    static get(value: number | null | undefined): number;
}

declare class DateUtil {
    static readonly DATE_FORMAT = "dd/MM/yyyy";
    static readonly DATE_TIME_FORMAT = "dd/MM/yyyy HH:mm";
    static readonly DATE_TIME_FORMAT_SLICED = "dd/MM/yy HH:mm";
    static readonly DATE_TIME_FULL_FORMAT = "dd/MM/yyyy HH:mm:ss";
    /**
     * Aceita Date | string | undefined. Retorna string formatada ou vazio.
     */
    static format(value: Date | string | undefined | null, format: string): string;
    static getTotalDaysInMonth(month: number, year: number): number;
    static addMonthsToDate(date: Date, monthsToAdd: number): Date;
    static addDaysToDate(days: number, date: Date): Date;
    static isValid(value: any): boolean;
    static isGreaterThan(initial: Date | string, final: Date | string): boolean;
    static isLessThan(initial: Date | string, final: Date | string): boolean;
    static isBetween(date: Date | string, initial: Date | string, final: Date | string): boolean;
    static getDayOfWeek(date: Date): string;
}

declare class CurrencyUtil {
    /**
     * @param value número a formatar. Se nulo/indefinido retorna string vazia.
     * @param currency código ISO (ex: 'BRL') ou símbolo informal passado como terceiro arg se precisar.
     * @param digitsInfo formato, ex: '1.2-2'
     */
    static transform(value: number | null | undefined, currency?: string, digitsInfo?: string): string;
}

declare class DocumentUtil {
    static isValidCpf(cpf: string): boolean;
    static isValidCnpj(cnpj: string): boolean;
}

declare class UuidUtil {
    private static uuidPattern;
    static isUUID(uuid: string | null | undefined): boolean;
    static extractUUID(uuid: string | null | undefined): string | null;
}

/**
 * Modelo mínimo de usuário falso gerado.
 */
interface FakeUser {
    name: string;
    email: string;
    phone: string;
    birthDate: Date | string;
    password: string;
}
/**
 * Opções para geração de senha.
 * Espelha o esperado pelo faker.internet.password({ ... })
 */
interface PasswordOptions {
    length?: number;
    memorable?: boolean;
    pattern?: RegExp;
    prefix?: string;
}
declare class FakeDataService {
    private readonly DEFAULT_PASSWORD_OPTIONS;
    randomPassword(options?: PasswordOptions): string;
    generateUsers(count: number): FakeUser[];
    formatPhoneNumber(phone: string): string;
    /**
     * Retorna opções de senha padrão, permitindo sobreposição:
     * ex: passwordDefaults({ length: 10, prefix: 'Hi' })
     */
    passwordDefaults(overrides?: PasswordOptions): Required<PasswordOptions>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FakeDataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FakeDataService>;
}

export { ActionDialogComponent, ActionResultDialogComponent, ActionRowComponent, AlertComponent, ArrayUtil, BREADCRUMB_PREFIX$, BadgeComponent, BadgeStackComponent, BreadcrumbComponent, BreadcrumbService, ButtonComponent, CheckBoxComponent, ClickCatcherDirective, ConfirmationDialogComponent, CoreMaterialModule, CurrencyBrlPipe, CurrencyPreferenceService, CurrencyUtil, DateAgoPipe, DateMaskDirective, DateUtil, DefaultConsoleMessageService, DefaultMessageService, DialogService, DialogShellComponent, DirectivesModule, DocumentUtil, DynamicTabDirective, FakeDataService, FlagComponent, FooterComponent, ForDirective, GetFirstStringBeforeSpacePipe, HeaderComponent, IconComponent, InfoDetailComponent, InfoDetailDialogComponent, InputComponent, InputCurrencyComponent, InputDateComponent, InputDateRangeComponent, InputTimeComponent, IsLongerThanPipe, LineBreakAfterPeriodPipe, LineBreakAfterPipe, ListPaginationComponent, LoadingOverlayComponent, LoadingService, LowerCaseDirective, MESSAGE_SERVICE, MY_DATE_FORMATS, MemoryFormatPipe, ModuleChangeService, NavComponent, NavService, NumberUtil, ObjectUtil, PhoneBrazilPipe, PhoneMaskBrazilDirective, PhoneMaskSpainDirective, PhoneSpainPipe, PipesModule, ProfileMenuComponent, ProgressBarComponent, ProgressBarMultipleComponent, PtechColDirective, PtechGridDirective, PumpkinTechModule, QuantityItemsComponent, RadioGroupEntityComponent, RadioGroupEnumComponent, RedDirective, SelectEntityComponent, SelectEnumComponent, SelectQuantityItemsComponent, SlideToggleComponent, SnackbarMessageService, SpaceDropDirective, StringUtil, TableCellDirective, TableComponent, TextareaComponent, TimeDurationPipe, TitleComponent, UpperCaseDirective, UptimeFormatPipe, UuidUtil };
export type { ActionDialogConfig, ActionDialogField, ActionResultData, AlertData, AlertType, BadgePreset, BadgeSize, BadgeVariant, BreadcrumbRoute, ConfirmationDTO, CurrencyCode, DialogModel, FakeUser, FooterItem, HeaderData, IMessageService, NavLink, PasswordOptions, ProfileMenuItem, PtechCurrencyConfig, TableAction, TableAlign, TableBadgeConfig, TableColType, TableColumn, TableReorderEvent, TableSelectionChangeEvent, TableToggleChangeEvent };
