@juau/zuri 0.3.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -145,6 +145,27 @@ export interface ZurI18n {
145
145
  /** Botão que alterna a densidade da interface. */
146
146
  densityToCompact: string;
147
147
  densityToComfortable: string;
148
+ /** Busca, edição no lugar e código. */
149
+ searchLabel: string;
150
+ copy: string;
151
+ copied: string;
152
+ copyFailed: string;
153
+ edit: string;
154
+ save: string;
155
+ inlineEditSaved: string;
156
+ inlineEditCancelled: string;
157
+ /** Texto para leitores de tela em links que abrem outra aba. */
158
+ opensInNewTab: string;
159
+ /** Seleção múltipla, tabela e navegação. */
160
+ optionAdded: (label: string) => string;
161
+ optionRemoved: (label: string) => string;
162
+ selectedCount: (count: number) => string;
163
+ clearSelection: string;
164
+ resizeColumn: (column: string) => string;
165
+ tableLoading: string;
166
+ bottomNav: string;
167
+ sheetHandle: string;
168
+ badgeCount: (count: number) => string;
148
169
  }
149
170
  export declare const ZUR_I18N_PT: ZurI18n;
150
171
  export declare const ZUR_I18N_EN: ZurI18n;
@@ -214,6 +235,7 @@ export declare class ZurThemeToggle {
214
235
  * ```
215
236
  */
216
237
  export declare class ZurThemeScope {
238
+ constructor();
217
239
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurThemeScope, never>;
218
240
  static ɵdir: i0.ɵɵDirectiveDeclaration<ZurThemeScope, "[zurThemeScope]", never, {}, {}, never, never, true, never>;
219
241
  }
@@ -423,6 +445,218 @@ export declare class ZurAvatarGroup {
423
445
  };
424
446
  }, {}, never, never, true, never>;
425
447
  }
448
+ /**
449
+ * Conjunto de ícones do Zuri: traço de 2 px, pontas arredondadas, grade de 24 px.
450
+ * Cada ícone é uma constante exportada, então o bundler descarta os que o app não usa.
451
+ * Os marcados com `mirror` apontam para um lado e se espelham em RTL.
452
+ *
453
+ * ```html
454
+ * <zur-icon [icon]="lupa" /> // readonly lupa = zurIconSearch;
455
+ * ```
456
+ */
457
+ export interface ZurIconDef {
458
+ /** Nome em kebab-case (para docs e testes). */
459
+ readonly name: string;
460
+ /** Dados do caminho SVG (`d`), em grade 24 × 24. */
461
+ readonly d: string;
462
+ /** Ícone direcional: espelha em páginas da direita para a esquerda. */
463
+ readonly mirror?: boolean;
464
+ }
465
+ export declare const zurIconCheck: ZurIconDef;
466
+ export declare const zurIconX: ZurIconDef;
467
+ export declare const zurIconPlus: ZurIconDef;
468
+ export declare const zurIconMinus: ZurIconDef;
469
+ export declare const zurIconChevronUp: ZurIconDef;
470
+ export declare const zurIconChevronDown: ZurIconDef;
471
+ export declare const zurIconChevronStart: ZurIconDef;
472
+ export declare const zurIconChevronEnd: ZurIconDef;
473
+ export declare const zurIconArrowUp: ZurIconDef;
474
+ export declare const zurIconArrowDown: ZurIconDef;
475
+ export declare const zurIconSearch: ZurIconDef;
476
+ export declare const zurIconMenu: ZurIconDef;
477
+ export declare const zurIconMoreHorizontal: ZurIconDef;
478
+ export declare const zurIconMoreVertical: ZurIconDef;
479
+ export declare const zurIconInfo: ZurIconDef;
480
+ export declare const zurIconAlertTriangle: ZurIconDef;
481
+ export declare const zurIconAlertCircle: ZurIconDef;
482
+ export declare const zurIconCheckCircle: ZurIconDef;
483
+ export declare const zurIconXCircle: ZurIconDef;
484
+ export declare const zurIconTrash: ZurIconDef;
485
+ export declare const zurIconPencil: ZurIconDef;
486
+ export declare const zurIconCopy: ZurIconDef;
487
+ export declare const zurIconDownload: ZurIconDef;
488
+ export declare const zurIconUpload: ZurIconDef;
489
+ export declare const zurIconLink: ZurIconDef;
490
+ export declare const zurIconExternalLink: ZurIconDef;
491
+ export declare const zurIconEye: ZurIconDef;
492
+ export declare const zurIconEyeOff: ZurIconDef;
493
+ export declare const zurIconCalendar: ZurIconDef;
494
+ export declare const zurIconClock: ZurIconDef;
495
+ export declare const zurIconUser: ZurIconDef;
496
+ export declare const zurIconUsers: ZurIconDef;
497
+ export declare const zurIconHome: ZurIconDef;
498
+ export declare const zurIconSettings: ZurIconDef;
499
+ export declare const zurIconHeart: ZurIconDef;
500
+ export declare const zurIconStar: ZurIconDef;
501
+ export declare const zurIconFilter: ZurIconDef;
502
+ export declare const zurIconSort: ZurIconDef;
503
+ export declare const zurIconRefresh: ZurIconDef;
504
+ export declare const zurIconBell: ZurIconDef;
505
+ export declare const zurIconMail: ZurIconDef;
506
+ export declare const zurIconImage: ZurIconDef;
507
+ export declare const zurIconFile: ZurIconDef;
508
+ export declare const zurIconFolder: ZurIconDef;
509
+ export declare const zurIconLock: ZurIconDef;
510
+ export declare const zurIconUndo: ZurIconDef;
511
+ export declare const zurIconGrip: ZurIconDef;
512
+ /** Todos os ícones, para catálogos e testes. Importar este objeto desativa o tree-shaking. */
513
+ export declare const ZUR_ICON_CATALOG: readonly ZurIconDef[];
514
+ /**
515
+ * Ícone SVG do Zuri. Sem `label` é decorativo (`aria-hidden`); com `label` vira `role="img"`.
516
+ * Os ícones direcionais (setas, chevrons) se espelham sozinhos em RTL.
517
+ *
518
+ * ```html
519
+ * <zur-icon [icon]="lupa" />
520
+ * <zur-icon [icon]="alerta" label="Atenção" [size]="24" />
521
+ * ```
522
+ */
523
+ export declare class ZurIcon {
524
+ readonly icon: import("@angular/core").InputSignal<ZurIconDef>;
525
+ /** Lado em px (16, 20 ou 24 seguem a grade do sistema). */
526
+ readonly size: import("@angular/core").InputSignal<number>;
527
+ /** Texto acessível; sem ele o ícone é decorativo. */
528
+ readonly label: import("@angular/core").InputSignal<string>;
529
+ protected readonly path: import("@angular/core").Signal<string>;
530
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurIcon, never>;
531
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurIcon, "zur-icon", never, {
532
+ "icon": {
533
+ "alias": "icon";
534
+ "required": true;
535
+ "isSignal": true;
536
+ };
537
+ "size": {
538
+ "alias": "size";
539
+ "required": false;
540
+ "isSignal": true;
541
+ };
542
+ "label": {
543
+ "alias": "label";
544
+ "required": false;
545
+ "isSignal": true;
546
+ };
547
+ }, {}, never, never, true, never>;
548
+ }
549
+ export type ZurIconButtonVariant = 'ghost' | 'secondary' | 'primary';
550
+ export type ZurIconButtonSize = 'sm' | 'md' | 'lg';
551
+ /**
552
+ * Botão quadrado só com ícone. O `label` é obrigatório: vira o `aria-label`, já que o botão
553
+ * não tem texto. O tamanho acompanha a densidade (`--zur-control-height-*`).
554
+ *
555
+ * ```html
556
+ * <button zur-icon-button label="Excluir"><zur-icon [icon]="lixeira" /></button>
557
+ * ```
558
+ */
559
+ export declare class ZurIconButton {
560
+ /** Nome acessível do botão (obrigatório: não há texto visível). */
561
+ readonly label: import("@angular/core").InputSignal<string>;
562
+ readonly variant: import("@angular/core").InputSignal<ZurIconButtonVariant>;
563
+ readonly size: import("@angular/core").InputSignal<ZurIconButtonSize>;
564
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurIconButton, never>;
565
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurIconButton, "button[zur-icon-button]", never, {
566
+ "label": {
567
+ "alias": "label";
568
+ "required": true;
569
+ "isSignal": true;
570
+ };
571
+ "variant": {
572
+ "alias": "variant";
573
+ "required": false;
574
+ "isSignal": true;
575
+ };
576
+ "size": {
577
+ "alias": "size";
578
+ "required": false;
579
+ "isSignal": true;
580
+ };
581
+ }, {}, never, ["*"], true, never>;
582
+ }
583
+ /**
584
+ * Botão de ação flutuante: o atalho para a ação principal da tela. É circular, menta
585
+ * e usa a sombra única do sistema. `extended` mostra o texto ao lado do ícone; sem ele,
586
+ * informe `label` para o leitor de tela. O posicionamento (fixo no canto) é da aplicação.
587
+ *
588
+ * ```html
589
+ * <button zur-fab label="Novo pedido"><zur-icon [icon]="mais" size="24" /></button>
590
+ * <button zur-fab extended><zur-icon [icon]="mais" /> Novo pedido</button>
591
+ * ```
592
+ */
593
+ export declare class ZurFab {
594
+ readonly label: import("@angular/core").InputSignal<string>;
595
+ readonly extended: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
596
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurFab, never>;
597
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurFab, "button[zur-fab]", never, {
598
+ "label": {
599
+ "alias": "label";
600
+ "required": false;
601
+ "isSignal": true;
602
+ };
603
+ "extended": {
604
+ "alias": "extended";
605
+ "required": false;
606
+ "isSignal": true;
607
+ };
608
+ }, {}, never, ["*"], true, never>;
609
+ }
610
+ /**
611
+ * Link com o estilo do sistema (ink sublinhado). Com `external`, abre em outra aba com
612
+ * `rel="noopener noreferrer"`, mostra o ícone e avisa os leitores de tela.
613
+ *
614
+ * ```html
615
+ * <a zur-link href="/entregas">Política de entrega</a>
616
+ * <a zur-link external href="https://exemplo.com">Guia de rega</a>
617
+ * ```
618
+ */
619
+ export declare class ZurLink {
620
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
621
+ protected readonly iconExternal: import("@juau/zuri").ZurIconDef;
622
+ readonly external: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
623
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurLink, never>;
624
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurLink, "a[zur-link]", never, {
625
+ "external": {
626
+ "alias": "external";
627
+ "required": false;
628
+ "isSignal": true;
629
+ };
630
+ }, {}, never, ["*"], true, never>;
631
+ }
632
+ export type ZurDividerOrientation = 'horizontal' | 'vertical';
633
+ /**
634
+ * Linha fina que separa grupos de conteúdo. Com `label` mostra um texto no meio ("ou"),
635
+ * que também vira o nome acessível do separador.
636
+ *
637
+ * ```html
638
+ * <zur-divider />
639
+ * <zur-divider label="ou" />
640
+ * <zur-divider orientation="vertical" />
641
+ * ```
642
+ */
643
+ export declare class ZurDivider {
644
+ readonly orientation: import("@angular/core").InputSignal<ZurDividerOrientation>;
645
+ readonly label: import("@angular/core").InputSignal<string>;
646
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurDivider, never>;
647
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurDivider, "zur-divider", never, {
648
+ "orientation": {
649
+ "alias": "orientation";
650
+ "required": false;
651
+ "isSignal": true;
652
+ };
653
+ "label": {
654
+ "alias": "label";
655
+ "required": false;
656
+ "isSignal": true;
657
+ };
658
+ }, {}, never, never, true, never>;
659
+ }
426
660
  /**
427
661
  * Campo de texto do Zuri — 56px, label em caption acima,
428
662
  * foco com borda 2px ink (sem glow, Airbnb), erro em vermelho semântico.
@@ -690,8 +924,12 @@ export interface ZurComboboxOption {
690
924
  * iniciais). Navegação por setas, Enter escolhe, Esc fecha. Funciona com
691
925
  * `ngModel` e formulários reativos; o valor é o `value` da opção (ou `null`).
692
926
  *
927
+ * Com `multiple`, vira seleção múltipla: as escolhas aparecem como chips dentro do campo, a lista
928
+ * continua aberta ao escolher e o valor é um `string[]`.
929
+ *
693
930
  * ```html
694
931
  * <zur-combobox label="Planta" [options]="plantas" [(ngModel)]="planta" />
932
+ * <zur-combobox label="Ambientes" multiple [options]="ambientes" [(ngModel)]="escolhidos" />
695
933
  * ```
696
934
  */
697
935
  export declare class ZurCombobox implements ControlValueAccessor {
@@ -703,32 +941,43 @@ export declare class ZurCombobox implements ControlValueAccessor {
703
941
  readonly error: import("@angular/core").InputSignal<string>;
704
942
  readonly options: import("@angular/core").InputSignal<ZurComboboxOption[]>;
705
943
  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
944
+ /** Seleção múltipla: chips no campo, lista aberta ao escolher, valor `string[]`. */
945
+ readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
706
946
  protected readonly id: string;
707
947
  protected readonly listId: string;
708
948
  readonly value: import("@angular/core").WritableSignal<string | null>;
949
+ /** Valores escolhidos no modo `multiple`. */
950
+ readonly values: import("@angular/core").WritableSignal<string[]>;
951
+ protected readonly announcement: import("@angular/core").WritableSignal<string>;
709
952
  /** Texto digitado; `null` quando o campo só mostra o rótulo escolhido. */
710
953
  private readonly typed;
711
954
  readonly open: import("@angular/core").WritableSignal<boolean>;
712
955
  protected readonly activeIndex: import("@angular/core").WritableSignal<number>;
713
956
  protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
714
957
  private readonly selectedLabel;
958
+ protected readonly selectedOptions: import("@angular/core").Signal<ZurComboboxOption[]>;
715
959
  protected readonly query: import("@angular/core").Signal<string>;
716
960
  /** Enquanto o usuário não digita, mostra todas as opções. */
717
961
  protected readonly filtered: import("@angular/core").Signal<ZurComboboxOption[]>;
718
- protected onChange: (value: string | null) => void;
962
+ protected onChange: (value: string | string[] | null) => void;
719
963
  protected onTouched: () => void;
964
+ protected hasValue(): boolean;
965
+ protected isSelected(value: string): boolean;
720
966
  protected optionId(i: number): string;
721
967
  protected isDisabled(): boolean;
722
968
  protected openList(): void;
723
969
  protected onInput(event: Event): void;
724
970
  protected onKeydown(event: KeyboardEvent): void;
725
971
  select(option: ZurComboboxOption): void;
972
+ /** Marca ou desmarca uma opção no modo `multiple`; a lista continua aberta. */
973
+ toggle(option: ZurComboboxOption): void;
974
+ protected removeTag(value: string): void;
726
975
  clear(): void;
727
976
  /** Fecha a lista e restaura o texto para o rótulo escolhido. */
728
977
  private closeList;
729
978
  protected onFocusOut(event: FocusEvent): void;
730
- writeValue(value: string | null): void;
731
- registerOnChange(fn: (value: string | null) => void): void;
979
+ writeValue(value: string | string[] | null): void;
980
+ registerOnChange(fn: (value: string | string[] | null) => void): void;
732
981
  registerOnTouched(fn: () => void): void;
733
982
  setDisabledState(isDisabled: boolean): void;
734
983
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurCombobox, never>;
@@ -763,6 +1012,11 @@ export declare class ZurCombobox implements ControlValueAccessor {
763
1012
  "required": false;
764
1013
  "isSignal": true;
765
1014
  };
1015
+ "multiple": {
1016
+ "alias": "multiple";
1017
+ "required": false;
1018
+ "isSignal": true;
1019
+ };
766
1020
  }, {}, never, never, true, never>;
767
1021
  }
768
1022
  export type ZurDatePickerMode = 'single' | 'range';
@@ -1049,6 +1303,272 @@ export declare class ZurChips implements ControlValueAccessor {
1049
1303
  };
1050
1304
  }, {}, never, never, true, never>;
1051
1305
  }
1306
+ export type ZurChipVariant = 'assist' | 'filter' | 'choice';
1307
+ export type ZurChipGroupMode = 'single' | 'multiple';
1308
+ /**
1309
+ * Grupo de chips selecionáveis. `mode="single"` é um `radiogroup` (setas trocam a escolha, Tab sai do
1310
+ * grupo); `mode="multiple"` é um conjunto de botões de alternar (filtros). O valor é `string` ou
1311
+ * `string[]`, conforme o modo, e funciona com `ngModel`, formulários reativos, `[formField]` e
1312
+ * `[(value)]`.
1313
+ *
1314
+ * ```html
1315
+ * <zur-chip-group label="Ambiente" mode="single" [(ngModel)]="ambiente">
1316
+ * <zur-chip value="sala">Sala</zur-chip>
1317
+ * <zur-chip value="varanda">Varanda</zur-chip>
1318
+ * </zur-chip-group>
1319
+ * ```
1320
+ *
1321
+ * Não confundir com `zur-chips`, o campo em que a pessoa digita para criar tags.
1322
+ */
1323
+ export declare class ZurChipGroup implements ControlValueAccessor {
1324
+ private readonly host;
1325
+ readonly label: import("@angular/core").InputSignal<string>;
1326
+ readonly mode: import("@angular/core").InputSignal<ZurChipGroupMode>;
1327
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
1328
+ readonly value: import("@angular/core").ModelSignal<string | string[] | null>;
1329
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
1330
+ protected onChange: (value: string | string[] | null) => void;
1331
+ protected onTouched: () => void;
1332
+ isDisabled(): boolean;
1333
+ isSelected(value: string): boolean;
1334
+ /** Escolhe (single) ou alterna (multiple) um valor. */
1335
+ toggle(value: string): void;
1336
+ protected onKeydown(event: KeyboardEvent): void;
1337
+ writeValue(value: string | string[] | null): void;
1338
+ registerOnChange(fn: (value: string | string[] | null) => void): void;
1339
+ registerOnTouched(fn: () => void): void;
1340
+ setDisabledState(isDisabled: boolean): void;
1341
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurChipGroup, never>;
1342
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurChipGroup, "zur-chip-group", never, {
1343
+ "label": {
1344
+ "alias": "label";
1345
+ "required": false;
1346
+ "isSignal": true;
1347
+ };
1348
+ "mode": {
1349
+ "alias": "mode";
1350
+ "required": false;
1351
+ "isSignal": true;
1352
+ };
1353
+ "disabled": {
1354
+ "alias": "disabled";
1355
+ "required": false;
1356
+ "isSignal": true;
1357
+ };
1358
+ "value": {
1359
+ "alias": "value";
1360
+ "required": false;
1361
+ "isSignal": true;
1362
+ };
1363
+ }, {
1364
+ "value": "valueChange";
1365
+ }, never, ["*"], true, never>;
1366
+ }
1367
+ /**
1368
+ * Chip interativo: `assist` (ação rápida, use `(click)`), `filter` (liga e desliga, `[(selected)]`) e
1369
+ * `choice` (dentro de um `zur-chip-group`, com `value`). O estado selecionado tem ✓ e borda de ink,
1370
+ * não só cor. Com `removable`, mostra um ✕ que emite `removed`.
1371
+ *
1372
+ * ```html
1373
+ * <zur-chip variant="filter" [(selected)]="soSol">Pleno sol</zur-chip>
1374
+ * <zur-chip removable label="Sala" (removed)="tirar('sala')">Sala</zur-chip>
1375
+ * ```
1376
+ */
1377
+ export declare class ZurChip {
1378
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1379
+ protected readonly host: ElementRef<HTMLElement>;
1380
+ private readonly group;
1381
+ readonly variant: import("@angular/core").InputSignal<ZurChipVariant>;
1382
+ /** Valor do chip dentro de um `zur-chip-group` (obrigatório lá). */
1383
+ readonly value: import("@angular/core").InputSignal<string>;
1384
+ /** Nome para o botão de remover; sem ele usa o texto do chip. */
1385
+ readonly label: import("@angular/core").InputSignal<string>;
1386
+ readonly selected: import("@angular/core").ModelSignal<boolean>;
1387
+ readonly removable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
1388
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
1389
+ readonly removed: import("@angular/core").OutputEmitterRef<void>;
1390
+ protected selectable(): boolean;
1391
+ protected isDisabled(): boolean;
1392
+ protected isSelected(): boolean;
1393
+ protected role(): string | null;
1394
+ protected pressed(): boolean | null;
1395
+ /** Em grupo `single`, só a escolha atual (ou todos, se nada foi escolhido) recebe o Tab. */
1396
+ protected tabStop(): boolean;
1397
+ protected onClick(): void;
1398
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurChip, never>;
1399
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurChip, "zur-chip", never, {
1400
+ "variant": {
1401
+ "alias": "variant";
1402
+ "required": false;
1403
+ "isSignal": true;
1404
+ };
1405
+ "value": {
1406
+ "alias": "value";
1407
+ "required": false;
1408
+ "isSignal": true;
1409
+ };
1410
+ "label": {
1411
+ "alias": "label";
1412
+ "required": false;
1413
+ "isSignal": true;
1414
+ };
1415
+ "selected": {
1416
+ "alias": "selected";
1417
+ "required": false;
1418
+ "isSignal": true;
1419
+ };
1420
+ "removable": {
1421
+ "alias": "removable";
1422
+ "required": false;
1423
+ "isSignal": true;
1424
+ };
1425
+ "disabled": {
1426
+ "alias": "disabled";
1427
+ "required": false;
1428
+ "isSignal": true;
1429
+ };
1430
+ }, {
1431
+ "selected": "selectedChange";
1432
+ "removed": "removed";
1433
+ }, never, ["*"], true, never>;
1434
+ }
1435
+ /**
1436
+ * Campo de busca: ícone de lupa, botão de limpar, Esc limpa e Enter envia. `searchChange` emite
1437
+ * enquanto a pessoa digita (com `debounceMs`, espera ela parar) e `submitted` emite no Enter.
1438
+ *
1439
+ * ```html
1440
+ * <zur-search label="Buscar plantas" [debounceMs]="250" (searchChange)="filtrar($event)" />
1441
+ * ```
1442
+ */
1443
+ export declare class ZurSearch implements ControlValueAccessor {
1444
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1445
+ private readonly destroyRef;
1446
+ private readonly host;
1447
+ /** Nome acessível; sem ele usa "Buscar". */
1448
+ readonly label: import("@angular/core").InputSignal<string>;
1449
+ readonly placeholder: import("@angular/core").InputSignal<string>;
1450
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
1451
+ /** Espera (ms) depois da última tecla antes de emitir `searchChange`; `0` emite na hora. */
1452
+ readonly debounceMs: import("@angular/core").InputSignalWithTransform<number, unknown>;
1453
+ readonly searchChange: import("@angular/core").OutputEmitterRef<string>;
1454
+ readonly submitted: import("@angular/core").OutputEmitterRef<string>;
1455
+ protected readonly id: string;
1456
+ protected readonly iconSearch: import("@juau/zuri").ZurIconDef;
1457
+ protected readonly iconX: import("@juau/zuri").ZurIconDef;
1458
+ protected readonly value: import("@angular/core").WritableSignal<string>;
1459
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
1460
+ private timer;
1461
+ protected onChange: (value: string) => void;
1462
+ protected onTouched: () => void;
1463
+ constructor();
1464
+ protected isDisabled(): boolean;
1465
+ protected onInput(event: Event): void;
1466
+ protected onKeydown(event: KeyboardEvent): void;
1467
+ clear(): void;
1468
+ writeValue(value: string | null): void;
1469
+ registerOnChange(fn: (value: string) => void): void;
1470
+ registerOnTouched(fn: () => void): void;
1471
+ setDisabledState(isDisabled: boolean): void;
1472
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSearch, never>;
1473
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSearch, "zur-search", never, {
1474
+ "label": {
1475
+ "alias": "label";
1476
+ "required": false;
1477
+ "isSignal": true;
1478
+ };
1479
+ "placeholder": {
1480
+ "alias": "placeholder";
1481
+ "required": false;
1482
+ "isSignal": true;
1483
+ };
1484
+ "disabled": {
1485
+ "alias": "disabled";
1486
+ "required": false;
1487
+ "isSignal": true;
1488
+ };
1489
+ "debounceMs": {
1490
+ "alias": "debounceMs";
1491
+ "required": false;
1492
+ "isSignal": true;
1493
+ };
1494
+ }, {
1495
+ "searchChange": "searchChange";
1496
+ "submitted": "submitted";
1497
+ }, never, never, true, never>;
1498
+ }
1499
+ /**
1500
+ * Texto editável no lugar. Em leitura é um botão com o valor; clique, Enter ou F2 abrem o campo.
1501
+ * Enter salva (em `multiline`, Ctrl/⌘+Enter), Esc cancela e sair do campo salva. O foco volta ao
1502
+ * botão e um aviso (`aria-live`) diz o que aconteceu.
1503
+ *
1504
+ * ```html
1505
+ * <zur-inline-edit label="Nome do pedido" [(ngModel)]="nome" (saved)="persistir($event)" />
1506
+ * ```
1507
+ */
1508
+ export declare class ZurInlineEdit implements ControlValueAccessor {
1509
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1510
+ private readonly host;
1511
+ private readonly injector;
1512
+ /** Nome acessível do campo (o que está sendo editado). */
1513
+ readonly label: import("@angular/core").InputSignal<string>;
1514
+ /** Texto mostrado, em muted, quando o valor está vazio. */
1515
+ readonly placeholder: import("@angular/core").InputSignal<string>;
1516
+ readonly multiline: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
1517
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
1518
+ /** Emite o novo valor quando a edição é salva (e só se mudou). */
1519
+ readonly saved: import("@angular/core").OutputEmitterRef<string>;
1520
+ protected readonly iconCheck: import("@juau/zuri").ZurIconDef;
1521
+ protected readonly iconX: import("@juau/zuri").ZurIconDef;
1522
+ protected readonly iconPencil: import("@juau/zuri").ZurIconDef;
1523
+ readonly value: import("@angular/core").WritableSignal<string>;
1524
+ protected readonly editing: import("@angular/core").WritableSignal<boolean>;
1525
+ protected readonly draft: import("@angular/core").WritableSignal<string>;
1526
+ protected readonly announcement: import("@angular/core").WritableSignal<string>;
1527
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
1528
+ protected onChange: (value: string) => void;
1529
+ protected onTouched: () => void;
1530
+ protected isDisabled(): boolean;
1531
+ start(): void;
1532
+ commit(): void;
1533
+ cancel(): void;
1534
+ private finish;
1535
+ protected onKeydown(event: KeyboardEvent): void;
1536
+ protected onReadKeydown(event: KeyboardEvent): void;
1537
+ /**
1538
+ * Sair do campo (para fora do componente) salva. Só conta o `focusout` que vem do editor: ao
1539
+ * abrir, o botão de leitura que tinha o foco sai do DOM e o navegador também emite `focusout`.
1540
+ */
1541
+ protected onFocusOut(event: FocusEvent): void;
1542
+ writeValue(value: string | null): void;
1543
+ registerOnChange(fn: (value: string) => void): void;
1544
+ registerOnTouched(fn: () => void): void;
1545
+ setDisabledState(isDisabled: boolean): void;
1546
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurInlineEdit, never>;
1547
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurInlineEdit, "zur-inline-edit", never, {
1548
+ "label": {
1549
+ "alias": "label";
1550
+ "required": false;
1551
+ "isSignal": true;
1552
+ };
1553
+ "placeholder": {
1554
+ "alias": "placeholder";
1555
+ "required": false;
1556
+ "isSignal": true;
1557
+ };
1558
+ "multiline": {
1559
+ "alias": "multiline";
1560
+ "required": false;
1561
+ "isSignal": true;
1562
+ };
1563
+ "disabled": {
1564
+ "alias": "disabled";
1565
+ "required": false;
1566
+ "isSignal": true;
1567
+ };
1568
+ }, {
1569
+ "saved": "saved";
1570
+ }, never, never, true, never>;
1571
+ }
1052
1572
  /**
1053
1573
  * Controle deslizante. Com `range`, tem dois controles e o valor é `[mínimo, máximo]`;
1054
1574
  * sem, é um número. Teclado: setas (±step), PageUp/PageDown (±10 steps), Home/End.
@@ -1595,6 +2115,72 @@ export declare class ZurTabs {
1595
2115
  "index": "indexChange";
1596
2116
  }, ["tabs"], ["*"], true, never>;
1597
2117
  }
2118
+ /**
2119
+ * Barra de navegação inferior para celular: de 3 a 5 destinos principais, cada um com ícone e
2120
+ * rótulo. Respeita a área segura do aparelho (`safe-area-inset-bottom`). Por padrão fica fixa na
2121
+ * base da tela e some a partir de 768 px, onde a sidebar ou a navbar assumem.
2122
+ *
2123
+ * ```html
2124
+ * <zur-bottom-nav label="Navegação principal">
2125
+ * <a zur-bottom-nav-item href="/" active>
2126
+ * <zur-icon zurBottomNavIcon [icon]="casa" /> Início
2127
+ * </a>
2128
+ * <a zur-bottom-nav-item href="/pedidos" [badge]="3">
2129
+ * <zur-icon zurBottomNavIcon [icon]="sino" /> Pedidos
2130
+ * </a>
2131
+ * </zur-bottom-nav>
2132
+ * ```
2133
+ */
2134
+ export declare class ZurBottomNav {
2135
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
2136
+ /** Nome acessível da região; sem ele usa "Navegação inferior". */
2137
+ readonly label: import("@angular/core").InputSignal<string>;
2138
+ /** Fixa na base da tela. Desligue para posicionar você mesmo. */
2139
+ readonly fixed: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
2140
+ /** Esconde a barra a partir de 768 px. Desligue para mostrá-la em qualquer largura. */
2141
+ readonly responsive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
2142
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurBottomNav, never>;
2143
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurBottomNav, "zur-bottom-nav", never, {
2144
+ "label": {
2145
+ "alias": "label";
2146
+ "required": false;
2147
+ "isSignal": true;
2148
+ };
2149
+ "fixed": {
2150
+ "alias": "fixed";
2151
+ "required": false;
2152
+ "isSignal": true;
2153
+ };
2154
+ "responsive": {
2155
+ "alias": "responsive";
2156
+ "required": false;
2157
+ "isSignal": true;
2158
+ };
2159
+ }, {}, never, ["*"], true, never>;
2160
+ }
2161
+ /**
2162
+ * Destino da barra inferior: um `<a>` ou `<button>`. `active` marca a página atual
2163
+ * (`aria-current="page"`) e `badge` mostra um número, ou um ponto com `"dot"`.
2164
+ */
2165
+ export declare class ZurBottomNavItem {
2166
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
2167
+ readonly active: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
2168
+ /** Número de novidades, ou `"dot"` para só um ponto. */
2169
+ readonly badge: import("@angular/core").InputSignal<number | "dot" | null>;
2170
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurBottomNavItem, never>;
2171
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurBottomNavItem, "a[zur-bottom-nav-item], button[zur-bottom-nav-item]", never, {
2172
+ "active": {
2173
+ "alias": "active";
2174
+ "required": false;
2175
+ "isSignal": true;
2176
+ };
2177
+ "badge": {
2178
+ "alias": "badge";
2179
+ "required": false;
2180
+ "isSignal": true;
2181
+ };
2182
+ }, {}, never, ["[zurBottomNavIcon]", "*"], true, never>;
2183
+ }
1598
2184
  /** Item clicável dentro de <zur-menu>. */
1599
2185
  export declare class ZurMenuItem {
1600
2186
  readonly selected: import("@angular/core").OutputEmitterRef<void>;
@@ -1691,6 +2277,11 @@ export interface ZurColumnFilterChange {
1691
2277
  key: string;
1692
2278
  value: string;
1693
2279
  }
2280
+ /** Largura nova de uma coluna redimensionada. */
2281
+ export interface ZurColumnResize {
2282
+ key: string;
2283
+ width: number;
2284
+ }
1694
2285
  /**
1695
2286
  * Estilo do Zuri para uma `<table>` nativa: cabeçalho em caption, linhas com
1696
2287
  * hairline, hover e densidade. A ordenação fica com você: marque as colunas com
@@ -1711,6 +2302,16 @@ export declare class ZurTable {
1711
2302
  /** Emite a coluna e a direção sempre que o usuário ordena. */
1712
2303
  readonly sortChange: import("@angular/core").OutputEmitterRef<ZurSort>;
1713
2304
  readonly sort: import("@angular/core").WritableSignal<ZurSort | null>;
2305
+ /** Mantém o cabeçalho visível ao rolar (a tabela vai dentro de `.zur-table-scroll`). */
2306
+ readonly stickyHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
2307
+ /** Mantém a primeira coluna visível na rolagem horizontal. */
2308
+ readonly stickyFirstColumn: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
2309
+ /** Emite a nova largura (px) quando uma coluna `zurResizable` é redimensionada. */
2310
+ readonly columnResize: import("@angular/core").OutputEmitterRef<ZurColumnResize>;
2311
+ /** `true` enquanto há um `tbody[zurTableSkeleton]` na tabela (marca `aria-busy`). */
2312
+ readonly busy: import("@angular/core").WritableSignal<boolean>;
2313
+ /** Quantidade de colunas redimensionáveis (liga `table-layout: fixed`). */
2314
+ readonly resizableCount: import("@angular/core").WritableSignal<number>;
1714
2315
  /** Ids das linhas selecionadas (two-way). Veja `tr[zurRow]`, `th[zurSelectAll]` e `td[zurSelect]`. */
1715
2316
  readonly selected: import("@angular/core").ModelSignal<string[]>;
1716
2317
  /** Emite quando o texto de filtro de uma coluna muda (`zur-column-filter`). */
@@ -1736,6 +2337,16 @@ export declare class ZurTable {
1736
2337
  "required": false;
1737
2338
  "isSignal": true;
1738
2339
  };
2340
+ "stickyHeader": {
2341
+ "alias": "stickyHeader";
2342
+ "required": false;
2343
+ "isSignal": true;
2344
+ };
2345
+ "stickyFirstColumn": {
2346
+ "alias": "stickyFirstColumn";
2347
+ "required": false;
2348
+ "isSignal": true;
2349
+ };
1739
2350
  "selected": {
1740
2351
  "alias": "selected";
1741
2352
  "required": false;
@@ -1743,6 +2354,7 @@ export declare class ZurTable {
1743
2354
  };
1744
2355
  }, {
1745
2356
  "sortChange": "sortChange";
2357
+ "columnResize": "columnResize";
1746
2358
  "selected": "selectedChange";
1747
2359
  "filterChange": "filterChange";
1748
2360
  }, never, ["*"], true, never>;
@@ -1904,6 +2516,109 @@ export declare class ZurColumnMenu {
1904
2516
  "visible": "visibleChange";
1905
2517
  }, never, never, true, never>;
1906
2518
  }
2519
+ /**
2520
+ * Torna a coluna redimensionável: uma alça no fim da célula do cabeçalho arrasta com o mouse ou o
2521
+ * toque e também funciona pelo teclado (←/→ mudam 8 px, com Shift 32 px). O valor é a chave da
2522
+ * coluna; a largura nova sai em `columnResize` da tabela. Convive com `zurSortable`.
2523
+ *
2524
+ * ```html
2525
+ * <th zurSortable="nome" zurResizable="nome">Nome</th>
2526
+ * ```
2527
+ */
2528
+ export declare class ZurResizable {
2529
+ private readonly table;
2530
+ private readonly i18n;
2531
+ private readonly el;
2532
+ private readonly renderer;
2533
+ private readonly injector;
2534
+ readonly zurResizable: import("@angular/core").InputSignal<string>;
2535
+ readonly minWidth: import("@angular/core").InputSignalWithTransform<number, unknown>;
2536
+ readonly maxWidth: import("@angular/core").InputSignalWithTransform<number, unknown>;
2537
+ private handle;
2538
+ constructor();
2539
+ private clamp;
2540
+ private apply;
2541
+ private createHandle;
2542
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurResizable, never>;
2543
+ static ɵdir: i0.ɵɵDirectiveDeclaration<ZurResizable, "th[zurResizable]", never, {
2544
+ "zurResizable": {
2545
+ "alias": "zurResizable";
2546
+ "required": true;
2547
+ "isSignal": true;
2548
+ };
2549
+ "minWidth": {
2550
+ "alias": "minWidth";
2551
+ "required": false;
2552
+ "isSignal": true;
2553
+ };
2554
+ "maxWidth": {
2555
+ "alias": "maxWidth";
2556
+ "required": false;
2557
+ "isSignal": true;
2558
+ };
2559
+ }, {}, never, never, true, never>;
2560
+ }
2561
+ /**
2562
+ * Barra acima da tabela. Em repouso mostra o que você projetar (busca, filtros, botão de
2563
+ * exportar); com linhas selecionadas (`[selectedCount]`) troca para a barra de lote: contagem, as
2564
+ * ações de `[zurTableToolbarBatch]` e "Limpar seleção". A contagem é anunciada para leitores de tela.
2565
+ *
2566
+ * ```html
2567
+ * <zur-table-toolbar [selectedCount]="marcadas().length" (clearSelection)="marcadas.set([])">
2568
+ * <zur-search label="Buscar pedidos" />
2569
+ * <button zurTableToolbarBatch zur-button size="sm" variant="danger">Excluir</button>
2570
+ * </zur-table-toolbar>
2571
+ * ```
2572
+ */
2573
+ export declare class ZurTableToolbar {
2574
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
2575
+ /** Linhas selecionadas; maior que zero liga a barra de lote. */
2576
+ readonly selectedCount: import("@angular/core").InputSignalWithTransform<number, unknown>;
2577
+ readonly clearSelection: import("@angular/core").OutputEmitterRef<void>;
2578
+ protected readonly batch: import("@angular/core").Signal<boolean>;
2579
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTableToolbar, never>;
2580
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurTableToolbar, "zur-table-toolbar", never, {
2581
+ "selectedCount": {
2582
+ "alias": "selectedCount";
2583
+ "required": false;
2584
+ "isSignal": true;
2585
+ };
2586
+ }, {
2587
+ "clearSelection": "clearSelection";
2588
+ }, never, ["[zurTableToolbarBatch]", "*"], true, never>;
2589
+ }
2590
+ /**
2591
+ * Corpo de carregamento: `rows` linhas de `columns` células em skeleton, e a tabela fica com
2592
+ * `aria-busy` e um aviso "Carregando dados" para leitores de tela. Troque pelo `tbody` real
2593
+ * quando os dados chegarem.
2594
+ *
2595
+ * ```html
2596
+ * @if (carregando()) { <tbody zurTableSkeleton [rows]="5" [columns]="4"></tbody> } @else { <tbody>…</tbody> }
2597
+ * ```
2598
+ */
2599
+ export declare class ZurTableSkeleton {
2600
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
2601
+ private readonly table;
2602
+ readonly rows: import("@angular/core").InputSignalWithTransform<number, unknown>;
2603
+ readonly columns: import("@angular/core").InputSignalWithTransform<number, unknown>;
2604
+ protected readonly widths: string[];
2605
+ protected readonly rowList: import("@angular/core").Signal<number[]>;
2606
+ protected readonly colList: import("@angular/core").Signal<number[]>;
2607
+ constructor();
2608
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTableSkeleton, never>;
2609
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurTableSkeleton, "tbody[zurTableSkeleton]", never, {
2610
+ "rows": {
2611
+ "alias": "rows";
2612
+ "required": false;
2613
+ "isSignal": true;
2614
+ };
2615
+ "columns": {
2616
+ "alias": "columns";
2617
+ "required": false;
2618
+ "isSignal": true;
2619
+ };
2620
+ }, {}, never, never, true, never>;
2621
+ }
1907
2622
  export type ZurChartType = 'bar' | 'line' | 'area' | 'donut';
1908
2623
  export interface ZurChartSeries {
1909
2624
  name: string;
@@ -2478,6 +3193,163 @@ export declare class ZurStep {
2478
3193
  };
2479
3194
  }, {}, never, ["*"], true, never>;
2480
3195
  }
3196
+ /**
3197
+ * Bloco de código com botão de copiar. O texto é sempre da esquerda para a direita (também em RTL),
3198
+ * o botão anuncia "Copiado" ou "Não foi possível copiar" para leitores de tela e a área rola na
3199
+ * horizontal com o teclado.
3200
+ *
3201
+ * ```html
3202
+ * <zur-code-snippet language="bash" code="npm install @juau/zuri" />
3203
+ * ```
3204
+ */
3205
+ export declare class ZurCodeSnippet {
3206
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
3207
+ readonly code: import("@angular/core").InputSignal<string>;
3208
+ /** Rótulo da linguagem mostrado no topo ("bash", "html"…). */
3209
+ readonly language: import("@angular/core").InputSignal<string>;
3210
+ /** Nome acessível do bloco; sem ele usa a linguagem. */
3211
+ readonly label: import("@angular/core").InputSignal<string>;
3212
+ protected readonly iconCopy: import("@juau/zuri").ZurIconDef;
3213
+ protected readonly iconCheck: import("@juau/zuri").ZurIconDef;
3214
+ protected readonly copied: import("@angular/core").WritableSignal<boolean>;
3215
+ protected readonly announcement: import("@angular/core").WritableSignal<string>;
3216
+ private timer;
3217
+ constructor();
3218
+ copy(): Promise<void>;
3219
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurCodeSnippet, never>;
3220
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurCodeSnippet, "zur-code-snippet", never, {
3221
+ "code": {
3222
+ "alias": "code";
3223
+ "required": true;
3224
+ "isSignal": true;
3225
+ };
3226
+ "language": {
3227
+ "alias": "language";
3228
+ "required": false;
3229
+ "isSignal": true;
3230
+ };
3231
+ "label": {
3232
+ "alias": "label";
3233
+ "required": false;
3234
+ "isSignal": true;
3235
+ };
3236
+ }, {}, never, never, true, never>;
3237
+ }
3238
+ export type ZurListSelection = 'none' | 'single' | 'multiple';
3239
+ /**
3240
+ * Lista vertical de itens com área para ícone/avatar, texto principal, texto secundário e ação.
3241
+ * Com `selection="single" | "multiple"` vira um `listbox`: setas movem o foco, Espaço/Enter escolhem
3242
+ * e o valor (`string` ou `string[]`) funciona com `ngModel`, formulários reativos e `[formField]`.
3243
+ *
3244
+ * ```html
3245
+ * <zur-list label="Pedidos" selection="single" contained divided [(ngModel)]="pedido">
3246
+ * <zur-list-item value="42">
3247
+ * <zur-avatar zurListLeading name="Ana Silva" size="sm" />
3248
+ * Pedido 42
3249
+ * <span zurListSecondary>Monstera e vaso</span>
3250
+ * <zur-badge zurListTrailing>Enviado</zur-badge>
3251
+ * </zur-list-item>
3252
+ * </zur-list>
3253
+ * ```
3254
+ */
3255
+ export declare class ZurList implements ControlValueAccessor {
3256
+ readonly label: import("@angular/core").InputSignal<string>;
3257
+ readonly selection: import("@angular/core").InputSignal<ZurListSelection>;
3258
+ /** Borda e raio de 14 px em volta da lista. */
3259
+ readonly contained: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
3260
+ /** Fio entre os itens. */
3261
+ readonly divided: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
3262
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
3263
+ readonly value: import("@angular/core").ModelSignal<string | string[] | null>;
3264
+ protected readonly items: import("@angular/core").Signal<readonly any[]>;
3265
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
3266
+ private readonly focused;
3267
+ protected onChange: (value: string | string[] | null) => void;
3268
+ protected onTouched: () => void;
3269
+ readonly selectable: import("@angular/core").Signal<boolean>;
3270
+ isDisabled(): boolean;
3271
+ isSelected(value: string): boolean;
3272
+ /** Valor do item que recebe o Tab: o último focado, o escolhido ou o primeiro habilitado. */
3273
+ readonly tabValue: import("@angular/core").Signal<any>;
3274
+ select(value: string): void;
3275
+ protected onFocusIn(event: FocusEvent): void;
3276
+ protected onKeydown(event: KeyboardEvent): void;
3277
+ writeValue(value: string | string[] | null): void;
3278
+ registerOnChange(fn: (value: string | string[] | null) => void): void;
3279
+ registerOnTouched(fn: () => void): void;
3280
+ setDisabledState(isDisabled: boolean): void;
3281
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurList, never>;
3282
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurList, "zur-list", never, {
3283
+ "label": {
3284
+ "alias": "label";
3285
+ "required": false;
3286
+ "isSignal": true;
3287
+ };
3288
+ "selection": {
3289
+ "alias": "selection";
3290
+ "required": false;
3291
+ "isSignal": true;
3292
+ };
3293
+ "contained": {
3294
+ "alias": "contained";
3295
+ "required": false;
3296
+ "isSignal": true;
3297
+ };
3298
+ "divided": {
3299
+ "alias": "divided";
3300
+ "required": false;
3301
+ "isSignal": true;
3302
+ };
3303
+ "disabled": {
3304
+ "alias": "disabled";
3305
+ "required": false;
3306
+ "isSignal": true;
3307
+ };
3308
+ "value": {
3309
+ "alias": "value";
3310
+ "required": false;
3311
+ "isSignal": true;
3312
+ };
3313
+ }, {
3314
+ "value": "valueChange";
3315
+ }, ["items"], ["*"], true, never>;
3316
+ }
3317
+ /**
3318
+ * Item da lista. Slots: `[zurListLeading]` (ícone, avatar), o texto principal, `[zurListSecondary]`
3319
+ * e `[zurListTrailing]` (badge, botão). Com `interactive` (fora de uma lista selecionável) a linha
3320
+ * vira um botão e o `(click)` do item funciona.
3321
+ */
3322
+ export declare class ZurListItem {
3323
+ readonly el: ElementRef<HTMLElement>;
3324
+ protected readonly list: ZurList | null;
3325
+ /** Identifica o item nas listas selecionáveis (obrigatório lá). */
3326
+ readonly value: import("@angular/core").InputSignal<string>;
3327
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
3328
+ /** Linha clicável (botão), para listas que não são de seleção. */
3329
+ readonly interactive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
3330
+ isDisabled(): boolean;
3331
+ protected selected(): boolean;
3332
+ protected isTabStop(): boolean;
3333
+ protected onClick(): void;
3334
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurListItem, never>;
3335
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurListItem, "zur-list-item", never, {
3336
+ "value": {
3337
+ "alias": "value";
3338
+ "required": false;
3339
+ "isSignal": true;
3340
+ };
3341
+ "disabled": {
3342
+ "alias": "disabled";
3343
+ "required": false;
3344
+ "isSignal": true;
3345
+ };
3346
+ "interactive": {
3347
+ "alias": "interactive";
3348
+ "required": false;
3349
+ "isSignal": true;
3350
+ };
3351
+ }, {}, never, ["[zurListLeading]", "*", "[zurListSecondary]", "[zurListTrailing]"], true, never>;
3352
+ }
2481
3353
  export type ZurStepperOrientation = 'horizontal' | 'vertical';
2482
3354
  export type ZurStepStatus = 'done' | 'current' | 'upcoming' | 'error';
2483
3355
  /** Conteúdo de uma etapa do `zur-stepper`; só a etapa atual é mostrada. */
@@ -2902,16 +3774,51 @@ export declare class ZurModal {
2902
3774
  }, never, ["*", "[zurModalActions]"], true, never>;
2903
3775
  }
2904
3776
  export type ZurToastKind = 'neutral' | 'success' | 'error';
3777
+ export interface ZurToastAction {
3778
+ /** Texto do botão ("Desfazer"). */
3779
+ label: string;
3780
+ /** Roda ao clicar; o toast fecha em seguida. */
3781
+ handler: () => void;
3782
+ }
3783
+ export interface ZurToastOptions {
3784
+ /** Tempo na tela em ms. Padrão: 4000, ou 8000 quando há ação. */
3785
+ durationMs?: number;
3786
+ /** Botão de texto dentro do toast, para desfazer ou abrir algo. */
3787
+ action?: ZurToastAction;
3788
+ /** Não fecha sozinho: só pelo ✕, pela ação ou por `dismiss`. */
3789
+ persistent?: boolean;
3790
+ }
2905
3791
  export interface ZurToast {
2906
3792
  id: number;
2907
3793
  message: string;
2908
3794
  kind: ZurToastKind;
3795
+ action?: ZurToastAction;
3796
+ persistent: boolean;
2909
3797
  }
2910
- /** Fila de toasts — use junto com <zur-toast-container>. */
3798
+ /**
3799
+ * Fila de toasts — use junto com <zur-toast-container>.
3800
+ *
3801
+ * O tempo de cada toast pausa enquanto o ponteiro ou o foco estão sobre a pilha (WCAG 2.2.1) e
3802
+ * continua de onde parou. `show` devolve o id, para fechar por `dismiss(id)`.
3803
+ *
3804
+ * ```ts
3805
+ * toast.show('Planta removida', 'neutral', { action: { label: 'Desfazer', handler: () => restaurar() } });
3806
+ * toast.show('Sem conexão', 'error', { persistent: true });
3807
+ * toast.show('Salvo', 'success', 2000); // forma curta: só a duração
3808
+ * ```
3809
+ */
2911
3810
  export declare class ZurToastService {
2912
3811
  readonly toasts: import("@angular/core").WritableSignal<ZurToast[]>;
2913
- show(message: string, kind?: ZurToastKind, durationMs?: number): void;
3812
+ private readonly timers;
3813
+ private paused;
3814
+ show(message: string, kind?: ZurToastKind, options?: number | ZurToastOptions): number;
2914
3815
  dismiss(id: number): void;
3816
+ dismissAll(): void;
3817
+ /** Congela o tempo de todos os toasts (o container chama com ponteiro ou foco sobre a pilha). */
3818
+ pauseAll(): void;
3819
+ /** Retoma o tempo que faltava de cada toast. */
3820
+ resumeAll(): void;
3821
+ private start;
2915
3822
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurToastService, never>;
2916
3823
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
2917
3824
  }
@@ -2922,6 +3829,11 @@ export declare class ZurToastService {
2922
3829
  export declare class ZurToastContainer {
2923
3830
  protected readonly i18n: import("@juau/zuri").ZurI18n;
2924
3831
  protected readonly service: ZurToastService;
3832
+ /** O tempo dos toasts pausa com o ponteiro ou o foco sobre a pilha. */
3833
+ protected hovering: boolean;
3834
+ protected focusWithin: boolean;
3835
+ protected sync(): void;
3836
+ protected onFocusOut(event: FocusEvent): void;
2925
3837
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurToastContainer, never>;
2926
3838
  static ɵcmp: i0.ɵɵComponentDeclaration<ZurToastContainer, "zur-toast-container", never, {}, {}, never, never, true, never>;
2927
3839
  }
@@ -3084,8 +3996,11 @@ export declare class ZurProgress {
3084
3996
  };
3085
3997
  }, {}, never, never, true, never>;
3086
3998
  }
3087
- /** `start`/`end` seguem a direção de leitura (em RTL trocam de lado); `left`/`right` são físicos. */
3088
- export type ZurDrawerSide = 'start' | 'end' | 'left' | 'right';
3999
+ /**
4000
+ * `start`/`end` seguem a direção de leitura (em RTL trocam de lado); `left`/`right` são físicos.
4001
+ * `bottom` é o bottom sheet: sobe da borda inferior, tem alça e fecha arrastando para baixo.
4002
+ */
4003
+ export type ZurDrawerSide = 'start' | 'end' | 'left' | 'right' | 'bottom';
3089
4004
  /**
3090
4005
  * Painel lateral deslizante (gaveta) sobre a página, para filtros, detalhes ou
3091
4006
  * formulários curtos. Fecha com ESC, clique no fundo ou no botão de fechar; o foco
@@ -3094,6 +4009,7 @@ export type ZurDrawerSide = 'start' | 'end' | 'left' | 'right';
3094
4009
  * ```html
3095
4010
  * <button zur-button (click)="filtros = true">Filtros</button>
3096
4011
  * <zur-drawer [(open)]="filtros" title="Filtros">…</zur-drawer>
4012
+ * <zur-drawer [(open)]="opcoes" side="bottom" title="Opções">…</zur-drawer> // bottom sheet
3097
4013
  * ```
3098
4014
  */
3099
4015
  export declare class ZurDrawer {
@@ -3103,9 +4019,17 @@ export declare class ZurDrawer {
3103
4019
  readonly title: import("@angular/core").InputSignal<string>;
3104
4020
  readonly side: import("@angular/core").InputSignal<ZurDrawerSide>;
3105
4021
  private readonly panel;
4022
+ /** Deslocamento (px) do bottom sheet enquanto é arrastado para baixo. */
4023
+ protected readonly dragY: import("@angular/core").WritableSignal<number>;
4024
+ protected readonly dragging: import("@angular/core").WritableSignal<boolean>;
4025
+ private dragStartY;
3106
4026
  private returnFocusTo;
3107
4027
  constructor();
3108
4028
  close(): void;
4029
+ protected dragStart(event: PointerEvent): void;
4030
+ protected dragMove(event: PointerEvent): void;
4031
+ /** Solta: fecha se foi arrastado além de 100 px (ou 30% da altura); senão volta ao lugar. */
4032
+ protected dragEnd(event: PointerEvent): void;
3109
4033
  /** Mantém o Tab circulando dentro do painel. */
3110
4034
  protected trapFocus(event: KeyboardEvent): void;
3111
4035
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurDrawer, never>;