@ngx-smz/ui-kit 0.0.0-stage → 21.9.0-next.10

package/types/ngx-smz-ui-kit.d.ts

@@ -0,0 +1,2542 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnDestroy, AfterContentChecked, InjectionToken, Type, ViewContainerRef, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Observable, Subject } from 'rxjs';
+import { Overlay } from '@angular/cdk/overlay';
+import * as _ngx_smz_ui_kit from '@ngx-smz/ui-kit';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
+type SmzClassValue = string | false | null | undefined;
+type VariantGroups = Record<string, Record<string, string>>;
+type SmzVariantProps<V extends VariantGroups> = {
+    [K in keyof V]?: keyof V[K] & string;
+};
+interface SmzVariantsConfig<V extends VariantGroups> {
+    /** Classes aplicadas sempre. */
+    base: string;
+    /** Grupos de variantes mutuamente exclusivos (ex.: size, severity). */
+    variants: V;
+    /** Valor usado quando a prop nao e informada. */
+    defaults?: SmzVariantProps<V>;
+    /** Classes que dependem da combinacao de duas ou mais variantes. */
+    compound?: Array<{
+        when: SmzVariantProps<V>;
+        class: string;
+    }>;
+}
+declare function smzCx(...parts: SmzClassValue[]): string;
+/**
+ * Combina classes por variante. As strings de classe devem ser literais completas
+ * (nunca montadas por concatenacao), senao o Tailwind nao as encontra no scan.
+ * Nao resolve conflitos entre utilitarios: mantenha as variantes mutuamente exclusivas.
+ */
+declare function smzVariants<V extends VariantGroups>(config: SmzVariantsConfig<V>): (props?: SmzVariantProps<V>) => string;
+
+type SmzSeverity = 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+/** Severidades do vocabulario antigo (PrimeNG), aceitas por compatibilidade. */
+type SmzLegacySeverity = 'info' | 'warn' | 'error' | 'help' | 'contrast';
+declare function smzNormalizeSeverity(value: string | null | undefined, fallback?: SmzSeverity): SmzSeverity;
+/** Fundo solido por severidade (badge, tag). Strings literais para o Tailwind encontrar no scan. */
+declare const SMZ_SOLID_TONE: Record<SmzSeverity, string>;
+/** Fundo suave com borda por severidade (message). */
+declare const SMZ_SOFT_TONE: Record<SmzSeverity, string>;
+
+/**
+ * Base de ControlValueAccessor para os controles de formulario do ui-kit.
+ * O componente concreto deve registrar NG_VALUE_ACCESSOR em `providers`.
+ * Fornece a entrada `disabled` e o estado combinado `isDisabled` (entrada ou desabilitado pelo formulario).
+ */
+declare abstract class SmzValueAccessor<T> implements ControlValueAccessor {
+    readonly current: _angular_core.WritableSignal<T>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly formDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    writeValue(value: T | null): void;
+    registerOnChange(fn: (value: T | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected commit(value: T | null): void;
+    protected touch(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzValueAccessor<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzValueAccessor<any>, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Substitui o `pTemplate` do PrimeNG: marca um `ng-template` com um nome para o componente
+ * hospedeiro localizar via `contentChildren(SmzTemplateDirective)`.
+ *
+ * <ng-template smzTemplate="header">...</ng-template>
+ */
+declare class SmzTemplateDirective {
+    readonly template: TemplateRef<unknown>;
+    readonly name: _angular_core.InputSignal<string>;
+    /** Compatibilidade com `PrimeTemplate.getType()`. */
+    getType(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzTemplateDirective, "ng-template[smzTemplate]", never, { "name": { "alias": "smzTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare function smzFindTemplate(templates: readonly SmzTemplateDirective[], name: string): TemplateRef<unknown> | undefined;
+
+interface SmzUiMenuItemCommandEvent {
+    originalEvent?: Event;
+    item?: SmzUiMenuItem;
+    index?: number;
+}
+/** Item de menu do ui-kit. Substitui o `MenuItem` do PrimeNG na API publica. */
+interface SmzUiMenuItem {
+    id?: string;
+    label?: string;
+    icon?: string;
+    command?: (event: SmzUiMenuItemCommandEvent) => void;
+    url?: string;
+    target?: string;
+    routerLink?: any;
+    queryParams?: any;
+    fragment?: string;
+    routerLinkActiveOptions?: any;
+    queryParamsHandling?: 'merge' | 'preserve' | '';
+    preserveFragment?: boolean;
+    relativeTo?: unknown;
+    replaceUrl?: boolean;
+    skipLocationChange?: boolean;
+    items?: SmzUiMenuItem[];
+    separator?: boolean;
+    disabled?: boolean;
+    visible?: boolean;
+    expanded?: boolean;
+    badge?: string;
+    badgeStyleClass?: string;
+    tooltip?: string;
+    tooltipOptions?: unknown;
+    title?: string;
+    /** Quando `false`, o label e interpretado como HTML. */
+    escape?: boolean;
+    automationId?: unknown;
+    styleClass?: string;
+    iconClass?: string;
+    labelStyleClass?: string;
+    state?: Record<string, unknown>;
+    /** Dados livres do consumidor. */
+    data?: any;
+    [extra: string]: any;
+}
+
+/** No de arvore do ui-kit. Substitui o `TreeNode` do PrimeNG na API publica. */
+interface SmzUiTreeNode<T = any> {
+    key?: string;
+    label?: string;
+    data?: T;
+    icon?: string;
+    expandedIcon?: string;
+    collapsedIcon?: string;
+    type?: string;
+    children?: SmzUiTreeNode<T>[];
+    parent?: SmzUiTreeNode<T>;
+    expanded?: boolean;
+    leaf?: boolean;
+    selectable?: boolean;
+    draggable?: boolean;
+    droppable?: boolean;
+    partialSelected?: boolean;
+    styleClass?: string;
+    checked?: boolean;
+    loading?: boolean;
+    /** Campos extras usados pelo consumidor (ex.: `tooltip`). */
+    [extra: string]: any;
+}
+
+/** Substitui o `FilterMatchMode` do PrimeNG. Os valores sao os mesmos para facilitar a migracao. */
+declare const SmzFilterMatchMode: {
+    readonly STARTS_WITH: "startsWith";
+    readonly CONTAINS: "contains";
+    readonly NOT_CONTAINS: "notContains";
+    readonly ENDS_WITH: "endsWith";
+    readonly EQUALS: "equals";
+    readonly NOT_EQUALS: "notEquals";
+    readonly IN: "in";
+    readonly LESS_THAN: "lt";
+    readonly LESS_THAN_OR_EQUAL_TO: "lte";
+    readonly GREATER_THAN: "gt";
+    readonly GREATER_THAN_OR_EQUAL_TO: "gte";
+    readonly BETWEEN: "between";
+    readonly IS: "is";
+    readonly IS_NOT: "isNot";
+    readonly BEFORE: "before";
+    readonly AFTER: "after";
+    readonly DATE_IS: "dateIs";
+    readonly DATE_IS_NOT: "dateIsNot";
+    readonly DATE_BEFORE: "dateBefore";
+    readonly DATE_AFTER: "dateAfter";
+};
+type SmzFilterMatchModeValue = (typeof SmzFilterMatchMode)[keyof typeof SmzFilterMatchMode];
+/** Substitui o `FilterOperator` do PrimeNG. */
+declare const SmzFilterOperator: {
+    readonly AND: "and";
+    readonly OR: "or";
+};
+type SmzFilterOperatorValue = (typeof SmzFilterOperator)[keyof typeof SmzFilterOperator];
+/** Substitui o `FilterMetadata` do PrimeNG. */
+interface SmzFilterMetadata {
+    value?: any;
+    matchMode?: SmzFilterMatchModeValue | string;
+    operator?: SmzFilterOperatorValue | string;
+}
+
+type SmzButtonSeverity = 'primary' | 'secondary' | 'danger' | 'success' | 'warning';
+type SmzButtonVariant = 'solid' | 'outlined' | 'text';
+type SmzButtonSize = 'sm' | 'md' | 'lg';
+type SmzButtonIconPosition = 'left' | 'right';
+/** Severidades aceitas por compatibilidade com o vocabulario antigo (PrimeNG). */
+type SmzButtonLegacySeverity = 'info' | 'warn' | 'help' | 'error' | 'contrast' | 'plain' | 'ghost';
+interface ParsedStyleClass {
+    severity?: SmzButtonSeverity;
+    variant?: SmzButtonVariant;
+    size?: SmzButtonSize;
+    rounded?: boolean;
+    extra: string;
+}
+/**
+ * Interpreta strings de classe no vocabulario antigo (`p-button-outlined p-button-sm px-3`).
+ * Tokens `p-button-*` viram props; os demais seguem como classes extras.
+ */
+type SmzStyleClass = string | SmzStyleClass[] | Record<string, unknown> | null | undefined;
+declare function smzNormalizeStyleClass(value: SmzStyleClass): string;
+declare function smzParseButtonStyleClass(styleClass: SmzStyleClass): ParsedStyleClass;
+/**
+ * Botao do ui-kit. Substitui o `pButton` / `p-button` do PrimeNG.
+ *
+ * <button smzButton label="Excluir" icon="fa-solid fa-trash" severity="danger" variant="outlined"></button>
+ *
+ * `styleClass` aceita o vocabulario antigo (`p-button-outlined p-button-sm`) alem de classes livres.
+ */
+declare class SmzButtonComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly iconPosition: _angular_core.InputSignal<SmzButtonIconPosition>;
+    readonly severity: _angular_core.InputSignal<SmzButtonSeverity | SmzButtonLegacySeverity>;
+    readonly variant: _angular_core.InputSignal<SmzButtonVariant>;
+    readonly size: _angular_core.InputSignal<SmzButtonSize>;
+    /** Atalhos do vocabulario antigo: equivalem a `variant="text"` e `variant="outlined"`. */
+    readonly text: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly outlined: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly styleClass: _angular_core.InputSignal<SmzStyleClass>;
+    private readonly staticClass;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzButtonComponent, "button[smzButton], a[smzButton]", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "outlined": { "alias": "outlined"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type SmzTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+type SmzTooltipEvent = 'hover' | 'focus' | 'both';
+interface SmzTooltipOptions {
+    tooltipPosition?: SmzTooltipPosition;
+    showDelay?: number;
+    hideDelay?: number;
+    tooltipEvent?: SmzTooltipEvent;
+    escape?: boolean;
+    tooltipStyleClass?: string;
+    tooltipZIndex?: string | number;
+    tooltipDisabled?: boolean;
+}
+declare class SmzTooltipComponent {
+    readonly text: _angular_core.InputSignal<string>;
+    readonly escape: _angular_core.InputSignal<boolean>;
+    protected readonly classes = "max-w-xs rounded-control bg-ui-fg px-2 py-1 font-ui text-ui-xs text-ui-surface-1 shadow-overlay";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTooltipComponent, "ui-tooltip", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "escape": { "alias": "escape"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Tooltip do ui-kit. Substitui o `pTooltip` do PrimeNG.
+ * Requer o CSS do CDK Overlay no app (`@angular/cdk/overlay-prebuilt.css`).
+ *
+ * <button smzButton smzTooltip="Salvar" tooltipPosition="bottom">...</button>
+ */
+declare class SmzTooltipDirective implements OnDestroy {
+    readonly text: _angular_core.InputSignal<string>;
+    readonly tooltipPosition: _angular_core.InputSignal<SmzTooltipPosition>;
+    readonly showDelay: _angular_core.InputSignal<number>;
+    readonly hideDelay: _angular_core.InputSignal<number>;
+    readonly tooltipEvent: _angular_core.InputSignal<SmzTooltipEvent>;
+    readonly escape: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly tooltipStyleClass: _angular_core.InputSignal<string>;
+    readonly tooltipZIndex: _angular_core.InputSignal<string | number>;
+    readonly tooltipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Opcoes agrupadas (compatibilidade com `tooltipOptions` do PrimeNG). Sobrescrevem os inputs individuais. */
+    readonly tooltipOptions: _angular_core.InputSignal<SmzTooltipOptions>;
+    /** Aceito por compatibilidade; o overlay do CDK ja e anexado ao body. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    private readonly overrides;
+    private readonly overlay;
+    private readonly host;
+    private overlayRef?;
+    private showTimer?;
+    private hideTimer?;
+    /** Ajuste programatico de opcoes (usado por diretivas que envolvem o tooltip). */
+    configure(options: SmzTooltipOptions): void;
+    onEnter(source: 'hover' | 'focus'): void;
+    onLeave(source: 'hover' | 'focus'): void;
+    show(): void;
+    hide(): void;
+    ngOnDestroy(): void;
+    private accepts;
+    private option;
+    private open;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzTooltipDirective, "[smzTooltip]", never, { "text": { "alias": "smzTooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "showDelay": { "alias": "showDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; "tooltipEvent": { "alias": "tooltipEvent"; "required": false; "isSignal": true; }; "escape": { "alias": "escape"; "required": false; "isSignal": true; }; "tooltipStyleClass": { "alias": "tooltipStyleClass"; "required": false; "isSignal": true; }; "tooltipZIndex": { "alias": "tooltipZIndex"; "required": false; "isSignal": true; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; "isSignal": true; }; "tooltipOptions": { "alias": "tooltipOptions"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Efeito ripple. Substitui o `pRipple` do PrimeNG.
+ * Usa a Web Animations API, entao nao depende de CSS/keyframes.
+ */
+declare class SmzRippleDirective {
+    private readonly host;
+    protected ripple(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzRippleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzRippleDirective, "[smzRipple]", never, {}, {}, never, never, true, never>;
+}
+
+type SmzInputSize = 'sm' | 'md' | 'lg';
+/** Campo de texto. Substitui o `pInputText` do PrimeNG. */
+declare class SmzInputTextDirective {
+    readonly size: _angular_core.InputSignal<SmzInputSize>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly staticClass;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzInputTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzInputTextDirective, "input[smzInputText]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Area de texto. Substitui o `pTextarea` / `pInputTextarea` do PrimeNG. */
+declare class SmzTextareaDirective {
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Cresce com o conteudo (equivale ao `autoResize` do `pTextarea`). */
+    readonly autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly el;
+    constructor();
+    protected resize(): void;
+    private readonly staticClass;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTextareaDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzTextareaDirective, "textarea[smzTextarea]", never, { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Checkbox do ui-kit. Substitui o `p-checkbox` do PrimeNG.
+ *
+ * - Booleano: `<ui-checkbox formControlName="ativo" label="Ativo" />`
+ * - Grupo (modelo e um array): `<ui-checkbox formControlName="itens" value="a" label="A" />`
+ */
+declare class SmzCheckboxComponent extends SmzValueAccessor<unknown> {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    /** Valor deste item quando o modelo e um array (modo grupo). */
+    readonly value: _angular_core.InputSignal<unknown>;
+    /** Forca o modo booleano mesmo com `value` informado. Mantido por compatibilidade com o Prime. */
+    readonly binary: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly changed: _angular_core.OutputEmitterRef<{
+        checked: boolean;
+        value: unknown;
+    }>;
+    private readonly groupMode;
+    protected readonly checked: _angular_core.Signal<boolean>;
+    protected readonly boxClasses: _angular_core.Signal<"border-ui-primary bg-ui-primary text-ui-on-primary" | "border-ui-line-strong bg-ui-surface-1 text-transparent">;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzCheckboxComponent, "ui-checkbox", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "binary": { "alias": "binary"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Radio do ui-kit. Substitui o `p-radiobutton` do PrimeNG.
+ * Cada radio do grupo usa o mesmo controle de formulario e o mesmo `name`.
+ *
+ * <ui-radio-button formControlName="tipo" name="tipo" value="a" label="A" />
+ */
+declare class SmzRadioButtonComponent extends SmzValueAccessor<unknown> {
+    private readonly injector;
+    private readonly destroyRef;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly clicked: _angular_core.OutputEmitterRef<{
+        value: unknown;
+    }>;
+    /**
+     * Os radios do grupo compartilham o mesmo controle, mas `commit` so atualiza o radio clicado.
+     * Acompanhar o valor do controle mantem os demais radios sincronizados (desmarcam visualmente).
+     */
+    constructor();
+    protected readonly checked: _angular_core.Signal<boolean>;
+    protected select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzRadioButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzRadioButtonComponent, "ui-radio-button", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Interruptor. Substitui o `p-toggleswitch` do PrimeNG.
+ *
+ * <ui-toggle-switch formControlName="ativo" />
+ */
+declare class SmzToggleSwitchComponent extends SmzValueAccessor<boolean> {
+    readonly name: _angular_core.InputSignal<string>;
+    readonly changed: _angular_core.OutputEmitterRef<{
+        checked: boolean;
+    }>;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzToggleSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzToggleSwitchComponent, "ui-toggle-switch", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+/** Contador/etiqueta pequena. Substitui o `p-badge` do PrimeNG. */
+declare class SmzBadgeComponent {
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly severity: _angular_core.InputSignal<SmzSeverity | SmzLegacySeverity>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzBadgeComponent, "ui-badge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Etiqueta de status. Substitui o `p-tag` do PrimeNG. */
+declare class SmzTagComponent {
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly severity: _angular_core.InputSignal<SmzSeverity | SmzLegacySeverity>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly rounded: _angular_core.InputSignal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTagComponent, "ui-tag", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type SmzDividerLayout = 'horizontal' | 'vertical';
+/** Linha separadora. Substitui o `p-divider` do PrimeNG (sem conteudo central). */
+declare class SmzDividerComponent {
+    readonly layout: _angular_core.InputSignal<SmzDividerLayout>;
+    protected readonly classes: _angular_core.Signal<"mx-3 block w-px self-stretch bg-ui-line" | "my-4 block h-px w-full bg-ui-line">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzDividerComponent, "ui-divider", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SmzSkeletonShape = 'rectangle' | 'circle';
+/** Placeholder de carregamento. Substitui o `p-skeleton` do PrimeNG. */
+declare class SmzSkeletonComponent {
+    readonly shape: _angular_core.InputSignal<SmzSkeletonShape>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<"block animate-pulse rounded-full bg-ui-surface-3" | "block animate-pulse rounded-control bg-ui-surface-3">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzSkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzSkeletonComponent, "ui-skeleton", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SmzProgressBarMode = 'determinate' | 'indeterminate';
+/** Barra de progresso. Substitui o `p-progressbar` do PrimeNG. */
+declare class SmzProgressBarComponent {
+    readonly value: _angular_core.InputSignal<number>;
+    readonly mode: _angular_core.InputSignal<SmzProgressBarMode>;
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly percent: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzProgressBarComponent, "ui-progress-bar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SmzMessageSeverity = 'info' | 'success' | 'warn' | 'error' | 'secondary';
+/** Mensagem inline. Substitui o `p-message` do PrimeNG. */
+declare class SmzMessageComponent {
+    readonly severity: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzMessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzMessageComponent, "ui-message", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Icone baseado em classes de fonte de icones (ex.: "fa-solid fa-check", "fa-solid fa-check").
+ * A origem dos glifos e do app; o componente so padroniza a marcacao.
+ */
+declare class SmzIconComponent {
+    readonly name: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzIconComponent, "ui-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare function smzMergeClasses(base: string, overrides: string | null | undefined): string;
+/** Le a classe estatica do elemento hospedeiro (`class="..."`), para mescla-la com as classes do componente. */
+declare function smzStaticHostClass(): string;
+
+/**
+ * Badge sobreposto a um elemento (canto superior direito). Substitui o `pBadge` do PrimeNG.
+ *
+ * <i class="fa-solid fa-bell" smzBadge [value]="count"></i>
+ */
+declare class SmzBadgeDirective implements OnDestroy {
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly severity: _angular_core.InputSignal<SmzSeverity | SmzLegacySeverity>;
+    private readonly host;
+    private readonly renderer;
+    private badge?;
+    constructor();
+    ngOnDestroy(): void;
+    private removeBadge;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzBadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzBadgeDirective, "[smzBadge]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Utilitarios de objeto usados pelos componentes de dados (tabela, arvore, selects).
+ * Substitui o `ObjectUtils` do PrimeNG, com a mesma semantica dos metodos usados.
+ */
+declare class SmzObjectUtils {
+    static isEmpty(value: any): boolean;
+    static isNotEmpty(value: any): boolean;
+    static isFunction(value: any): boolean;
+    /** Le um campo de um objeto; aceita caminho com ponto (`a.b.c`) ou funcao. */
+    static resolveFieldData(data: any, field: any): any;
+    static equals(first: any, second: any, field?: string): boolean;
+    static deepEquals(first: any, second: any): boolean;
+    /** Move um item de `from` para `to` (muta o array). */
+    static reorderArray(value: any[], from: number, to: number): void;
+    static removeAccents(text: string): string;
+    /**
+     * Compara dois valores respeitando valores vazios (vazio vai para o fim na ordem ascendente).
+     * `locale` define o collator usado para strings (com ordenacao numerica).
+     */
+    static compare(first: any, second: any, locale?: string, order?: number): number;
+    static sort(first: any, second: any, order?: number, locale?: string, nullSortOrder?: number): number;
+}
+/** Gera ids unicos para elementos (`smz_id_1`, `smz_id_2`...). Substitui o `UniqueComponentId` do PrimeNG. */
+declare function smzUniqueId(prefix?: string): string;
+
+declare function read(element: HTMLElement | null | undefined): number;
+/**
+ * Gerencia a pilha de z-index de overlays (dialogs, menus, popovers).
+ * Substitui o `ZIndexUtils` do PrimeNG.
+ */
+declare const SmzZIndex: {
+    get: typeof read;
+    getCurrent: (key?: string) => number;
+    set: (key: string, element: HTMLElement | null | undefined, baseZIndex?: number) => void;
+    clear: (element: HTMLElement | null | undefined) => void;
+};
+
+/**
+ * Utilitarios de DOM usados pelos componentes que manipulam elementos diretamente (tabela, dialog, menu).
+ * Substitui o `DomHandler` do PrimeNG, com os mesmos nomes e semantica dos metodos usados.
+ */
+declare class SmzDomHandler {
+    private static classes;
+    static hasClass(element: any, className: string): boolean;
+    static addClass(element: any, className: string): void;
+    static removeClass(element: any, className: string): void;
+    static invokeElementMethod(element: any, methodName: string, args?: any[]): void;
+    static find(element: any, selector: string): any;
+    static findSingle(element: any, selector: string): any;
+    static matches(element: any, selector: string): boolean;
+    static index(element: any): number;
+    static indexWithinGroup(element: any, attributeName: string): number;
+    static appendChild(element: any, target: any): void;
+    static isElement(obj: any): boolean;
+    static getOuterWidth(element: any, margin?: boolean): number;
+    static getOuterHeight(element: any, margin?: boolean): number;
+    static getOffset(element: any): {
+        top: any;
+        left: any;
+    };
+    static getWindowScrollTop(): number;
+    static getWindowScrollLeft(): number;
+    static getViewport(): {
+        width: number;
+        height: number;
+    };
+    static getHiddenElementDimensions(element: any): {
+        width: number;
+        height: number;
+    };
+    static getHiddenElementOuterWidth(element: any): number;
+    static getHiddenElementOuterHeight(element: any): number;
+    static isVisible(element: any): boolean;
+    static isTouchDevice(): boolean;
+    static clearSelection(): void;
+    static getFocusableElements(element: any, selector?: string): any[];
+    /** Posiciona `element` (position: absolute no body) abaixo de `target`, invertendo se nao couber. */
+    static absolutePosition(element: any, target: any, gutter?: boolean): void;
+    /** Posiciona `element` relativo ao seu offsetParent, abaixo de `target`. */
+    static relativePosition(element: any, target: any, gutter?: boolean): void;
+}
+/**
+ * Dispara `listener` quando qualquer ancestral rolavel de `element` rola (usado para fechar overlays conectados).
+ * Substitui o `ConnectedOverlayScrollHandler` do PrimeNG.
+ */
+declare class SmzConnectedOverlayScrollHandler {
+    private element;
+    private listener;
+    private parents;
+    constructor(element: any, listener?: () => void);
+    bindScrollListener(): void;
+    unbindScrollListener(): void;
+    destroy(): void;
+}
+
+/**
+ * Foca o primeiro elemento focavel (ou o proprio hospedeiro) apos a renderizacao.
+ * Substitui o `pAutoFocus` do PrimeNG.
+ *
+ * <input smzAutoFocus />   <div [smzAutoFocus]="true"> ... </div>
+ */
+declare class SmzAutoFocusDirective implements AfterContentChecked {
+    readonly autofocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly host;
+    private focused;
+    ngAfterContentChecked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzAutoFocusDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzAutoFocusDirective, "[smzAutoFocus]", never, { "autofocus": { "alias": "smzAutoFocus"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Configuracao de um dialog aberto por `SmzDialogService`. Tambem e o token de DI para o componente do conteudo. */
+declare class SmzDialogConfig<TData = any> {
+    data?: TData;
+    header?: string;
+    width?: string;
+    height?: string;
+    showHeader?: boolean;
+    modal?: boolean;
+    closable?: boolean;
+    closeOnEscape?: boolean;
+    dismissableMask?: boolean;
+    baseZIndex?: number;
+    style?: Record<string, string>;
+    contentStyle?: Record<string, string>;
+    styleClass?: string;
+}
+/** Referencia ao dialog aberto. Injetavel no componente do conteudo para fechar com um resultado. */
+declare class SmzDialogRef<TResult = unknown> {
+    private readonly closeSubject;
+    private closeHandler;
+    /** Emite o resultado quando o dialog fecha. */
+    readonly onClose: Observable<TResult | undefined>;
+    close(result?: TResult): void;
+    /** @internal registrado pelo servico para destruir o overlay. */
+    bind(closeHandler: () => void): void;
+}
+
+/** Componente que sera criado dentro do dialog. */
+declare const SMZ_DIALOG_CONTENT: InjectionToken<Type<unknown>>;
+/** Moldura do dialog: cabecalho com titulo e botao fechar, mais a area do conteudo. */
+declare class SmzDialogFrameComponent {
+    protected readonly config: SmzDialogConfig<any>;
+    protected readonly ref: SmzDialogRef<any>;
+    private readonly injector;
+    private readonly contentType;
+    private readonly host;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzDialogFrameComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzDialogFrameComponent, "ui-dialog-frame", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Abre um componente dentro de um dialog modal (CDK Overlay). Substitui o `DialogService` do PrimeNG.
+ * Requer o CSS do CDK Overlay no app (`@angular/cdk/overlay-prebuilt.css`).
+ *
+ * const ref = dialogs.open(MeuComponente, { header: 'Titulo', width: '50%', data: { ... } });
+ * ref.onClose.subscribe((resultado) => ...);
+ */
+declare class SmzDialogService {
+    private readonly overlay;
+    private readonly injector;
+    open<TResult = unknown>(content: Type<unknown>, config?: Partial<SmzDialogConfig>): SmzDialogRef<TResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SmzDialogService>;
+}
+
+/** Posicoes aceitas por `ui-dialog`. */
+type SmzDialogPosition = 'center' | 'top' | 'bottom' | 'left' | 'right' | 'topleft' | 'topright' | 'bottomleft' | 'bottomright';
+/**
+ * Dialog declarativo. Substitui o `p-dialog` do PrimeNG.
+ *
+ * <ui-dialog header="Titulo" [(visible)]="aberto" [style]="{ width: '450px' }">
+ *   conteudo
+ *   <ng-template smzTemplate="footer"><button smzButton label="Salvar"></button></ng-template>
+ * </ui-dialog>
+ */
+declare class SmzDialogComponent implements OnDestroy {
+    readonly visible: _angular_core.ModelSignal<boolean>;
+    readonly header: _angular_core.InputSignal<string>;
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dismissableMask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly style: _angular_core.InputSignal<Record<string, string | number>>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly baseZIndex: _angular_core.InputSignal<number>;
+    /** Permite arrastar pelo cabecalho. */
+    readonly draggable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Mostra a alca nativa de redimensionar no canto inferior direito. */
+    readonly resizable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Mostra o botao de maximizar no cabecalho padrao (com `smzTemplate="header"` use `maximize()`). */
+    readonly maximizable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly maximized: _angular_core.ModelSignal<boolean>;
+    /** Posicao na tela (como o `position` do `p-dialog`). */
+    readonly position: _angular_core.InputSignal<SmzDialogPosition>;
+    readonly shown: _angular_core.OutputEmitterRef<void>;
+    readonly hidden: _angular_core.OutputEmitterRef<void>;
+    private readonly panel;
+    private readonly templates;
+    protected readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly footerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    private readonly overlay;
+    private readonly viewContainer;
+    private readonly host;
+    private overlayRef?;
+    protected readonly dx: _angular_core.WritableSignal<number>;
+    protected readonly dy: _angular_core.WritableSignal<number>;
+    constructor();
+    /** Alterna entre maximizado e normal. */
+    maximize(): void;
+    protected startDrag(event: PointerEvent): void;
+    private strategyFor;
+    close(): void;
+    ngOnDestroy(): void;
+    private open;
+    private dispose;
+    /** O `data-testid` posto no hospedeiro vai para o painel renderizado no overlay (usado nos testes e2e). */
+    private forwardTestId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzDialogComponent, "ui-dialog", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "dismissableMask": { "alias": "dismissableMask"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "baseZIndex": { "alias": "baseZIndex"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "maximizable": { "alias": "maximizable"; "required": false; "isSignal": true; }; "maximized": { "alias": "maximized"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; "maximized": "maximizedChange"; "shown": "shown"; "hidden": "hidden"; }, ["templates"], ["*"], true, never>;
+}
+
+/** Elemento real ou ancora virtual que apenas informa o retangulo. */
+type SmzPopoverTarget = Element | {
+    getBoundingClientRect(): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+};
+/**
+ * Painel flutuante ancorado a um elemento. Substitui o `p-popover` do PrimeNG.
+ *
+ * <button smzButton (click)="op.toggle($event)"></button>
+ * <ui-popover #op>conteudo</ui-popover>
+ */
+declare class SmzPopoverComponent implements OnDestroy {
+    readonly style: _angular_core.InputSignal<Record<string, string | number>>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly dismissable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly autoZIndex: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Aceito por compatibilidade; o overlay do CDK ja e anexado ao body. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    readonly shown: _angular_core.OutputEmitterRef<void>;
+    readonly hidden: _angular_core.OutputEmitterRef<void>;
+    private readonly panel;
+    private readonly overlay;
+    private readonly viewContainer;
+    private readonly host;
+    private overlayRef?;
+    private origin?;
+    get overlayVisible(): boolean;
+    toggle(event: Event | null, target?: SmzPopoverTarget): void;
+    show(event: Event | null, target?: SmzPopoverTarget): void;
+    hide(): void;
+    ngOnDestroy(): void;
+    /** Ancora virtual (objeto com `getBoundingClientRect`) vira um ponto para o CDK. */
+    private toPoint;
+    /** O `data-testid` posto no hospedeiro vai para o painel renderizado no overlay (usado nos testes e2e). */
+    private forwardTestId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzPopoverComponent, "ui-popover", never, { "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "dismissable": { "alias": "dismissable"; "required": false; "isSignal": true; }; "autoZIndex": { "alias": "autoZIndex"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; }, { "shown": "shown"; "hidden": "hidden"; }, never, ["*"], true, never>;
+}
+
+type SmzDrawerPosition = 'left' | 'right' | 'top' | 'bottom' | 'full';
+/**
+ * Painel lateral deslizante. Substitui o `p-drawer` do PrimeNG.
+ *
+ * <ui-drawer [(visible)]="aberto" position="right" header="Filtros">conteudo</ui-drawer>
+ */
+declare class SmzDrawerComponent implements OnDestroy {
+    readonly visible: _angular_core.ModelSignal<boolean>;
+    readonly position: _angular_core.InputSignal<SmzDrawerPosition>;
+    readonly fullScreen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly header: _angular_core.InputSignal<string>;
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showCloseIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly style: _angular_core.InputSignal<Record<string, string | number>>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    /** Aceitos por compatibilidade com o `p-drawer`; sem efeito neste componente. */
+    readonly blockScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaCloseLabel: _angular_core.InputSignal<string>;
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    readonly shown: _angular_core.OutputEmitterRef<void>;
+    readonly hidden: _angular_core.OutputEmitterRef<void>;
+    private readonly panel;
+    private readonly templates;
+    protected readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly footerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly effectivePosition: _angular_core.Signal<SmzDrawerPosition>;
+    protected readonly panelClasses: _angular_core.Signal<string>;
+    private readonly overlay;
+    private readonly viewContainer;
+    private readonly host;
+    private overlayRef?;
+    constructor();
+    close(): void;
+    ngOnDestroy(): void;
+    private open;
+    private dispose;
+    /** O `data-testid` posto no hospedeiro vai para o painel renderizado no overlay (usado nos testes e2e). */
+    private forwardTestId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzDrawerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzDrawerComponent, "ui-drawer", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "fullScreen": { "alias": "fullScreen"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "showCloseIcon": { "alias": "showCloseIcon"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "blockScroll": { "alias": "blockScroll"; "required": false; "isSignal": true; }; "ariaCloseLabel": { "alias": "ariaCloseLabel"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; "shown": "shown"; "hidden": "hidden"; }, ["templates"], ["*"], true, never>;
+}
+
+interface SmzToastMessage {
+    /** success | info | warn | error | secondary | contrast (vocabulario antigo) */
+    severity?: string;
+    summary?: string;
+    detail?: string;
+    id?: unknown;
+    /** Permite ter varios containers `ui-toast`, cada um escutando uma chave. */
+    key?: string;
+    /** Tempo de vida em ms (padrao do container se omitido). */
+    life?: number;
+    sticky?: boolean;
+    closable?: boolean;
+    data?: unknown;
+    icon?: string;
+    contentStyleClass?: string;
+    styleClass?: string;
+    closeIcon?: string;
+    [extra: string]: unknown;
+}
+/** Barramento de mensagens do toast. Substitui o `MessageService` do PrimeNG. */
+declare class SmzMessageService {
+    private readonly state;
+    /** Mensagens atualmente na fila (todas as chaves). */
+    readonly messages: _angular_core.Signal<readonly SmzToastMessage[]>;
+    add(message: SmzToastMessage): void;
+    addAll(messages: SmzToastMessage[]): void;
+    remove(message: SmzToastMessage): void;
+    /** Remove todas as mensagens, ou so as da chave informada. */
+    clear(key?: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzMessageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SmzMessageService>;
+}
+
+type SmzToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'center';
+/**
+ * Container de toasts: exibe as mensagens do `SmzMessageService`. Substitui o `p-toast` do PrimeNG.
+ *
+ * <ui-toast position="bottom-right" />
+ */
+declare class SmzToastContainerComponent {
+    readonly position: _angular_core.InputSignal<SmzToastPosition>;
+    readonly key: _angular_core.InputSignal<string>;
+    readonly life: _angular_core.InputSignal<number>;
+    readonly style: _angular_core.InputSignal<Record<string, string | number>>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    private readonly service;
+    private readonly timers;
+    protected readonly positionClasses: _angular_core.Signal<string>;
+    protected readonly visibleMessages: _angular_core.Signal<SmzToastMessage[]>;
+    constructor();
+    protected toneClasses(message: SmzToastMessage): string;
+    protected close(message: SmzToastMessage): void;
+    protected pause(message: SmzToastMessage): void;
+    protected resume(message: SmzToastMessage): void;
+    private schedule;
+    private arm;
+    private clearTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzToastContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzToastContainerComponent, "ui-toast", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "key": { "alias": "key"; "required": false; "isSignal": true; }; "life": { "alias": "life"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Menu de itens, inline ou em popup ancorado. Substitui o `p-menu` do PrimeNG.
+ *
+ * <button smzButton (click)="menu.toggle($event)"></button>
+ * <ui-menu #menu [model]="itens" [popup]="true" />
+ */
+declare class SmzMenuListComponent implements OnDestroy {
+    readonly model: _angular_core.InputSignal<SmzUiMenuItem[]>;
+    readonly popup: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly style: _angular_core.InputSignal<Record<string, string | number>>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly autoZIndex: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Aceitos por compatibilidade com o `p-menu`; sem efeito neste componente. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    readonly baseZIndex: _angular_core.InputSignal<number>;
+    readonly shown: _angular_core.OutputEmitterRef<void>;
+    readonly hidden: _angular_core.OutputEmitterRef<void>;
+    private readonly list;
+    private readonly overlay;
+    private readonly viewContainer;
+    private readonly host;
+    private overlayRef?;
+    private origin?;
+    get visible(): boolean;
+    toggle(event: Event | null): void;
+    /** Abre o popup ancorado ao elemento do evento. */
+    show(event: Event | null, target?: Element): void;
+    /** Abre o popup nas coordenadas da tela (uso tipico: menu de contexto). */
+    showAt(x: number, y: number): void;
+    hide(): void;
+    ngOnDestroy(): void;
+    protected activate(item: SmzUiMenuItem, event: Event): void;
+    private open;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzMenuListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzMenuListComponent, "ui-menu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "popup": { "alias": "popup"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "autoZIndex": { "alias": "autoZIndex"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "baseZIndex": { "alias": "baseZIndex"; "required": false; "isSignal": true; }; }, { "shown": "shown"; "hidden": "hidden"; }, never, never, true, never>;
+}
+
+/** Alvo que sabe qual elemento deve ser bloqueado (equivale ao `BlockableUI` do PrimeNG). */
+interface SmzBlockableUi {
+    getBlockableElement(): HTMLElement;
+}
+type SmzBlockTarget = HTMLElement | SmzBlockableUi | null | undefined;
+/**
+ * Bloqueia a interacao com um elemento exibindo uma mascara por cima dele. Substitui o `p-blockUI` do PrimeNG.
+ * Sem `target`, bloqueia o proprio pai do componente.
+ *
+ * <ui-block-ui [target]="elemento" [blocked]="carregando"><i class="fa-solid fa-lock"></i></ui-block-ui>
+ */
+declare class SmzBlockUiComponent implements OnDestroy {
+    readonly target: _angular_core.InputSignal<unknown>;
+    readonly blocked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly mask;
+    private readonly host;
+    private attachedTo;
+    private previousPosition;
+    constructor();
+    ngOnDestroy(): void;
+    private block;
+    private unblock;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzBlockUiComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzBlockUiComponent, "ui-block-ui", never, { "target": { "alias": "target"; "required": false; "isSignal": true; }; "blocked": { "alias": "blocked"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Barra de ferramentas simples (conteudo projetado). Substitui o `p-toolbar` do PrimeNG. */
+declare class SmzToolbarComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzToolbarComponent, "ui-toolbar", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface SmzAnchoredPanelOptions {
+    /** O painel tem pelo menos a largura da ancora. */
+    matchWidth?: boolean;
+    /** Fecha ao clicar fora (padrao: true). */
+    closeOnOutsideClick?: boolean;
+    /** Chamado quando o painel e fechado por clique fora ou Escape. */
+    onDismiss?: () => void;
+}
+/**
+ * Painel suspenso ancorado a um elemento (CDK Overlay): base dos selects, datepicker, autocomplete etc.
+ * Fecha com Escape ou clique fora (exceto na propria ancora).
+ */
+declare class SmzAnchoredPanel {
+    private readonly overlay;
+    private readonly viewContainer;
+    private overlayRef?;
+    private subscription?;
+    constructor(overlay: Overlay, viewContainer: ViewContainerRef);
+    get isOpen(): boolean;
+    /** Elemento raiz do painel renderizado (para foco e medidas). */
+    get element(): HTMLElement | null;
+    open(anchor: HTMLElement, template: TemplateRef<unknown>, options?: SmzAnchoredPanelOptions): void;
+    close(): void;
+    updatePosition(): void;
+}
+
+type SmzFilterMode = 'contains' | 'startsWith' | 'endsWith' | 'equals' | 'notContains' | 'notEquals' | string;
+/** Configuracao de como ler label/valor de uma opcao (usada por select, multiselect, listbox, selectbutton, autocomplete). */
+interface SmzOptionConfig {
+    optionLabel?: string | null;
+    optionValue?: string | null;
+    optionDisabled?: string | null;
+    dataKey?: string | null;
+}
+/**
+ * Texto da opcao. Sem `optionLabel`, opcoes-objeto com `label` usam esse campo (como o `p-select` do PrimeNG);
+ * primitivos sao usados como estao.
+ */
+declare function optionLabel(option: any, config: SmzOptionConfig): string;
+/**
+ * Valor da opcao. Sem `optionValue` (e sem `optionLabel`), opcoes-objeto com `value` usam esse campo
+ * (como o `p-select` do PrimeNG); caso contrario o proprio objeto e o valor.
+ */
+declare function optionValue(option: any, config: SmzOptionConfig): any;
+declare function optionDisabled(option: any, config: SmzOptionConfig): boolean;
+/** Igualdade de valores: por `dataKey` quando ha, senao comparacao profunda. */
+declare function sameValue(first: any, second: any, dataKey?: string | null): boolean;
+/** Filtra `options` por texto digitado, no modo informado (padrao: contains), ignorando acentos e caixa. */
+declare function filterOptions<T>(options: readonly T[], text: string, config: SmzOptionConfig & {
+    filterBy?: string | null;
+    mode?: SmzFilterMode;
+}): T[];
+
+interface SmzSelectChangeEvent {
+    originalEvent?: Event;
+    value: any;
+}
+/**
+ * Lista suspensa de selecao unica. Substitui o `p-select` do PrimeNG.
+ *
+ * <ui-select [options]="paises" optionLabel="name" dataKey="id" [formControl]="pais" [filter]="true" />
+ *
+ * Sem `optionValue` o valor do controle e o proprio objeto da opcao.
+ */
+declare class SmzSelectComponent extends SmzValueAccessor<any> implements OnDestroy {
+    readonly options: _angular_core.InputSignal<readonly any[]>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<string>;
+    readonly optionDisabled: _angular_core.InputSignal<string>;
+    readonly dataKey: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filterBy: _angular_core.InputSignal<string>;
+    readonly filterMatchMode: _angular_core.InputSignal<string>;
+    readonly filterPlaceholder: _angular_core.InputSignal<string>;
+    readonly showClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly emptyFilterMessage: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Aceito por compatibilidade com o `p-select`; o painel sempre e anexado ao body pelo CDK. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    readonly changed: _angular_core.OutputEmitterRef<SmzSelectChangeEvent>;
+    readonly showed: _angular_core.OutputEmitterRef<void>;
+    readonly hidden: _angular_core.OutputEmitterRef<void>;
+    protected readonly listId: string;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly filterText: _angular_core.WritableSignal<string>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly config: _angular_core.Signal<SmzOptionConfig>;
+    protected readonly visibleOptions: _angular_core.Signal<any[]>;
+    /** Templates opcionais: `item` (linha da lista) e `selectedItem` (valor exibido no campo), como no `p-select`. */
+    private readonly templates;
+    protected readonly itemTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly selectedItemTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly hasValue: _angular_core.Signal<boolean>;
+    protected readonly selectedOption: _angular_core.Signal<any>;
+    protected readonly displayLabel: _angular_core.Signal<string>;
+    private readonly overlay;
+    private readonly viewContainer;
+    private readonly trigger;
+    private readonly panel;
+    private readonly filterInput;
+    private readonly anchored;
+    ngOnDestroy(): void;
+    protected labelOf(option: any): string;
+    protected isOptionDisabled(option: any): boolean;
+    protected isSelected(option: any): boolean;
+    protected optionClasses(option: any, index: number): string;
+    protected toggle(): void;
+    protected onBlur(): void;
+    protected select(option: any, event?: Event): void;
+    protected clear(event: Event): void;
+    protected onFilter(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private openPanel;
+    private close;
+    private afterClose;
+    private nextEnabled;
+    private jumpToLetter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzSelectComponent, "ui-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; "isSignal": true; }; "dataKey": { "alias": "dataKey"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterBy": { "alias": "filterBy"; "required": false; "isSignal": true; }; "filterMatchMode": { "alias": "filterMatchMode"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "emptyFilterMessage": { "alias": "emptyFilterMessage"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "showed": "showed"; "hidden": "hidden"; }, ["templates"], never, true, never>;
+}
+
+interface SmzMultiSelectChangeEvent {
+    originalEvent?: Event;
+    value: any[];
+    itemValue?: any;
+}
+/**
+ * Lista suspensa de selecao multipla. Substitui o `p-multiselect` do PrimeNG.
+ *
+ * <ui-multi-select [options]="itens" optionLabel="name" dataKey="id" [formControl]="selecionados" />
+ */
+declare class SmzMultiSelectComponent extends SmzValueAccessor<any[]> implements OnDestroy {
+    readonly options: _angular_core.InputSignal<readonly any[]>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<string>;
+    readonly optionDisabled: _angular_core.InputSignal<string>;
+    readonly dataKey: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filterBy: _angular_core.InputSignal<string>;
+    readonly filterMatchMode: _angular_core.InputSignal<string>;
+    readonly filterPlaceholder: _angular_core.InputSignal<string>;
+    readonly showClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showToggleAll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly emptyFilterMessage: _angular_core.InputSignal<string>;
+    readonly maxSelectedLabels: _angular_core.InputSignal<number>;
+    /** Texto quando ha mais itens que `maxSelectedLabels`; `{0}` vira a quantidade. */
+    readonly selectedItemsLabel: _angular_core.InputSignal<string>;
+    readonly panelStyle: _angular_core.InputSignal<Record<string, string | number>>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly autofocusFilter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Aceitos por compatibilidade com o `p-multiselect`; sem efeito. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    readonly display: _angular_core.InputSignal<string>;
+    readonly changed: _angular_core.OutputEmitterRef<SmzMultiSelectChangeEvent>;
+    readonly panelHide: _angular_core.OutputEmitterRef<void>;
+    readonly panelShow: _angular_core.OutputEmitterRef<void>;
+    protected readonly listId: string;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly filterText: _angular_core.WritableSignal<string>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly config: _angular_core.Signal<SmzOptionConfig>;
+    protected readonly visibleOptions: _angular_core.Signal<any[]>;
+    /** Templates opcionais: `item` (linha da lista) e `selectedItems` (valor exibido no campo; `$implicit` = valores selecionados), como no `p-multiselect`. */
+    private readonly templates;
+    protected readonly itemTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly selectedItemsTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly selectedValues: _angular_core.Signal<any[]>;
+    protected readonly selectedOptions: _angular_core.Signal<any[]>;
+    protected readonly allSelected: _angular_core.Signal<boolean>;
+    protected readonly displayLabel: _angular_core.Signal<string>;
+    private readonly overlay;
+    private readonly viewContainer;
+    private readonly trigger;
+    private readonly panel;
+    private readonly filterInput;
+    private readonly anchored;
+    ngOnDestroy(): void;
+    protected labelOf(option: any): string;
+    protected isSelected(option: any): boolean;
+    protected optionRowClass(option: any, index: number): string;
+    protected toggle(): void;
+    protected onBlur(): void;
+    protected toggleOption(option: any, event: Event): void;
+    protected toggleAll(event: Event): void;
+    protected clear(event: Event): void;
+    protected onFilter(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private openPanel;
+    private close;
+    private afterClose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzMultiSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzMultiSelectComponent, "ui-multi-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; "isSignal": true; }; "dataKey": { "alias": "dataKey"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterBy": { "alias": "filterBy"; "required": false; "isSignal": true; }; "filterMatchMode": { "alias": "filterMatchMode"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "showToggleAll": { "alias": "showToggleAll"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "emptyFilterMessage": { "alias": "emptyFilterMessage"; "required": false; "isSignal": true; }; "maxSelectedLabels": { "alias": "maxSelectedLabels"; "required": false; "isSignal": true; }; "selectedItemsLabel": { "alias": "selectedItemsLabel"; "required": false; "isSignal": true; }; "panelStyle": { "alias": "panelStyle"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "autofocusFilter": { "alias": "autofocusFilter"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "panelHide": "panelHide"; "panelShow": "panelShow"; }, ["templates"], never, true, never>;
+}
+
+interface SmzSelectButtonChangeEvent {
+    originalEvent?: Event;
+    value: any;
+}
+/**
+ * Grupo de botoes de selecao unica ou multipla. Substitui o `p-selectbutton` do PrimeNG.
+ *
+ * <ui-select-button [options]="tipos" optionLabel="label" optionValue="value" [(ngModel)]="tipo" />
+ */
+declare class SmzSelectButtonComponent extends SmzValueAccessor<any> {
+    readonly options: _angular_core.InputSignal<readonly any[]>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<string>;
+    readonly optionDisabled: _angular_core.InputSignal<string>;
+    readonly dataKey: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly allowEmpty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<"small" | "large">;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    /** Aceito por compatibilidade com o `p-selectbutton`; sem efeito. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    readonly changed: _angular_core.OutputEmitterRef<SmzSelectButtonChangeEvent>;
+    /** Sem `optionLabel`/`optionValue`, opcoes-objeto com `label`/`value` sao lidas automaticamente (como no PrimeNG). */
+    private readonly sample;
+    protected readonly config: _angular_core.Signal<SmzOptionConfig>;
+    protected labelOf(option: any): string;
+    protected iconOf(option: any): string | null;
+    protected isOptionDisabled(option: any): boolean;
+    protected isSelected(option: any): boolean;
+    protected buttonClasses(option: any): string;
+    protected toggle(option: any, event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzSelectButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzSelectButtonComponent, "ui-select-button", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; "isSignal": true; }; "dataKey": { "alias": "dataKey"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+interface SmzListboxClickEvent {
+    originalEvent: Event;
+    option: any;
+    value: any;
+}
+interface SmzListboxChangeEvent {
+    originalEvent?: Event;
+    value: any;
+}
+/**
+ * Lista de selecao (unica ou multipla) sempre visivel. Substitui o `p-listbox` do PrimeNG.
+ * Aceita os templates `header`, `item`, `footer` e `empty` via `smzTemplate`.
+ *
+ * <ui-listbox [options]="itens" optionLabel="name" dataKey="id" [(ngModel)]="selecionado">
+ *   <ng-template smzTemplate="item" let-item>{{ item.name }}</ng-template>
+ * </ui-listbox>
+ */
+declare class SmzListboxComponent extends SmzValueAccessor<any> {
+    readonly options: _angular_core.InputSignal<readonly any[]>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<string>;
+    readonly optionDisabled: _angular_core.InputSignal<string>;
+    readonly dataKey: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly checkbox: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filterBy: _angular_core.InputSignal<string>;
+    readonly filterMatchMode: _angular_core.InputSignal<string>;
+    /** Aceito por compatibilidade com o `p-listbox`; selecao multipla sempre alterna por clique. */
+    readonly metaKeySelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly emptyFilterMessage: _angular_core.InputSignal<string>;
+    readonly listStyle: _angular_core.InputSignal<Record<string, string | number>>;
+    readonly style: _angular_core.InputSignal<Record<string, string | number>>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly changed: _angular_core.OutputEmitterRef<SmzListboxChangeEvent>;
+    readonly clicked: _angular_core.OutputEmitterRef<SmzListboxClickEvent>;
+    /** Elemento hospedeiro (compatibilidade com `Listbox.el` do PrimeNG). */
+    readonly el: ElementRef<HTMLElement>;
+    protected readonly filterText: _angular_core.WritableSignal<string>;
+    private readonly templates;
+    protected readonly headerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly itemTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly footerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly emptyTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly config: _angular_core.Signal<SmzOptionConfig>;
+    protected readonly visibleOptions: _angular_core.Signal<any[]>;
+    protected labelOf(option: any): string;
+    protected isSelected(option: any): boolean;
+    protected rowClass(option: any): string;
+    protected onFilter(event: Event): void;
+    protected onItemClick(option: any, event: Event): void;
+    protected focusSibling(event: Event, step: 1 | -1): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzListboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzListboxComponent, "ui-listbox", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; "isSignal": true; }; "dataKey": { "alias": "dataKey"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "checkbox": { "alias": "checkbox"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterBy": { "alias": "filterBy"; "required": false; "isSignal": true; }; "filterMatchMode": { "alias": "filterMatchMode"; "required": false; "isSignal": true; }; "metaKeySelection": { "alias": "metaKeySelection"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "emptyFilterMessage": { "alias": "emptyFilterMessage"; "required": false; "isSignal": true; }; "listStyle": { "alias": "listStyle"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "clicked": "clicked"; }, ["templates"], never, true, never>;
+}
+
+/** Campo com icone sobreposto ao input. Substitui o `p-iconfield` do PrimeNG. */
+declare class SmzIconFieldComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzIconFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzIconFieldComponent, "ui-icon-field", never, {}, {}, never, ["*"], true, never>;
+}
+/** Icone dentro de um `ui-icon-field`. Substitui o `p-inputicon` do PrimeNG. */
+declare class SmzInputIconComponent {
+    readonly styleClass: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzInputIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzInputIconComponent, "ui-input-icon", never, { "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** Agrupa input e complementos lado a lado. Substitui o `p-inputgroup` do PrimeNG. */
+declare class SmzInputGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzInputGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzInputGroupComponent, "ui-input-group", never, {}, {}, never, ["*"], true, never>;
+}
+/** Complemento de um `ui-input-group`. Substitui o `p-inputgroupaddon` do PrimeNG. */
+declare class SmzInputGroupAddonComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzInputGroupAddonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzInputGroupAddonComponent, "ui-input-group-addon", never, {}, {}, never, ["*"], true, never>;
+}
+
+/** Textos e calendario localizados usados pelos componentes do kit. Mesmas chaves do `Translation` do PrimeNG. */
+interface SmzTranslation {
+    startsWith?: string;
+    contains?: string;
+    notContains?: string;
+    endsWith?: string;
+    equals?: string;
+    notEquals?: string;
+    noFilter?: string;
+    lt?: string;
+    lte?: string;
+    gt?: string;
+    gte?: string;
+    is?: string;
+    isNot?: string;
+    before?: string;
+    after?: string;
+    dateIs?: string;
+    dateIsNot?: string;
+    dateBefore?: string;
+    dateAfter?: string;
+    clear?: string;
+    apply?: string;
+    matchAll?: string;
+    matchAny?: string;
+    addRule?: string;
+    removeRule?: string;
+    accept?: string;
+    reject?: string;
+    choose?: string;
+    upload?: string;
+    cancel?: string;
+    close?: string;
+    pending?: string;
+    dayNames?: string[];
+    dayNamesShort?: string[];
+    dayNamesMin?: string[];
+    monthNames?: string[];
+    monthNamesShort?: string[];
+    chooseYear?: string;
+    chooseMonth?: string;
+    chooseDate?: string;
+    prevDecade?: string;
+    nextDecade?: string;
+    prevYear?: string;
+    nextYear?: string;
+    prevMonth?: string;
+    nextMonth?: string;
+    am?: string;
+    pm?: string;
+    today?: string;
+    weekHeader?: string;
+    firstDayOfWeek?: number;
+    showMonthAfterYear?: boolean;
+    dateFormat?: string;
+    weak?: string;
+    medium?: string;
+    strong?: string;
+    passwordPrompt?: string;
+    emptyMessage?: string;
+    emptyFilterMessage?: string;
+    [key: string]: any;
+}
+/** Chaves de traducao usadas pelos componentes (mesmos valores do `TranslationKeys` do PrimeNG). */
+declare const SmzTranslationKeys: {
+    readonly STARTS_WITH: "startsWith";
+    readonly CONTAINS: "contains";
+    readonly NOT_CONTAINS: "notContains";
+    readonly ENDS_WITH: "endsWith";
+    readonly EQUALS: "equals";
+    readonly NOT_EQUALS: "notEquals";
+    readonly NO_FILTER: "noFilter";
+    readonly LT: "lt";
+    readonly LTE: "lte";
+    readonly GT: "gt";
+    readonly GTE: "gte";
+    readonly IS: "is";
+    readonly IS_NOT: "isNot";
+    readonly BEFORE: "before";
+    readonly AFTER: "after";
+    readonly CLEAR: "clear";
+    readonly APPLY: "apply";
+    readonly MATCH_ALL: "matchAll";
+    readonly MATCH_ANY: "matchAny";
+    readonly ADD_RULE: "addRule";
+    readonly REMOVE_RULE: "removeRule";
+    readonly ACCEPT: "accept";
+    readonly REJECT: "reject";
+    readonly CHOOSE: "choose";
+    readonly UPLOAD: "upload";
+    readonly CANCEL: "cancel";
+    readonly PENDING: "pending";
+    readonly EMPTY_MESSAGE: "emptyMessage";
+    readonly EMPTY_FILTER_MESSAGE: "emptyFilterMessage";
+};
+/**
+ * Textos e nomes de calendario dos componentes do kit. O app (ou a core) chama `setTranslation` com o locale ativo.
+ * Substitui `PrimeNG.setTranslation` / `getTranslation`.
+ */
+declare class SmzLocaleService {
+    private readonly state;
+    /** Traducao atual (signal: componentes reagem a mudancas de idioma). */
+    readonly translation: _angular_core.Signal<SmzTranslation>;
+    /** Emite quando a traducao muda (para componentes que guardam rotulos em cache). */
+    readonly translationObserver: Subject<SmzTranslation>;
+    /** Modos de filtro oferecidos por tipo de coluna (`text`, `numeric`, `date`). */
+    filterMatchModeOptions: Record<string, string[]>;
+    setTranslation(translation: SmzTranslation | null | undefined): void;
+    getTranslation<T = string>(key: string): T;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzLocaleService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SmzLocaleService>;
+}
+
+interface SmzInputNumberInputEvent {
+    originalEvent: Event;
+    value: number | null;
+    formattedValue: string;
+}
+/**
+ * Campo numerico com formatacao por locale (decimal ou moeda). Substitui o `p-inputnumber` do PrimeNG.
+ *
+ * <ui-input-number [formControl]="preco" mode="currency" currency="BRL" locale="pt-BR" />
+ *
+ * O texto e reformatado ao sair do campo; enquanto digita, o valor numerico ja e propagado ao formulario.
+ */
+declare class SmzInputNumberComponent extends SmzValueAccessor<number> {
+    readonly mode: _angular_core.InputSignal<string>;
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly localeMatcher: _angular_core.InputSignal<string>;
+    readonly currency: _angular_core.InputSignal<string>;
+    readonly currencyDisplay: _angular_core.InputSignal<string>;
+    readonly useGrouping: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly minFractionDigits: _angular_core.InputSignal<number>;
+    readonly maxFractionDigits: _angular_core.InputSignal<number>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly prefix: _angular_core.InputSignal<string>;
+    readonly suffix: _angular_core.InputSignal<string>;
+    readonly showButtons: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly allowEmpty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly inputed: _angular_core.OutputEmitterRef<SmzInputNumberInputEvent>;
+    readonly keyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly blurred: _angular_core.OutputEmitterRef<Event>;
+    readonly focused: _angular_core.OutputEmitterRef<void>;
+    private readonly field;
+    private readonly editing;
+    private readonly typed;
+    private readonly formatter;
+    private readonly decimalSeparator;
+    protected readonly text: _angular_core.Signal<string>;
+    writeValue(value: number | null): void;
+    protected onFocus(): void;
+    protected onInput(event: Event): void;
+    protected onBlur(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected spin(direction: 1 | -1): void;
+    protected clear(): void;
+    private format;
+    /** Texto editavel: numero sem prefixo/sufixo/agrupamento, com o separador decimal do locale. */
+    private rawText;
+    private sanitize;
+    private parse;
+    private round;
+    private clamp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzInputNumberComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzInputNumberComponent, "ui-input-number", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "localeMatcher": { "alias": "localeMatcher"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "currencyDisplay": { "alias": "currencyDisplay"; "required": false; "isSignal": true; }; "useGrouping": { "alias": "useGrouping"; "required": false; "isSignal": true; }; "minFractionDigits": { "alias": "minFractionDigits"; "required": false; "isSignal": true; }; "maxFractionDigits": { "alias": "maxFractionDigits"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; }, { "inputed": "inputed"; "keyDown": "keyDown"; "blurred": "blurred"; "focused": "focused"; }, never, never, true, never>;
+}
+
+/** Formata uma data (so a parte de data) no formato estilo jQuery UI: d, dd, o, oo, D, DD, m, mm, M, MM, y, yy, @, !. */
+declare function smzFormatDate(date: Date, format: string, translation: SmzTranslation): string;
+/** Interpreta um texto de data no formato dado; retorna `null` quando nao bate ou a data nao existe. */
+declare function smzParseDate(text: string, format: string, translation: SmzTranslation): Date | null;
+declare const smzSameDay: (first: Date | null | undefined, second: Date | null | undefined) => boolean;
+declare const smzStartOfDay: (date: Date) => Date;
+declare const smzTwoDigits: (value: number, length?: number) => string;
+/** Primeiro dia exibido na grade do mes: volta ate o `firstDayOfWeek`. */
+declare function smzCalendarStart(year: number, month: number, firstDayOfWeek: number): Date;
+
+type SmzDatePickerValue = Date | Date[] | null;
+type SmzDateSelectionMode = 'single' | 'multiple' | 'range';
+type View = 'date' | 'month' | 'year';
+interface DayCell {
+    date: Date;
+    label: number;
+    inMonth: boolean;
+    today: boolean;
+    disabled: boolean;
+}
+/**
+ * Seletor de data (e hora). Substitui o `p-datepicker` do PrimeNG.
+ *
+ * <ui-date-picker [formControl]="data" dateFormat="dd/mm/yy" [showTime]="true" />
+ *
+ * Formato de texto no estilo jQuery UI (`dd/mm/yy`, `MM d, yy`...). Os nomes de mes e dia vem do `SmzLocaleService`.
+ */
+declare class SmzDatePickerComponent extends SmzValueAccessor<SmzDatePickerValue> implements OnDestroy {
+    readonly selectionMode: _angular_core.InputSignal<SmzDateSelectionMode>;
+    readonly dateFormat: _angular_core.InputSignal<string>;
+    readonly showTime: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly timeOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showSeconds: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hourFormat: _angular_core.InputSignal<"12" | "24">;
+    readonly minDate: _angular_core.InputSignal<Date>;
+    readonly maxDate: _angular_core.InputSignal<Date>;
+    readonly showButtonBar: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showOnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly keepInvalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    /** Aceitos por compatibilidade com o `p-datepicker`; sem efeito. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    readonly touchUI: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly focusTrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selected: _angular_core.OutputEmitterRef<Date>;
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly blurred: _angular_core.OutputEmitterRef<Event>;
+    private readonly locale;
+    protected readonly translation: _angular_core.Signal<_ngx_smz_ui_kit.SmzTranslation>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly view: _angular_core.WritableSignal<View>;
+    private readonly viewDate;
+    private readonly typed;
+    protected readonly hour: _angular_core.WritableSignal<number>;
+    protected readonly minute: _angular_core.WritableSignal<number>;
+    protected readonly second: _angular_core.WritableSignal<number>;
+    protected readonly viewYear: _angular_core.Signal<number>;
+    protected readonly viewMonth: _angular_core.Signal<number>;
+    protected readonly decadeStart: _angular_core.Signal<number>;
+    protected readonly decadeYears: _angular_core.Signal<number[]>;
+    protected readonly monthName: _angular_core.Signal<string>;
+    protected readonly monthNamesShort: _angular_core.Signal<string[]>;
+    protected readonly effectiveFormat: _angular_core.Signal<string>;
+    protected readonly weekdayNames: _angular_core.Signal<string[]>;
+    protected readonly cells: _angular_core.Signal<DayCell[]>;
+    protected readonly displayHour: _angular_core.Signal<string>;
+    protected readonly text: _angular_core.Signal<string>;
+    private readonly overlay;
+    private readonly viewContainer;
+    private readonly anchorRef;
+    private readonly fieldRef;
+    private readonly panel;
+    private readonly anchored;
+    /**
+     * Aceita `Date`, string (ISO ou parseavel) e numero (timestamp), como o `p-datepicker`.
+     * Valores invalidos viram `null` em vez de lancar. O modelo do formulario so muda quando o usuario escolhe uma data.
+     */
+    writeValue(value: SmzDatePickerValue | string | number): void;
+    ngOnDestroy(): void;
+    protected twoDigits(value: number): string;
+    protected toggle(): void;
+    protected onFocus(): void;
+    protected onFieldClick(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onTyping(event: Event): void;
+    protected onBlur(event: Event): void;
+    protected shift(direction: -1 | 1): void;
+    protected pickMonth(month: number): void;
+    protected pickYear(year: number): void;
+    protected isSelected(date: Date): boolean;
+    protected isInRange(date: Date): boolean;
+    protected dayClasses(cell: DayCell): string;
+    protected pickDay(cell: DayCell): void;
+    protected goToday(): void;
+    protected clearValue(): void;
+    protected stepTime(unit: 'h' | 'm' | 's', delta: number): void;
+    private openPanel;
+    private close;
+    private afterClose;
+    private syncViewTo;
+    private withTime;
+    private isOutOfRange;
+    private formatSingle;
+    private formatValue;
+    private parseSingle;
+    /** Interpreta o texto digitado; se invalido, descarta (ou mantem, com `keepInvalid`). */
+    private commitTyped;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzDatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzDatePickerComponent, "ui-date-picker", never, { "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "showTime": { "alias": "showTime"; "required": false; "isSignal": true; }; "timeOnly": { "alias": "timeOnly"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "hourFormat": { "alias": "hourFormat"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "showButtonBar": { "alias": "showButtonBar"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "showOnFocus": { "alias": "showOnFocus"; "required": false; "isSignal": true; }; "keepInvalid": { "alias": "keepInvalid"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonlyInput"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "touchUI": { "alias": "touchUI"; "required": false; "isSignal": true; }; "focusTrap": { "alias": "focusTrap"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "cleared": "cleared"; "opened": "opened"; "closed": "closed"; "blurred": "blurred"; }, never, never, true, never>;
+}
+
+interface SmzAutoCompleteCompleteEvent {
+    originalEvent?: Event;
+    query: string;
+}
+interface SmzAutoCompleteSelectEvent {
+    originalEvent?: Event;
+    value: any;
+}
+/**
+ * Campo de texto com sugestoes. Substitui o `p-autocomplete` do PrimeNG.
+ * O componente nao busca: ao digitar emite `completeMethod` e o consumidor atualiza `suggestions`.
+ *
+ * <ui-auto-complete [(ngModel)]="texto" [suggestions]="sugestoes" (completeMethod)="buscar($event)" [dropdown]="true" />
+ */
+declare class SmzAutoCompleteComponent extends SmzValueAccessor<any> implements OnDestroy {
+    readonly suggestions: _angular_core.InputSignal<readonly any[]>;
+    readonly field: _angular_core.InputSignal<string>;
+    readonly dropdown: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly minLength: _angular_core.InputSignal<number>;
+    readonly delay: _angular_core.InputSignal<number>;
+    readonly forceSelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    /** Aceito por compatibilidade com o `p-autocomplete`; sem efeito. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    readonly completeMethod: _angular_core.OutputEmitterRef<SmzAutoCompleteCompleteEvent>;
+    readonly selectedItem: _angular_core.OutputEmitterRef<SmzAutoCompleteSelectEvent>;
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    readonly blurred: _angular_core.OutputEmitterRef<Event>;
+    readonly focused: _angular_core.OutputEmitterRef<void>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    private readonly typed;
+    private searching;
+    private timer?;
+    private readonly templates;
+    protected readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly itemTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly text: _angular_core.Signal<string>;
+    private readonly overlay;
+    private readonly viewContainer;
+    private readonly anchorRef;
+    private readonly fieldRef;
+    private readonly panel;
+    private readonly anchored;
+    constructor();
+    writeValue(value: any): void;
+    ngOnDestroy(): void;
+    protected labelOf(item: any): string;
+    protected onInput(event: Event): void;
+    protected onBlur(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected select(item: any, event: Event): void;
+    protected clear(): void;
+    protected toggleDropdown(): void;
+    private scheduleSearch;
+    private triggerSearch;
+    private openPanel;
+    private closePanel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzAutoCompleteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzAutoCompleteComponent, "ui-auto-complete", never, { "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "dropdown": { "alias": "dropdown"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "forceSelection": { "alias": "forceSelection"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; }, { "completeMethod": "completeMethod"; "selectedItem": "selectedItem"; "cleared": "cleared"; "blurred": "blurred"; "focused": "focused"; }, ["templates"], never, true, never>;
+}
+
+interface MaskSlot {
+    /** Posicao do caractere dentro do texto formatado. */
+    position: number;
+    test: RegExp;
+}
+interface ParsedMask {
+    /** Caractere literal por posicao (`null` onde ha slot). */
+    literals: Array<string | null>;
+    slots: MaskSlot[];
+    /** Quantidade de slots obrigatorios (os demais, depois de `?`, sao opcionais). */
+    required: number;
+}
+/**
+ * Campo com mascara de entrada. Substitui o `p-inputmask` do PrimeNG.
+ * Na mascara: `9` = digito, `a` = letra (ou `characterPattern`), `*` = letra ou digito; demais caracteres sao literais.
+ *
+ * <ui-input-mask mask="(99) 99999-9999" [formControl]="telefone" [unmask]="true" />
+ */
+declare class SmzInputMaskComponent extends SmzValueAccessor<string> {
+    readonly mask: _angular_core.InputSignal<string>;
+    readonly slotChar: _angular_core.InputSignal<string>;
+    readonly characterPattern: _angular_core.InputSignal<string>;
+    readonly unmask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly autoClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    /** Tipo do `<input>` nativo (`text`, `tel`, `password`...). */
+    readonly type: _angular_core.InputSignal<string>;
+    readonly inputed: _angular_core.OutputEmitterRef<Event>;
+    readonly blurred: _angular_core.OutputEmitterRef<Event>;
+    readonly completed: _angular_core.OutputEmitterRef<void>;
+    private readonly field;
+    /** Caracteres dos slots preenchidos, em ordem. */
+    private readonly entered;
+    private readonly focusedState;
+    protected readonly parsed: _angular_core.Signal<ParsedMask>;
+    protected readonly display: _angular_core.Signal<string>;
+    writeValue(value: string | null): void;
+    protected onFocus(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    /**
+     * Sem `maxlength` no `<input>`: numa mascara fixa o texto exibido ja tem o tamanho maximo (ex.: "5__.___.___-__"),
+     * e o navegador bloquearia a insercao de qualquer caractere novo. `fitToSlots` descarta o que nao cabe.
+     */
+    protected onInput(event: Event): void;
+    protected onBlur(event: Event): void;
+    /** Redistribui os caracteres de `text` nos slots, descartando o que nao cabe ou nao combina. */
+    private fitToSlots;
+    private apply;
+    private moveCaret;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzInputMaskComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzInputMaskComponent, "ui-input-mask", never, { "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "slotChar": { "alias": "slotChar"; "required": false; "isSignal": true; }; "characterPattern": { "alias": "characterPattern"; "required": false; "isSignal": true; }; "unmask": { "alias": "unmask"; "required": false; "isSignal": true; }; "autoClear": { "alias": "autoClear"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "inputed": "inputed"; "blurred": "blurred"; "completed": "completed"; }, never, never, true, never>;
+}
+
+/**
+ * Campo de senha com alternancia de visibilidade e medidor de forca. Substitui o `p-password` do PrimeNG.
+ *
+ * <ui-password [formControl]="senha" [toggleMask]="true" [feedback]="true" />
+ */
+declare class SmzPasswordComponent extends SmzValueAccessor<string> {
+    readonly toggleMask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly feedback: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly promptLabel: _angular_core.InputSignal<string>;
+    readonly weakLabel: _angular_core.InputSignal<string>;
+    readonly mediumLabel: _angular_core.InputSignal<string>;
+    readonly strongLabel: _angular_core.InputSignal<string>;
+    readonly mediumRegex: _angular_core.InputSignal<string>;
+    readonly strongRegex: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    private readonly locale;
+    protected readonly visible: _angular_core.WritableSignal<boolean>;
+    private readonly strength;
+    protected readonly meterWidth: _angular_core.Signal<number>;
+    protected readonly meterClass: _angular_core.Signal<string>;
+    protected readonly meterLabel: _angular_core.Signal<string>;
+    protected onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzPasswordComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzPasswordComponent, "ui-password", never, { "toggleMask": { "alias": "toggleMask"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; "promptLabel": { "alias": "promptLabel"; "required": false; "isSignal": true; }; "weakLabel": { "alias": "weakLabel"; "required": false; "isSignal": true; }; "mediumLabel": { "alias": "mediumLabel"; "required": false; "isSignal": true; }; "strongLabel": { "alias": "strongLabel"; "required": false; "isSignal": true; }; "mediumRegex": { "alias": "mediumRegex"; "required": false; "isSignal": true; }; "strongRegex": { "alias": "strongRegex"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Seletor de cor (amostra com o seletor nativo do navegador). Substitui o `p-colorpicker` do PrimeNG.
+ * O valor e a cor em hexadecimal **sem** o `#` (mesmo formato do PrimeNG), por exemplo `ff0000`.
+ *
+ * <ui-color-picker [formControl]="cor" />
+ */
+declare class SmzColorPickerComponent extends SmzValueAccessor<string> {
+    readonly inputId: _angular_core.InputSignal<string>;
+    /** Aceito por compatibilidade com o `p-colorpicker`; sem efeito. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    /** Emitido quando o usuario escolhe uma cor (equivale ao `onChange` do `p-colorpicker`). */
+    readonly changed: _angular_core.OutputEmitterRef<{
+        originalEvent: Event;
+        value: string;
+    }>;
+    protected readonly hex: _angular_core.Signal<string>;
+    protected onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzColorPickerComponent, "ui-color-picker", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+/** Item simples de selecao (`label` + `value`). Substitui o `SelectItem` do PrimeNG. */
+interface SmzSelectItem<T = any> {
+    label?: string;
+    value: T;
+    title?: string;
+    icon?: string;
+    disabled?: boolean;
+}
+/** Criterio de ordenacao por campo. Substitui o `SortMeta` do PrimeNG. */
+interface SmzSortMeta {
+    field: string;
+    order: number;
+}
+
+type SmzTabValue = string | number;
+/**
+ * Abas. Substituem o `p-tabs` / `p-tablist` / `p-tab` / `p-tabpanels` / `p-tabpanel` do PrimeNG.
+ *
+ * <ui-tabs [(value)]="aba">
+ *   <ui-tab-list><ui-tab [value]="0">Um</ui-tab><ui-tab [value]="1">Dois</ui-tab></ui-tab-list>
+ *   <ui-tab-panels><ui-tab-panel [value]="0">...</ui-tab-panel><ui-tab-panel [value]="1">...</ui-tab-panel></ui-tab-panels>
+ * </ui-tabs>
+ *
+ * Com `lazy`, o conteudo so e criado quando o painel e aberto pela primeira vez (use `<ng-template smzTemplate="content">`).
+ */
+declare class SmzTabsComponent {
+    readonly value: _angular_core.ModelSignal<SmzTabValue>;
+    readonly lazy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Aceito por compatibilidade com o `p-tabs`; sem efeito. */
+    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    select(value: SmzTabValue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTabsComponent, "ui-tabs", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, never>;
+}
+declare class SmzTabListComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTabListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTabListComponent, "ui-tab-list", never, {}, {}, never, ["*"], true, never>;
+}
+declare class SmzTabComponent {
+    readonly value: _angular_core.InputSignal<SmzTabValue>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly tabs;
+    protected readonly active: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected activate(event?: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTabComponent, "ui-tab", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class SmzTabPanelsComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTabPanelsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTabPanelsComponent, "ui-tab-panels", never, {}, {}, never, ["*"], true, never>;
+}
+declare class SmzTabPanelComponent {
+    readonly value: _angular_core.InputSignal<SmzTabValue>;
+    protected readonly tabs: SmzTabsComponent;
+    protected readonly active: _angular_core.Signal<boolean>;
+    protected readonly visited: _angular_core.WritableSignal<boolean>;
+    private readonly templates;
+    protected readonly contentTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTabPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTabPanelComponent, "ui-tab-panel", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, ["templates"], ["*"], true, never>;
+}
+
+type SmzAccordionValue = string | number;
+/**
+ * Acordeao. Substitui o `p-accordion` / `p-accordion-panel` / `p-accordion-header` / `p-accordion-content` do PrimeNG.
+ *
+ * <ui-accordion [multiple]="true">
+ *   <ui-accordion-panel [value]="1"><ui-accordion-header>Titulo</ui-accordion-header><ui-accordion-content>...</ui-accordion-content></ui-accordion-panel>
+ * </ui-accordion>
+ */
+declare class SmzAccordionComponent {
+    readonly value: _angular_core.ModelSignal<SmzAccordionValue | SmzAccordionValue[]>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Um painel foi aberto (equivale ao `onOpen` do `p-accordion`). */
+    readonly opened: _angular_core.OutputEmitterRef<{
+        value: SmzAccordionValue;
+    }>;
+    /** Um painel foi fechado (equivale ao `onClose`). */
+    readonly closed: _angular_core.OutputEmitterRef<{
+        value: SmzAccordionValue;
+    }>;
+    /** Aceito por compatibilidade com o `p-accordion`; sem efeito. */
+    readonly transitionOptions: _angular_core.InputSignal<string>;
+    isOpen(value: SmzAccordionValue): boolean;
+    toggle(value: SmzAccordionValue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzAccordionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzAccordionComponent, "ui-accordion", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "transitionOptions": { "alias": "transitionOptions"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "opened": "opened"; "closed": "closed"; }, never, ["*"], true, never>;
+}
+declare class SmzAccordionPanelComponent {
+    readonly value: _angular_core.InputSignal<SmzAccordionValue>;
+    private readonly accordion;
+    readonly open: _angular_core.Signal<boolean>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzAccordionPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzAccordionPanelComponent, "ui-accordion-panel", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class SmzAccordionHeaderComponent {
+    protected readonly panel: SmzAccordionPanelComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzAccordionHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzAccordionHeaderComponent, "ui-accordion-header", never, {}, {}, never, ["*"], true, never>;
+}
+declare class SmzAccordionContentComponent {
+    protected readonly panel: SmzAccordionPanelComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzAccordionContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzAccordionContentComponent, "ui-accordion-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+type SmzTimelineAlign = 'left' | 'right' | 'alternate' | 'top' | 'bottom';
+/**
+ * Linha do tempo. Substitui o `p-timeline` do PrimeNG.
+ * Templates (via `smzTemplate`): `marker`, `content` e `opposite`, todos com o evento como `$implicit`.
+ *
+ * <ui-timeline [value]="eventos" align="alternate">
+ *   <ng-template smzTemplate="content" let-event>{{ event.titulo }}</ng-template>
+ * </ui-timeline>
+ */
+declare class SmzUiTimelineComponent {
+    readonly value: _angular_core.InputSignal<readonly any[]>;
+    readonly align: _angular_core.InputSignal<string>;
+    readonly layout: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    private readonly templates;
+    protected readonly markerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly contentTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly oppositeTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly horizontal: _angular_core.Signal<boolean>;
+    protected rowReverse(index: number): boolean;
+    protected oppositeClass(index: number): string;
+    protected contentClass(index: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzUiTimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzUiTimelineComponent, "ui-timeline", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, ["templates"], never, true, never>;
+}
+
+/**
+ * Alterna classes de um elemento alvo ao clicar no hospedeiro (menus e paineis). Substitui o `pStyleClass` do PrimeNG.
+ * O alvo vem de `smzStyleClass`: `@next`, `@prev`, `@parent`, `@grandparent` ou um seletor CSS.
+ *
+ * <button smzStyleClass="@next" enterFromClass="hidden" enterActiveClass="animate-scalein" leaveToClass="hidden" leaveActiveClass="animate-fadeout" [hideOnOutsideClick]="true"></button>
+ *
+ * As classes `*ActiveClass` sao removidas ao fim da animacao (evento `animationend`).
+ */
+declare class SmzStyleClassDirective implements OnDestroy {
+    readonly selector: _angular_core.InputSignal<string>;
+    readonly enterFromClass: _angular_core.InputSignal<string>;
+    readonly enterActiveClass: _angular_core.InputSignal<string>;
+    readonly enterToClass: _angular_core.InputSignal<string>;
+    readonly leaveFromClass: _angular_core.InputSignal<string>;
+    readonly leaveActiveClass: _angular_core.InputSignal<string>;
+    readonly leaveToClass: _angular_core.InputSignal<string>;
+    readonly hideOnOutsideClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly toggleClass: _angular_core.InputSignal<string>;
+    private readonly host;
+    private documentListener?;
+    ngOnDestroy(): void;
+    protected onClick(event: Event): void;
+    private resolveTarget;
+    private classes;
+    private apply;
+    private enter;
+    private leave;
+    private afterAnimation;
+    private bindOutsideClick;
+    private unbindOutsideClick;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzStyleClassDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzStyleClassDirective, "[smzStyleClass]", never, { "selector": { "alias": "smzStyleClass"; "required": false; "isSignal": true; }; "enterFromClass": { "alias": "enterFromClass"; "required": false; "isSignal": true; }; "enterActiveClass": { "alias": "enterActiveClass"; "required": false; "isSignal": true; }; "enterToClass": { "alias": "enterToClass"; "required": false; "isSignal": true; }; "leaveFromClass": { "alias": "leaveFromClass"; "required": false; "isSignal": true; }; "leaveActiveClass": { "alias": "leaveActiveClass"; "required": false; "isSignal": true; }; "leaveToClass": { "alias": "leaveToClass"; "required": false; "isSignal": true; }; "hideOnOutsideClick": { "alias": "hideOnOutsideClick"; "required": false; "isSignal": true; }; "toggleClass": { "alias": "toggleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface SmzPageEvent {
+    first: number;
+    rows: number;
+    page: number;
+    pageCount: number;
+}
+/**
+ * Paginador. Substitui o `p-paginator` do PrimeNG.
+ * O template do relatorio aceita `{currentPage}`, `{totalPages}`, `{rows}`, `{first}`, `{last}` e `{totalRecords}`.
+ *
+ * <ui-paginator [first]="primeiro" [rows]="10" [totalRecords]="120" (pageChanged)="mudou($event)" />
+ */
+declare class SmzPaginatorComponent {
+    readonly first: _angular_core.ModelSignal<number>;
+    readonly rows: _angular_core.ModelSignal<number>;
+    readonly totalRecords: _angular_core.InputSignal<number>;
+    readonly pageLinkSize: _angular_core.InputSignal<number>;
+    readonly rowsPerPageOptions: _angular_core.InputSignal<number[]>;
+    readonly showCurrentPageReport: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly currentPageReportTemplate: _angular_core.InputSignal<string>;
+    readonly alwaysShow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showPageLinks: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    /** Aceitos por compatibilidade com o `p-paginator`; sem efeito. */
+    readonly dropdownAppendTo: _angular_core.InputSignal<unknown>;
+    readonly showFirstLastIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly pageChanged: _angular_core.OutputEmitterRef<SmzPageEvent>;
+    protected readonly pageCount: _angular_core.Signal<number>;
+    protected readonly page: _angular_core.Signal<number>;
+    protected readonly isFirst: _angular_core.Signal<boolean>;
+    protected readonly isLast: _angular_core.Signal<boolean>;
+    protected readonly visible: _angular_core.Signal<boolean>;
+    protected readonly links: _angular_core.Signal<number[]>;
+    protected readonly report: _angular_core.Signal<string>;
+    /** Vai para a pagina (base 0) e emite `pageChanged`. */
+    goTo(page: number): void;
+    protected changeRows(rows: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzPaginatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzPaginatorComponent, "ui-paginator", never, { "first": { "alias": "first"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "totalRecords": { "alias": "totalRecords"; "required": false; "isSignal": true; }; "pageLinkSize": { "alias": "pageLinkSize"; "required": false; "isSignal": true; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; "isSignal": true; }; "showCurrentPageReport": { "alias": "showCurrentPageReport"; "required": false; "isSignal": true; }; "currentPageReportTemplate": { "alias": "currentPageReportTemplate"; "required": false; "isSignal": true; }; "alwaysShow": { "alias": "alwaysShow"; "required": false; "isSignal": true; }; "showPageLinks": { "alias": "showPageLinks"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "dropdownAppendTo": { "alias": "dropdownAppendTo"; "required": false; "isSignal": true; }; "showFirstLastIcon": { "alias": "showFirstLastIcon"; "required": false; "isSignal": true; }; }, { "first": "firstChange"; "rows": "rowsChange"; "pageChanged": "pageChanged"; }, never, never, true, never>;
+}
+
+type SmzDataViewLayout = 'list' | 'grid';
+/**
+ * Colecao de itens em lista ou grade, com filtro e paginacao. Substitui o `p-dataview` do PrimeNG.
+ * Templates: `header`, `list`, `grid`, `empty` e `footer`, declarados por referencia (`<ng-template let-items #list>`)
+ * ou por `smzTemplate`. Os de `list` e `grid` recebem a pagina atual como `$implicit`.
+ */
+declare class SmzDataViewComponent {
+    readonly value: _angular_core.InputSignal<readonly any[]>;
+    readonly layout: _angular_core.InputSignal<string>;
+    readonly paginator: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly first: _angular_core.ModelSignal<number>;
+    readonly filterBy: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    /** Aceito por compatibilidade com o `p-dataview`; o container da grade e definido no template do consumidor. */
+    readonly gridStyleClass: _angular_core.InputSignal<string>;
+    /** Elemento hospedeiro (compatibilidade com `DataView.el` do PrimeNG). */
+    readonly el: ElementRef<HTMLElement>;
+    private readonly query;
+    private readonly templates;
+    private readonly refHeader;
+    private readonly refList;
+    private readonly refGrid;
+    private readonly refEmpty;
+    private readonly refFooter;
+    protected readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly listTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly gridTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly emptyTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly footerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly filtered: _angular_core.Signal<readonly any[]>;
+    protected readonly pageItems: _angular_core.Signal<readonly any[]>;
+    /** Filtra os itens por texto nos campos de `filterBy` e volta para a primeira pagina. */
+    filter(value: string): void;
+    protected onPage(first: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzDataViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzDataViewComponent, "ui-data-view", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "first": { "alias": "first"; "required": false; "isSignal": true; }; "filterBy": { "alias": "filterBy"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "gridStyleClass": { "alias": "gridStyleClass"; "required": false; "isSignal": true; }; }, { "first": "firstChange"; }, ["templates", "refHeader", "refList", "refGrid", "refEmpty", "refFooter"], never, true, never>;
+}
+
+interface SmzPickListMoveEvent {
+    items: any[];
+}
+type Side = 'source' | 'target';
+/**
+ * Duas listas de transferencia de itens. Substitui o `p-picklist` do PrimeNG.
+ * `source` e `target` sao arrays do consumidor: o componente os altera in-place e emite o que foi movido.
+ * Template `item` (via `smzTemplate`) recebe o item como `$implicit`.
+ */
+declare class SmzPickListComponent {
+    readonly source: _angular_core.InputSignal<any[]>;
+    readonly target: _angular_core.InputSignal<any[]>;
+    readonly sourceHeader: _angular_core.InputSignal<string>;
+    readonly targetHeader: _angular_core.InputSignal<string>;
+    readonly sourceFilterPlaceholder: _angular_core.InputSignal<string>;
+    readonly targetFilterPlaceholder: _angular_core.InputSignal<string>;
+    readonly filterBy: _angular_core.InputSignal<string>;
+    readonly dragdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly responsive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly listStyle: _angular_core.InputSignal<Record<string, string | number>>;
+    /** Aceitos por compatibilidade com o `p-picklist`; sem efeito (nao ha botoes de reordenacao). */
+    readonly showSourceControls: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showTargetControls: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly movedToTarget: _angular_core.OutputEmitterRef<SmzPickListMoveEvent>;
+    readonly movedToSource: _angular_core.OutputEmitterRef<SmzPickListMoveEvent>;
+    readonly movedAllToTarget: _angular_core.OutputEmitterRef<SmzPickListMoveEvent>;
+    readonly movedAllToSource: _angular_core.OutputEmitterRef<SmzPickListMoveEvent>;
+    protected readonly sourceQuery: _angular_core.WritableSignal<string>;
+    protected readonly targetQuery: _angular_core.WritableSignal<string>;
+    /** Incrementado a cada alteracao in-place dos arrays do consumidor. */
+    private readonly tick;
+    private readonly selection;
+    private readonly templates;
+    protected readonly itemTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly selectedSource: _angular_core.Signal<any[]>;
+    protected readonly selectedTarget: _angular_core.Signal<any[]>;
+    protected readonly sourceView: _angular_core.Signal<any[]>;
+    protected readonly targetView: _angular_core.Signal<any[]>;
+    protected label(item: any): string;
+    protected isSelected(side: Side, item: any): boolean;
+    protected rowClass(side: Side, item: any): string;
+    protected toggle(side: Side, item: any): void;
+    protected moveOne(side: Side, item: any): void;
+    protected moveSelected(side: Side): void;
+    protected moveAll(side: Side): void;
+    protected dropped(event: CdkDragDrop<any[]>, side: Side): void;
+    private transfer;
+    private filtered;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzPickListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzPickListComponent, "ui-pick-list", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "sourceHeader": { "alias": "sourceHeader"; "required": false; "isSignal": true; }; "targetHeader": { "alias": "targetHeader"; "required": false; "isSignal": true; }; "sourceFilterPlaceholder": { "alias": "sourceFilterPlaceholder"; "required": false; "isSignal": true; }; "targetFilterPlaceholder": { "alias": "targetFilterPlaceholder"; "required": false; "isSignal": true; }; "filterBy": { "alias": "filterBy"; "required": false; "isSignal": true; }; "dragdrop": { "alias": "dragdrop"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "listStyle": { "alias": "listStyle"; "required": false; "isSignal": true; }; "showSourceControls": { "alias": "showSourceControls"; "required": false; "isSignal": true; }; "showTargetControls": { "alias": "showTargetControls"; "required": false; "isSignal": true; }; }, { "movedToTarget": "movedToTarget"; "movedToSource": "movedToSource"; "movedAllToTarget": "movedAllToTarget"; "movedAllToSource": "movedAllToSource"; }, ["templates"], never, true, never>;
+}
+
+type SmzFilterFunction = (value: any, filter: any, filterLocale?: string) => boolean;
+/**
+ * Funcoes de filtro por modo (`contains`, `equals`, `dateIs`...) usadas pela tabela. Substitui o `FilterService` do PrimeNG.
+ * Modos proprios podem ser adicionados com `register`.
+ */
+declare class SmzFilterService {
+    filters: Record<string, SmzFilterFunction>;
+    /** Filtra `data` mantendo os itens em que algum dos `fields` satisfaz o modo. */
+    filter(data: any[], fields: any[], value: any, matchMode: string, locale?: string): any[];
+    /** Registra (ou sobrescreve) um modo de filtro. */
+    register(rule: string, fn: SmzFilterFunction): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzFilterService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SmzFilterService>;
+}
+
+type SmzTreeSelectionMode = 'single' | 'multiple' | 'checkbox' | null;
+interface SmzTreeNodeEvent {
+    originalEvent: Event;
+    node: SmzUiTreeNode;
+}
+interface SmzTreeDropEvent {
+    originalEvent: Event;
+    dragNode: SmzUiTreeNode;
+    dropNode: SmzUiTreeNode | null;
+    /** Posicao (base 0) de `dropNode` na sua lista; `undefined` ao soltar fora de qualquer no. */
+    index?: number;
+    /** Com `validateDrop`, o consumidor chama `accept()` para efetivar a movimentacao. */
+    accept?: () => void;
+}
+interface TreeRow {
+    node: SmzUiTreeNode;
+    level: number;
+    siblings: SmzUiTreeNode[];
+    index: number;
+    parent: SmzUiTreeNode | null;
+}
+type DropPosition = -1 | 0 | 1;
+/**
+ * Arvore de nos com selecao, expansao, filtro e arrastar e soltar. Substitui o `p-tree` do PrimeNG.
+ * Templates por tipo de no: `<ng-template smzTemplate="tipo" let-node>` (o tipo e `node.type`; `default` vale para os demais).
+ * Tambem aceita `header`, `footer` e `empty`.
+ *
+ * <ui-tree [value]="nos" selectionMode="single" [(selection)]="selecionado" />
+ */
+declare class SmzUiTreeComponent {
+    readonly value: _angular_core.InputSignal<SmzUiTreeNode<any>[]>;
+    readonly selectionMode: _angular_core.InputSignal<string>;
+    readonly selection: _angular_core.ModelSignal<any>;
+    readonly metaKeySelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly propagateSelectionUp: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly propagateSelectionDown: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loadingIcon: _angular_core.InputSignal<string>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filterMode: _angular_core.InputSignal<string>;
+    readonly filterPlaceholder: _angular_core.InputSignal<string>;
+    readonly filterBy: _angular_core.InputSignal<string>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly draggableNodes: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly droppableNodes: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly validateDrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly scrollHeight: _angular_core.InputSignal<string>;
+    readonly style: _angular_core.InputSignal<Record<string, string | number>>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    /** Menu de contexto exibido no clique direito de um no (o consumidor atualiza o modelo em `nodeContextMenuSelect`). */
+    readonly contextMenu: _angular_core.InputSignal<SmzMenuListComponent>;
+    /** Templates fornecidos por outro componente (ex.: `ui-tree-select`), usados no lugar dos filhos de conteudo. */
+    readonly templateOverride: _angular_core.InputSignal<readonly SmzTemplateDirective[]>;
+    /** Aceitos por compatibilidade com o `p-tree`; sem efeito. */
+    readonly layout: _angular_core.InputSignal<string>;
+    readonly virtualScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly nodeSelect: _angular_core.OutputEmitterRef<SmzTreeNodeEvent>;
+    readonly nodeUnselect: _angular_core.OutputEmitterRef<SmzTreeNodeEvent>;
+    readonly nodeExpand: _angular_core.OutputEmitterRef<SmzTreeNodeEvent>;
+    readonly nodeCollapse: _angular_core.OutputEmitterRef<SmzTreeNodeEvent>;
+    readonly nodeContextMenuSelect: _angular_core.OutputEmitterRef<SmzTreeNodeEvent>;
+    readonly nodeDblClick: _angular_core.OutputEmitterRef<SmzTreeNodeEvent>;
+    readonly nodeDrop: _angular_core.OutputEmitterRef<SmzTreeDropEvent>;
+    readonly filtered: _angular_core.OutputEmitterRef<{
+        filter: string;
+        filteredValue: SmzUiTreeNode[];
+    }>;
+    /** Elemento hospedeiro (compatibilidade com `Tree.el` do PrimeNG). */
+    readonly el: ElementRef<HTMLElement>;
+    /** Incrementado a cada mutacao in-place (expansao, selecao propagada, drop) para recalcular as linhas. */
+    private readonly tick;
+    private readonly query;
+    protected readonly dropHover: _angular_core.WritableSignal<{
+        key: SmzUiTreeNode;
+        position: DropPosition;
+    }>;
+    private dragged;
+    private readonly templates;
+    private readonly allTemplates;
+    protected readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly footerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly emptyTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly rows: _angular_core.Signal<TreeRow[]>;
+    /** Filtra os nos por texto no campo `filterBy` (modo `lenient` mantem os filhos de um no que combina). */
+    _filter(value: string): void;
+    protected isLeaf(node: SmzUiTreeNode): boolean;
+    protected iconOf(node: SmzUiTreeNode): string | null;
+    protected templateFor(node: SmzUiTreeNode): TemplateRef<unknown> | undefined;
+    protected isSelected(node: SmzUiTreeNode): boolean;
+    protected isDraggable(node: SmzUiTreeNode): boolean;
+    protected rowClasses(row: TreeRow): string;
+    protected toggle(event: Event, node: SmzUiTreeNode): void;
+    private expand;
+    private collapse;
+    protected onNodeClick(event: Event, node: SmzUiTreeNode): void;
+    protected onContextMenu(event: MouseEvent, node: SmzUiTreeNode): void;
+    protected onKeydown(event: KeyboardEvent, row: TreeRow): void;
+    private listSelection;
+    private setSelection;
+    private indexInSelection;
+    private sameNode;
+    private propagateDown;
+    private propagateUp;
+    /** Mapa no -> motivo (`self` combina; `child` tem descendente que combina). */
+    private matchingNodes;
+    protected onDragStart(event: DragEvent, row: TreeRow): void;
+    protected onDragEnd(): void;
+    private allowDrop;
+    private positionOf;
+    protected onDragOver(event: DragEvent, row: TreeRow): void;
+    protected onDragLeave(): void;
+    protected onDrop(event: DragEvent, row: TreeRow): void;
+    protected onRootDragOver(event: DragEvent): void;
+    protected onRootDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzUiTreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzUiTreeComponent, "ui-tree", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "metaKeySelection": { "alias": "metaKeySelection"; "required": false; "isSignal": true; }; "propagateSelectionUp": { "alias": "propagateSelectionUp"; "required": false; "isSignal": true; }; "propagateSelectionDown": { "alias": "propagateSelectionDown"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingIcon": { "alias": "loadingIcon"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "filterBy": { "alias": "filterBy"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "draggableNodes": { "alias": "draggableNodes"; "required": false; "isSignal": true; }; "droppableNodes": { "alias": "droppableNodes"; "required": false; "isSignal": true; }; "validateDrop": { "alias": "validateDrop"; "required": false; "isSignal": true; }; "scrollHeight": { "alias": "scrollHeight"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "contextMenu": { "alias": "contextMenu"; "required": false; "isSignal": true; }; "templateOverride": { "alias": "templateOverride"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; }, { "selection": "selectionChange"; "nodeSelect": "nodeSelect"; "nodeUnselect": "nodeUnselect"; "nodeExpand": "nodeExpand"; "nodeCollapse": "nodeCollapse"; "nodeContextMenuSelect": "nodeContextMenuSelect"; "nodeDblClick": "nodeDblClick"; "nodeDrop": "nodeDrop"; "filtered": "filtered"; }, ["templates"], never, true, never>;
+}
+
+/**
+ * Selecao de no de arvore em lista suspensa. Substitui o `p-treeselect` do PrimeNG.
+ * O valor e o proprio no (modo `single`) ou a lista de nos (`multiple` e `checkbox`).
+ * Aceita os mesmos templates por tipo de no do `ui-tree`.
+ */
+declare class SmzTreeSelectComponent extends SmzValueAccessor<any> implements OnDestroy {
+    readonly options: _angular_core.InputSignal<SmzUiTreeNode<any>[]>;
+    readonly selectionMode: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filterPlaceholder: _angular_core.InputSignal<string>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly showClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly scrollHeight: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly containerStyleClass: _angular_core.InputSignal<string>;
+    /** Aceitos por compatibilidade com o `p-treeselect`; sem efeito. */
+    readonly appendTo: _angular_core.InputSignal<unknown>;
+    readonly display: _angular_core.InputSignal<string>;
+    readonly filterInputAutoFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly templates: _angular_core.Signal<readonly SmzTemplateDirective[]>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly selectedNodes: _angular_core.Signal<SmzUiTreeNode<any>[]>;
+    protected readonly label: _angular_core.Signal<string>;
+    private readonly overlay;
+    private readonly viewContainer;
+    private readonly trigger;
+    private readonly panel;
+    private readonly anchored;
+    ngOnDestroy(): void;
+    protected toggle(): void;
+    protected onBlur(): void;
+    protected onSelection(selection: any): void;
+    protected clear(event: Event): void;
+    private openPanel;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTreeSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTreeSelectComponent, "ui-tree-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "scrollHeight": { "alias": "scrollHeight"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "containerStyleClass": { "alias": "containerStyleClass"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "filterInputAutoFocus": { "alias": "filterInputAutoFocus"; "required": false; "isSignal": true; }; }, {}, ["templates"], never, true, never>;
+}
+
+/** Paleta no formato Tailwind (`500`, `600`...) em hexadecimal. */
+type SmzPalette = Partial<Record<0 | 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950, string>>;
+/**
+ * Altera tokens do tema em tempo de execucao (cores sao canais RGB em `--smz-color-*`).
+ * O tema base vem do CSS (themes/*.css); este servico apenas sobrescreve variaveis no `<html>`.
+ */
+declare class SmzThemeService {
+    private readonly root;
+    /** Sobrescreve cores: `{ primary: '#6366f1' }` -> `--smz-color-primary`. Aceita hexadecimal ou canais ("99 102 241"). */
+    setColors(colors: Record<string, string>): void;
+    /** Define a cor primaria a partir de uma paleta; escolhe os tons por modo claro/escuro. */
+    setPrimaryPalette(palette: SmzPalette, dark?: boolean): void;
+    /** Remove todas as sobrescritas feitas por este servico (volta ao tema do CSS). */
+    reset(): void;
+    isDark(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SmzThemeService>;
+}
+
+/**
+ * Card. Substitui o `p-card` do PrimeNG.
+ * O conteudo padrao vai no corpo; `header`, `title`, `subtitle` e `footer` podem ser strings ou templates.
+ *
+ * <ui-card header="Titulo" subheader="Sub">conteudo<ng-template smzTemplate="footer">...</ng-template></ui-card>
+ */
+declare class SmzCardComponent {
+    /** Titulo em texto (equivale ao slot `title`). */
+    readonly header: _angular_core.InputSignal<string>;
+    /** Subtitulo em texto (equivale ao slot `subtitle`). */
+    readonly subheader: _angular_core.InputSignal<string>;
+    private readonly templates;
+    protected readonly headerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly titleTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly subtitleTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly footerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzCardComponent, "ui-card", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "subheader": { "alias": "subheader"; "required": false; "isSignal": true; }; }, {}, ["templates"], ["*"], true, never>;
+}
+
+/**
+ * Painel com cabecalho, recolhimento opcional e rodape. Substitui o `p-panel` do PrimeNG.
+ *
+ * <ui-panel header="Filtros" [toggleable]="true" [(collapsed)]="fechado">conteudo</ui-panel>
+ */
+declare class SmzPanelComponent {
+    readonly header: _angular_core.InputSignal<string>;
+    readonly toggleable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collapsed: _angular_core.ModelSignal<boolean>;
+    /** Antes de alternar (cancelavel nao: apenas notifica). */
+    readonly beforeToggle: _angular_core.OutputEmitterRef<{
+        originalEvent: Event;
+        collapsed: boolean;
+    }>;
+    readonly afterToggle: _angular_core.OutputEmitterRef<{
+        originalEvent: Event;
+        collapsed: boolean;
+    }>;
+    private readonly templates;
+    protected readonly headerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly iconsTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly footerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly hasHeader: _angular_core.Signal<boolean>;
+    protected toggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzPanelComponent, "ui-panel", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "toggleable": { "alias": "toggleable"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; "beforeToggle": "beforeToggle"; "afterToggle": "afterToggle"; }, ["templates"], ["*"], true, never>;
+}
+
+/**
+ * Indicador de carregamento circular. Substitui o `p-progressspinner` do PrimeNG.
+ * O tamanho vem das classes do host (ex.: `class="h-12 w-12"`); a cor, de `text-ui-primary` (herdavel).
+ *
+ * <ui-progress-spinner class="h-12 w-12" strokeWidth="4" />
+ */
+declare class SmzProgressSpinnerComponent {
+    readonly strokeWidth: _angular_core.InputSignal<string | number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzProgressSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzProgressSpinnerComponent, "ui-progress-spinner", never, { "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SmzFloatLabelVariant = 'over' | 'in' | 'on';
+/**
+ * Rotulo flutuante. Substitui o `p-floatlabel` do PrimeNG.
+ * O `<label>` projetado flutua quando o controle recebe foco ou tem valor
+ * (detectado em `input`/`textarea` e em selects do kit; use `[filled]` para forcar).
+ *
+ * <ui-float-label variant="on"><input smzInputText id="n" /><label for="n">Nome</label></ui-float-label>
+ */
+declare class SmzFloatLabelComponent {
+    readonly variant: _angular_core.InputSignal<SmzFloatLabelVariant>;
+    /** Forca o estado "preenchido" quando a deteccao automatica nao se aplica. */
+    readonly filled: _angular_core.InputSignal<boolean>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    private readonly detected;
+    private readonly host;
+    protected readonly floated: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    constructor();
+    protected check(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzFloatLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzFloatLabelComponent, "ui-float-label", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "filled": { "alias": "filled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Painel de um `ui-splitter`. O conteudo e projetado dentro da area do painel. */
+declare class SmzSplitterPanelComponent {
+    readonly content: _angular_core.Signal<TemplateRef<unknown>>;
+    /** Tamanho inicial em % (sobrescreve `panelSizes` do splitter). */
+    readonly size: _angular_core.InputSignal<number>;
+    readonly minSize: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzSplitterPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzSplitterPanelComponent, "ui-splitter-panel", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "minSize": { "alias": "minSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * Divisor redimensionavel. Substitui o `p-splitter` / `p-splitterPanel` do PrimeNG.
+ *
+ * <ui-splitter layout="horizontal" [panelSizes]="[30, 70]" [minSizes]="[10, 20]">
+ *   <ui-splitter-panel>A</ui-splitter-panel><ui-splitter-panel>B</ui-splitter-panel>
+ * </ui-splitter>
+ */
+declare class SmzSplitterComponent {
+    readonly layout: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly panelSizes: _angular_core.InputSignal<number[]>;
+    readonly minSizes: _angular_core.InputSignal<number[]>;
+    readonly resizeEnd: _angular_core.OutputEmitterRef<{
+        sizes: number[];
+    }>;
+    protected readonly panels: _angular_core.Signal<readonly SmzSplitterPanelComponent[]>;
+    private readonly root;
+    private readonly overrides;
+    protected readonly sizes: _angular_core.Signal<number[]>;
+    private min;
+    protected startDrag(event: PointerEvent, index: number): void;
+    protected onKey(event: KeyboardEvent, index: number): void;
+    private resize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzSplitterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzSplitterComponent, "ui-splitter", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "panelSizes": { "alias": "panelSizes"; "required": false; "isSignal": true; }; "minSizes": { "alias": "minSizes"; "required": false; "isSignal": true; }; }, { "resizeEnd": "resizeEnd"; }, ["panels"], never, true, never>;
+}
+
+/** Linha achatada exposta aos templates (`let-rowNode`). */
+interface SmzTreeTableRowNode<T = any> {
+    node: SmzUiTreeNode<T>;
+    parent: SmzUiTreeNode<T> | null;
+    level: number;
+}
+interface SmzTreeTableNodeEvent {
+    node: SmzUiTreeNode;
+    originalEvent?: Event;
+}
+type SmzTreeTableSelectionMode = 'single' | 'multiple' | 'checkbox';
+/**
+ * Tabela em arvore. Substitui o `p-treeTable` do PrimeNG.
+ * Os templates `header`, `body`, `caption`, `footer`, `emptymessage` e `summary` usam `smzTemplate`;
+ * o `body` recebe `let-rowNode let-rowData="rowData" let-columns="columns"`.
+ *
+ * <ui-tree-table [value]="nodes" [columns]="cols" selectionMode="checkbox" [(selection)]="sel">
+ *   <ng-template smzTemplate="header" let-columns><tr><th *ngFor="let c of columns">{{ c.header }}</th></tr></ng-template>
+ *   <ng-template smzTemplate="body" let-rowNode let-rowData="rowData" let-columns="columns">
+ *     <tr [smzTtRow]="rowNode"><td><ui-tree-table-toggler [rowNode]="rowNode" />{{ rowData.name }}</td></tr>
+ *   </ng-template>
+ * </ui-tree-table>
+ */
+declare class SmzTreeTableComponent {
+    readonly value: _angular_core.InputSignal<SmzUiTreeNode<any>[]>;
+    readonly columns: _angular_core.InputSignal<any[]>;
+    readonly selectionMode: _angular_core.InputSignal<string>;
+    readonly selection: _angular_core.ModelSignal<any>;
+    readonly propagateSelectionUp: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly propagateSelectionDown: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly scrollHeight: _angular_core.InputSignal<string>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly tableStyleClass: _angular_core.InputSignal<string>;
+    readonly paginator: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rows: _angular_core.ModelSignal<number>;
+    readonly first: _angular_core.ModelSignal<number>;
+    readonly rowsPerPageOptions: _angular_core.InputSignal<number[]>;
+    readonly sortField: _angular_core.ModelSignal<string>;
+    readonly sortOrder: _angular_core.ModelSignal<1 | -1>;
+    /** Destaca a linha sob o cursor (padrao: ligado). */
+    readonly rowHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showCurrentPageReport: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly currentPageReportTemplate: _angular_core.InputSignal<string>;
+    /** Campos (de `node.data`) consultados pelo filtro global. */
+    readonly globalFilterFields: _angular_core.InputSignal<string[]>;
+    /** `lenient`: um no que casa mantem toda a sua subarvore; `strict`: so os nos que casam (e seus ancestrais). */
+    readonly filterMode: _angular_core.InputSignal<"lenient" | "strict">;
+    readonly nodeSelect: _angular_core.OutputEmitterRef<SmzTreeTableNodeEvent>;
+    readonly nodeUnselect: _angular_core.OutputEmitterRef<SmzTreeTableNodeEvent>;
+    readonly nodeExpand: _angular_core.OutputEmitterRef<SmzTreeTableNodeEvent>;
+    readonly nodeCollapse: _angular_core.OutputEmitterRef<SmzTreeTableNodeEvent>;
+    readonly sorted: _angular_core.OutputEmitterRef<{
+        field: string;
+        order: 1 | -1;
+    }>;
+    readonly page: _angular_core.OutputEmitterRef<unknown>;
+    private readonly templates;
+    protected readonly headerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly bodyTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly captionTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly footerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly emptyTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    protected readonly summaryTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    /** Os nos sao mutaveis (`expanded`, `partialSelected`); este contador forca o recalculo das linhas. */
+    private readonly version;
+    private readonly filterService;
+    private readonly globalFilter;
+    private readonly columnFilters;
+    /** Nos raiz que passam nos filtros (global e por coluna), ou `null` quando nao ha filtro ativo. */
+    get filteredNodes(): SmzUiTreeNode[] | null;
+    /** Visibilidade calculada dos filtros: quais nos aparecem e quais ancestrais expandir. */
+    private readonly visibility;
+    protected readonly rootCount: _angular_core.Signal<number>;
+    protected readonly flatRows: _angular_core.Signal<SmzTreeTableRowNode<any>[]>;
+    /** Linhas visiveis; com paginador, a pagina atual e calculada sobre os nos raiz. */
+    protected readonly pageRows: _angular_core.Signal<SmzTreeTableRowNode<any>[]>;
+    /** Filtro global (equivale a `filterGlobal` do `p-treeTable`). */
+    filterGlobal(value: string | null, matchMode?: string): void;
+    /** Filtro de uma coluna (campo de `node.data`). Valor vazio remove o filtro. */
+    filter(value: any, field: string, matchMode?: string): void;
+    /** Limpa filtros, ordenacao e volta para a primeira pagina (equivale a `clear()` do `p-treeTable`). */
+    clear(): void;
+    refresh(): void;
+    toggleNode(rowNode: SmzTreeTableRowNode, event?: Event): void;
+    sortBy(field: string): void;
+    isSelected(node: SmzUiTreeNode): boolean;
+    selectionState(node: SmzUiTreeNode): 'checked' | 'partial' | 'unchecked';
+    onRowClick(rowNode: SmzTreeTableRowNode, event: Event): void;
+    toggleCheckbox(rowNode: SmzTreeTableRowNode, event?: Event): void;
+    /** Marca/desmarca todos os nos (checkbox do cabecalho). */
+    toggleAll(checked: boolean): void;
+    allSelected(): boolean;
+    private countNodes;
+    private findParent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTreeTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTreeTableComponent, "ui-tree-table", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "propagateSelectionUp": { "alias": "propagateSelectionUp"; "required": false; "isSignal": true; }; "propagateSelectionDown": { "alias": "propagateSelectionDown"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "scrollHeight": { "alias": "scrollHeight"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "tableStyleClass": { "alias": "tableStyleClass"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "first": { "alias": "first"; "required": false; "isSignal": true; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; "isSignal": true; }; "sortField": { "alias": "sortField"; "required": false; "isSignal": true; }; "sortOrder": { "alias": "sortOrder"; "required": false; "isSignal": true; }; "rowHover": { "alias": "rowHover"; "required": false; "isSignal": true; }; "showCurrentPageReport": { "alias": "showCurrentPageReport"; "required": false; "isSignal": true; }; "currentPageReportTemplate": { "alias": "currentPageReportTemplate"; "required": false; "isSignal": true; }; "globalFilterFields": { "alias": "globalFilterFields"; "required": false; "isSignal": true; }; "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; }, { "selection": "selectionChange"; "rows": "rowsChange"; "first": "firstChange"; "sortField": "sortFieldChange"; "sortOrder": "sortOrderChange"; "nodeSelect": "nodeSelect"; "nodeUnselect": "nodeUnselect"; "nodeExpand": "nodeExpand"; "nodeCollapse": "nodeCollapse"; "sorted": "sorted"; "page": "page"; }, ["templates"], never, true, never>;
+}
+/** Linha do corpo: `<tr [smzTtRow]="rowNode">`. Cuida de estilo, aria e selecao por clique. */
+declare class SmzTreeTableRowDirective {
+    protected readonly table: SmzTreeTableComponent;
+    readonly rowNode: _angular_core.InputSignal<SmzTreeTableRowNode<any>>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTreeTableRowDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzTreeTableRowDirective, "tr[smzTtRow]", never, { "rowNode": { "alias": "smzTtRow"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Seta de expandir/recolher com recuo por nivel: `<ui-tree-table-toggler [rowNode]="rowNode" />`. */
+declare class SmzTreeTableTogglerComponent {
+    protected readonly table: SmzTreeTableComponent;
+    readonly rowNode: _angular_core.InputSignal<SmzTreeTableRowNode<any>>;
+    protected hasChildren(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTreeTableTogglerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTreeTableTogglerComponent, "ui-tree-table-toggler", never, { "rowNode": { "alias": "rowNode"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Checkbox de selecao da linha (modo `checkbox`): `<ui-tree-table-checkbox [value]="rowNode" />`. */
+declare class SmzTreeTableCheckboxComponent {
+    protected readonly table: SmzTreeTableComponent;
+    readonly value: _angular_core.InputSignal<SmzTreeTableRowNode<any>>;
+    protected state(): 'checked' | 'partial' | 'unchecked';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTreeTableCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTreeTableCheckboxComponent, "ui-tree-table-checkbox", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Checkbox do cabecalho: seleciona/limpa todos os nos. */
+declare class SmzTreeTableHeaderCheckboxComponent {
+    protected readonly table: SmzTreeTableComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTreeTableHeaderCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTreeTableHeaderCheckboxComponent, "ui-tree-table-header-checkbox", never, {}, {}, never, never, true, never>;
+}
+/** Cabecalho ordenavel: `<th [smzTtSortableColumn]="'nome'">Nome <ui-tree-table-sort-icon field="nome" /></th>`. */
+declare class SmzTreeTableSortableColumnDirective {
+    protected readonly table: SmzTreeTableComponent;
+    readonly field: _angular_core.InputSignal<string>;
+    protected ariaSort(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTreeTableSortableColumnDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmzTreeTableSortableColumnDirective, "th[smzTtSortableColumn]", never, { "field": { "alias": "smzTtSortableColumn"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class SmzTreeTableSortIconComponent {
+    protected readonly table: SmzTreeTableComponent;
+    readonly field: _angular_core.InputSignal<string>;
+    protected dir(): 0 | 1 | -1;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzTreeTableSortIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzTreeTableSortIconComponent, "ui-tree-table-sort-icon", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare const SMZ_TREE_TABLE: readonly [typeof SmzTreeTableComponent, typeof SmzTreeTableRowDirective, typeof SmzTreeTableTogglerComponent, typeof SmzTreeTableCheckboxComponent, typeof SmzTreeTableHeaderCheckboxComponent, typeof SmzTreeTableSortableColumnDirective, typeof SmzTreeTableSortIconComponent, typeof SmzTemplateDirective];
+
+/** Opcoes de `SmzConfirmationService.confirm` (mesmos nomes do `Confirmation` do PrimeNG). */
+interface SmzConfirmation {
+    message?: string;
+    header?: string;
+    /** Classe do icone exibido ao lado da mensagem (ex.: `fa-solid fa-triangle-exclamation`). */
+    icon?: string;
+    acceptLabel?: string;
+    rejectLabel?: string;
+    /** Esconde o botao de aceitar/rejeitar. */
+    acceptVisible?: boolean;
+    rejectVisible?: boolean;
+    /** Severidade do botao de aceitar (ex.: `danger` destrutivo, `success` aprovar). */
+    acceptSeverity?: 'primary' | 'secondary' | 'danger' | 'success' | 'warning';
+    accept?: () => void;
+    reject?: () => void;
+    width?: string;
+    closeOnEscape?: boolean;
+}
+declare class SmzConfirmContentComponent {
+    protected readonly options: SmzConfirmation;
+    private readonly ref;
+    protected close(accepted: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzConfirmContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzConfirmContentComponent, "ui-confirm-content", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Confirmacao modal. Substitui o `ConfirmationService` + `<p-confirmdialog>` do PrimeNG
+ * (nao ha componente a declarar no template).
+ *
+ * confirm.confirm({ message: 'Excluir?', header: 'Confirmacao', icon: 'fa-solid fa-triangle-exclamation', accept: () => ..., reject: () => ... });
+ */
+declare class SmzConfirmationService {
+    private readonly dialogs;
+    confirm(confirmation: SmzConfirmation): SmzDialogRef<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzConfirmationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SmzConfirmationService>;
+}
+
+interface SmzFileSelectEvent {
+    files: File[];
+    originalEvent?: Event;
+}
+interface SmzFileErrorEvent {
+    file: File;
+    reason: 'size' | 'type';
+}
+/**
+ * Selecao de arquivos com area de arrastar e soltar e lista de escolhidos.
+ * Substitui o `p-fileupload` (modo `basic`/`advanced` sem envio automatico): o envio ao servidor
+ * fica a cargo do app (ex.: `HttpClient` no handler de `(selected)`).
+ *
+ * <ui-file-upload accept="image/*" [multiple]="true" [maxFileSize]="1000000" (selected)="enviar($event.files)" />
+ */
+declare class SmzFileUploadComponent {
+    readonly accept: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Tamanho maximo por arquivo, em bytes. */
+    readonly maxFileSize: _angular_core.InputSignal<number>;
+    readonly chooseLabel: _angular_core.InputSignal<string>;
+    readonly dropLabel: _angular_core.InputSignal<string>;
+    readonly selected: _angular_core.OutputEmitterRef<SmzFileSelectEvent>;
+    readonly removed: _angular_core.OutputEmitterRef<{
+        file: File;
+    }>;
+    readonly rejected: _angular_core.OutputEmitterRef<SmzFileErrorEvent>;
+    readonly files: _angular_core.WritableSignal<File[]>;
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    private readonly fileInput;
+    /** Limpa a lista (equivale a `clear()` do `p-fileupload`). */
+    clear(): void;
+    protected onPick(event: Event): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    protected remove(file: File): void;
+    protected size(file: File): string;
+    private add;
+    private matchesAccept;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmzFileUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmzFileUploadComponent, "ui-file-upload", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "chooseLabel": { "alias": "chooseLabel"; "required": false; "isSignal": true; }; "dropLabel": { "alias": "dropLabel"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "removed": "removed"; "rejected": "rejected"; }, never, never, true, never>;
+}
+
+export { SMZ_DIALOG_CONTENT, SMZ_SOFT_TONE, SMZ_SOLID_TONE, SMZ_TREE_TABLE, SmzAccordionComponent, SmzAccordionContentComponent, SmzAccordionHeaderComponent, SmzAccordionPanelComponent, SmzAnchoredPanel, SmzAutoCompleteComponent, SmzAutoFocusDirective, SmzBadgeComponent, SmzBadgeDirective, SmzBlockUiComponent, SmzButtonComponent, SmzCardComponent, SmzCheckboxComponent, SmzColorPickerComponent, SmzConfirmContentComponent, SmzConfirmationService, SmzConnectedOverlayScrollHandler, SmzDataViewComponent, SmzDatePickerComponent, SmzDialogComponent, SmzDialogConfig, SmzDialogFrameComponent, SmzDialogRef, SmzDialogService, SmzDividerComponent, SmzDomHandler, SmzDrawerComponent, SmzFileUploadComponent, SmzFilterMatchMode, SmzFilterOperator, SmzFilterService, SmzFloatLabelComponent, SmzIconComponent, SmzIconFieldComponent, SmzInputGroupAddonComponent, SmzInputGroupComponent, SmzInputIconComponent, SmzInputMaskComponent, SmzInputNumberComponent, SmzInputTextDirective, SmzListboxComponent, SmzLocaleService, SmzMenuListComponent, SmzMessageComponent, SmzMessageService, SmzMultiSelectComponent, SmzObjectUtils, SmzPaginatorComponent, SmzPanelComponent, SmzPasswordComponent, SmzPickListComponent, SmzPopoverComponent, SmzProgressBarComponent, SmzProgressSpinnerComponent, SmzRadioButtonComponent, SmzRippleDirective, SmzSelectButtonComponent, SmzSelectComponent, SmzSkeletonComponent, SmzSplitterComponent, SmzSplitterPanelComponent, SmzStyleClassDirective, SmzTabComponent, SmzTabListComponent, SmzTabPanelComponent, SmzTabPanelsComponent, SmzTabsComponent, SmzTagComponent, SmzTemplateDirective, SmzTextareaDirective, SmzThemeService, SmzToastContainerComponent, SmzToggleSwitchComponent, SmzToolbarComponent, SmzTooltipComponent, SmzTooltipDirective, SmzTranslationKeys, SmzTreeSelectComponent, SmzTreeTableCheckboxComponent, SmzTreeTableComponent, SmzTreeTableHeaderCheckboxComponent, SmzTreeTableRowDirective, SmzTreeTableSortIconComponent, SmzTreeTableSortableColumnDirective, SmzTreeTableTogglerComponent, SmzUiTimelineComponent, SmzUiTreeComponent, SmzValueAccessor, SmzZIndex, filterOptions, optionDisabled, optionLabel, optionValue, sameValue, smzCalendarStart, smzCx, smzFindTemplate, smzFormatDate, smzMergeClasses, smzNormalizeSeverity, smzNormalizeStyleClass, smzParseButtonStyleClass, smzParseDate, smzSameDay, smzStartOfDay, smzStaticHostClass, smzTwoDigits, smzUniqueId, smzVariants };
+export type { SmzAccordionValue, SmzAnchoredPanelOptions, SmzAutoCompleteCompleteEvent, SmzAutoCompleteSelectEvent, SmzBlockTarget, SmzBlockableUi, SmzButtonIconPosition, SmzButtonLegacySeverity, SmzButtonSeverity, SmzButtonSize, SmzButtonVariant, SmzClassValue, SmzConfirmation, SmzDataViewLayout, SmzDatePickerValue, SmzDateSelectionMode, SmzDialogPosition, SmzDividerLayout, SmzDrawerPosition, SmzFileErrorEvent, SmzFileSelectEvent, SmzFilterFunction, SmzFilterMatchModeValue, SmzFilterMetadata, SmzFilterMode, SmzFilterOperatorValue, SmzFloatLabelVariant, SmzInputNumberInputEvent, SmzInputSize, SmzLegacySeverity, SmzListboxChangeEvent, SmzListboxClickEvent, SmzMessageSeverity, SmzMultiSelectChangeEvent, SmzOptionConfig, SmzPageEvent, SmzPalette, SmzPickListMoveEvent, SmzPopoverTarget, SmzProgressBarMode, SmzSelectButtonChangeEvent, SmzSelectChangeEvent, SmzSelectItem, SmzSeverity, SmzSkeletonShape, SmzSortMeta, SmzStyleClass, SmzTabValue, SmzTimelineAlign, SmzToastMessage, SmzToastPosition, SmzTooltipEvent, SmzTooltipOptions, SmzTooltipPosition, SmzTranslation, SmzTreeDropEvent, SmzTreeNodeEvent, SmzTreeSelectionMode, SmzTreeTableNodeEvent, SmzTreeTableRowNode, SmzTreeTableSelectionMode, SmzUiMenuItem, SmzUiMenuItemCommandEvent, SmzUiTreeNode, SmzVariantProps, SmzVariantsConfig };