@juau/zuri 0.0.1 → 0.2.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.
@@ -1,6 +1,109 @@
1
1
  import * as i0 from "@angular/core";
2
- import { ElementRef, InjectionToken, OnDestroy, OnInit } from "@angular/core";
2
+ import { ElementRef, InjectionToken, OnDestroy, OnInit, Provider, TemplateRef } from "@angular/core";
3
3
  import { ControlValueAccessor } from "@angular/forms";
4
+ /**
5
+ * Textos que os componentes do Zuri mostram ou anunciam para leitores de tela
6
+ * (rótulos de botões, `aria-label` de regiões etc.). O padrão é português;
7
+ * troque com `provideZuriI18n('en')` ou passe só as chaves que quiser mudar.
8
+ */
9
+ export interface ZurI18n {
10
+ /** Locale BCP 47 usado para formatar datas e nomes de mês/dia (date picker). */
11
+ locale: string;
12
+ /** Botão de fechar (modal, toast, drawer). */
13
+ close: string;
14
+ /** Botão de voltar (lista e detalhe no mobile). */
15
+ back: string;
16
+ /** Botão do topbar que recolhe a sidebar ou abre a gaveta. */
17
+ toggleNav: string;
18
+ /** Região da sidebar. */
19
+ sideNav: string;
20
+ /** Links do topbar. */
21
+ topNav: string;
22
+ /** Links do rodapé. */
23
+ footerNav: string;
24
+ /** Lista de etapas do formulário/wizard. */
25
+ steps: string;
26
+ /** Painel da lista (lista e detalhe). */
27
+ list: string;
28
+ /** Painel do detalhe (lista e detalhe). */
29
+ detail: string;
30
+ /** Região do breadcrumb. */
31
+ breadcrumb: string;
32
+ /** Botão de tema quando o tema atual é escuro. */
33
+ themeToLight: string;
34
+ /** Botão de tema quando o tema atual é claro. */
35
+ themeToDark: string;
36
+ /** Paginação. */
37
+ pagination: string;
38
+ previousPage: string;
39
+ nextPage: string;
40
+ /** Rótulo de cada página, ex.: "Página 3". */
41
+ page: (n: number) => string;
42
+ /** Rótulo padrão da barra de progresso. */
43
+ progress: string;
44
+ /** Contador de caracteres do textarea, ex.: "12 de 200 caracteres". */
45
+ characterCount: (count: number, max: number) => string;
46
+ /** Combobox e paleta de comandos sem resultado. */
47
+ noResults: string;
48
+ /** Botão que limpa o valor (combobox, chips). */
49
+ clear: string;
50
+ /** Botão que abre o calendário. */
51
+ openCalendar: string;
52
+ previousMonth: string;
53
+ nextMonth: string;
54
+ /** Data selecionada na faixa: início/fim. */
55
+ rangeStart: string;
56
+ rangeEnd: string;
57
+ /** Upload: texto da área de soltar e do botão. */
58
+ dropFiles: string;
59
+ browseFiles: string;
60
+ removeFile: (name: string) => string;
61
+ fileTooLarge: (name: string, maxSize: string) => string;
62
+ fileTypeNotAllowed: (name: string) => string;
63
+ /** Chips. */
64
+ removeChip: (label: string) => string;
65
+ /** Slider de faixa: rótulos dos dois controles. */
66
+ minimum: string;
67
+ maximum: string;
68
+ /** Chat. */
69
+ chatLog: string;
70
+ messagePlaceholder: string;
71
+ sendMessage: string;
72
+ attachFile: string;
73
+ typing: (name: string) => string;
74
+ /** Paleta de comandos. */
75
+ commandPalette: string;
76
+ commandPlaceholder: string;
77
+ /** Central de notificações. */
78
+ notifications: string;
79
+ unreadNotifications: (count: number) => string;
80
+ markAllRead: string;
81
+ noNotifications: string;
82
+ today: string;
83
+ earlier: string;
84
+ /** Kanban (anúncios do arrasto por teclado). */
85
+ kanbanInstructions: string;
86
+ cardGrabbed: (card: string, column: string, position: number) => string;
87
+ cardMoved: (card: string, column: string, position: number) => string;
88
+ cardDropped: (card: string, column: string, position: number) => string;
89
+ cardCancelled: (card: string) => string;
90
+ }
91
+ export declare const ZUR_I18N_PT: ZurI18n;
92
+ export declare const ZUR_I18N_EN: ZurI18n;
93
+ /** Textos usados pelos componentes. Padrão: português. */
94
+ export declare const ZUR_I18N: InjectionToken<ZurI18n>;
95
+ /**
96
+ * Define o idioma dos textos internos dos componentes.
97
+ *
98
+ * ```ts
99
+ * bootstrapApplication(App, { providers: [provideZuriI18n('en')] });
100
+ * // ou só algumas chaves, sobre o português:
101
+ * provideZuriI18n({ close: 'Fechar janela' });
102
+ * // ou sobre o inglês:
103
+ * provideZuriI18n({ ...ZUR_I18N_EN, close: 'Dismiss' });
104
+ * ```
105
+ */
106
+ export declare function provideZuriI18n(config: 'pt' | 'en' | Partial<ZurI18n>): Provider;
4
107
  export type ZurTheme = 'light' | 'dark';
5
108
  /**
6
109
  * Elemento cujo `data-theme` o serviço controla. Fornecido por `zurThemeScope`
@@ -34,9 +137,10 @@ export declare class ZurThemeService {
34
137
  * Mostra a lua no tema claro ("ir para o escuro") e o sol no escuro.
35
138
  */
36
139
  export declare class ZurThemeToggle {
140
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
37
141
  protected readonly themeService: ZurThemeService;
38
142
  protected readonly isDark: import("@angular/core").Signal<boolean>;
39
- protected readonly label: import("@angular/core").Signal<"Ativar tema claro" | "Ativar tema escuro">;
143
+ protected readonly label: import("@angular/core").Signal<string>;
40
144
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurThemeToggle, never>;
41
145
  static ɵcmp: i0.ɵɵComponentDeclaration<ZurThemeToggle, "zur-theme-toggle", never, {}, {}, never, never, true, never>;
42
146
  }
@@ -97,7 +201,7 @@ export type ZurButtonSize = 'sm' | 'md' | 'lg';
97
201
  * para preservar semântica e acessibilidade.
98
202
  *
99
203
  * ```html
100
- * <button zur-button variant="primary" size="md">Reservar</button>
204
+ * <button zur-button variant="primary" size="md">Comprar</button>
101
205
  * ```
102
206
  */
103
207
  export declare class ZurButton {
@@ -335,8 +439,9 @@ export declare class ZurRadio implements ControlValueAccessor {
335
439
  };
336
440
  }, {}, never, ["*"], true, never>;
337
441
  }
338
- /** Switch pill 44×24px — ligado = menta. */
339
442
  export declare class ZurSwitch implements ControlValueAccessor {
443
+ /** Liga o texto projetado ao botão como nome acessível. */
444
+ protected readonly labelId: string;
340
445
  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
341
446
  protected readonly checked: import("@angular/core").WritableSignal<boolean>;
342
447
  protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
@@ -357,6 +462,589 @@ export declare class ZurSwitch implements ControlValueAccessor {
357
462
  };
358
463
  }, {}, never, ["*"], true, never>;
359
464
  }
465
+ /**
466
+ * Área de texto do Zuri: mesmo visual do `zur-input`, com contador opcional
467
+ * quando `maxlength` é definido. Funciona com `ngModel` e formulários reativos.
468
+ *
469
+ * ```html
470
+ * <zur-textarea label="Mensagem" [maxlength]="200" [(ngModel)]="mensagem" />
471
+ * ```
472
+ */
473
+ export declare class ZurTextarea implements ControlValueAccessor {
474
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
475
+ readonly label: import("@angular/core").InputSignal<string>;
476
+ readonly placeholder: import("@angular/core").InputSignal<string>;
477
+ readonly hint: import("@angular/core").InputSignal<string>;
478
+ readonly error: import("@angular/core").InputSignal<string>;
479
+ readonly rows: import("@angular/core").InputSignalWithTransform<number, unknown>;
480
+ /** Limite de caracteres; quando definido, mostra o contador. */
481
+ readonly maxlength: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
482
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
483
+ protected readonly id: string;
484
+ protected readonly value: import("@angular/core").WritableSignal<string>;
485
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
486
+ protected onChange: (value: string) => void;
487
+ protected onTouched: () => void;
488
+ protected readonly describedBy: import("@angular/core").Signal<string | null>;
489
+ protected isDisabled(): boolean;
490
+ protected onInput(event: Event): void;
491
+ writeValue(value: string | null): void;
492
+ registerOnChange(fn: (value: string) => void): void;
493
+ registerOnTouched(fn: () => void): void;
494
+ setDisabledState(isDisabled: boolean): void;
495
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTextarea, never>;
496
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurTextarea, "zur-textarea", never, {
497
+ "label": {
498
+ "alias": "label";
499
+ "required": false;
500
+ "isSignal": true;
501
+ };
502
+ "placeholder": {
503
+ "alias": "placeholder";
504
+ "required": false;
505
+ "isSignal": true;
506
+ };
507
+ "hint": {
508
+ "alias": "hint";
509
+ "required": false;
510
+ "isSignal": true;
511
+ };
512
+ "error": {
513
+ "alias": "error";
514
+ "required": false;
515
+ "isSignal": true;
516
+ };
517
+ "rows": {
518
+ "alias": "rows";
519
+ "required": false;
520
+ "isSignal": true;
521
+ };
522
+ "maxlength": {
523
+ "alias": "maxlength";
524
+ "required": false;
525
+ "isSignal": true;
526
+ };
527
+ "disabled": {
528
+ "alias": "disabled";
529
+ "required": false;
530
+ "isSignal": true;
531
+ };
532
+ }, {}, never, never, true, never>;
533
+ }
534
+ export interface ZurComboboxOption {
535
+ value: string;
536
+ label: string;
537
+ /** Linha secundária, mostrada em muted abaixo do rótulo. */
538
+ description?: string;
539
+ }
540
+ /**
541
+ * Select com busca: o usuário digita e a lista filtra (ignora acentos e aceita
542
+ * iniciais). Navegação por setas, Enter escolhe, Esc fecha. Funciona com
543
+ * `ngModel` e formulários reativos; o valor é o `value` da opção (ou `null`).
544
+ *
545
+ * ```html
546
+ * <zur-combobox label="Planta" [options]="plantas" [(ngModel)]="planta" />
547
+ * ```
548
+ */
549
+ export declare class ZurCombobox implements ControlValueAccessor {
550
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
551
+ private readonly host;
552
+ readonly label: import("@angular/core").InputSignal<string>;
553
+ readonly placeholder: import("@angular/core").InputSignal<string>;
554
+ readonly hint: import("@angular/core").InputSignal<string>;
555
+ readonly error: import("@angular/core").InputSignal<string>;
556
+ readonly options: import("@angular/core").InputSignal<ZurComboboxOption[]>;
557
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
558
+ protected readonly id: string;
559
+ protected readonly listId: string;
560
+ readonly value: import("@angular/core").WritableSignal<string | null>;
561
+ /** Texto digitado; `null` quando o campo só mostra o rótulo escolhido. */
562
+ private readonly typed;
563
+ readonly open: import("@angular/core").WritableSignal<boolean>;
564
+ protected readonly activeIndex: import("@angular/core").WritableSignal<number>;
565
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
566
+ private readonly selectedLabel;
567
+ protected readonly query: import("@angular/core").Signal<string>;
568
+ /** Enquanto o usuário não digita, mostra todas as opções. */
569
+ protected readonly filtered: import("@angular/core").Signal<ZurComboboxOption[]>;
570
+ protected onChange: (value: string | null) => void;
571
+ protected onTouched: () => void;
572
+ protected optionId(i: number): string;
573
+ protected isDisabled(): boolean;
574
+ protected openList(): void;
575
+ protected onInput(event: Event): void;
576
+ protected onKeydown(event: KeyboardEvent): void;
577
+ select(option: ZurComboboxOption): void;
578
+ clear(): void;
579
+ /** Fecha a lista e restaura o texto para o rótulo escolhido. */
580
+ private closeList;
581
+ protected onFocusOut(event: FocusEvent): void;
582
+ writeValue(value: string | null): void;
583
+ registerOnChange(fn: (value: string | null) => void): void;
584
+ registerOnTouched(fn: () => void): void;
585
+ setDisabledState(isDisabled: boolean): void;
586
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurCombobox, never>;
587
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurCombobox, "zur-combobox", never, {
588
+ "label": {
589
+ "alias": "label";
590
+ "required": false;
591
+ "isSignal": true;
592
+ };
593
+ "placeholder": {
594
+ "alias": "placeholder";
595
+ "required": false;
596
+ "isSignal": true;
597
+ };
598
+ "hint": {
599
+ "alias": "hint";
600
+ "required": false;
601
+ "isSignal": true;
602
+ };
603
+ "error": {
604
+ "alias": "error";
605
+ "required": false;
606
+ "isSignal": true;
607
+ };
608
+ "options": {
609
+ "alias": "options";
610
+ "required": false;
611
+ "isSignal": true;
612
+ };
613
+ "disabled": {
614
+ "alias": "disabled";
615
+ "required": false;
616
+ "isSignal": true;
617
+ };
618
+ }, {}, never, never, true, never>;
619
+ }
620
+ export type ZurDatePickerMode = 'single' | 'range';
621
+ /** Valor do modo `range`. `end` fica `null` enquanto só o início foi escolhido. */
622
+ export interface ZurDateRange {
623
+ start: Date | null;
624
+ end: Date | null;
625
+ }
626
+ /**
627
+ * Campo de data com calendário em painel. No modo `single` o valor é `Date | null`;
628
+ * no modo `range` é `{ start, end }` — o primeiro clique marca o início, o segundo o fim
629
+ * (como na reserva do Airbnb). Teclado na grade: setas, PageUp/PageDown (mês), Home/End
630
+ * (semana), Enter/Espaço escolhe, Esc fecha. Nomes de mês e dia seguem o `locale` do i18n.
631
+ *
632
+ * ```html
633
+ * <zur-date-picker label="Entrega" [min]="hoje" [(ngModel)]="entrega" />
634
+ * <zur-date-picker label="Período" mode="range" [(ngModel)]="periodo" />
635
+ * ```
636
+ */
637
+ export declare class ZurDatePicker implements ControlValueAccessor {
638
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
639
+ private readonly host;
640
+ readonly label: import("@angular/core").InputSignal<string>;
641
+ readonly placeholder: import("@angular/core").InputSignal<string>;
642
+ readonly hint: import("@angular/core").InputSignal<string>;
643
+ readonly error: import("@angular/core").InputSignal<string>;
644
+ readonly mode: import("@angular/core").InputSignal<ZurDatePickerMode>;
645
+ readonly min: import("@angular/core").InputSignal<Date | null>;
646
+ readonly max: import("@angular/core").InputSignal<Date | null>;
647
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
648
+ protected readonly id: string;
649
+ readonly open: import("@angular/core").WritableSignal<boolean>;
650
+ protected readonly single: import("@angular/core").WritableSignal<Date | null>;
651
+ protected readonly range: import("@angular/core").WritableSignal<ZurDateRange>;
652
+ /** Mês exibido (dia 1). */
653
+ protected readonly viewMonth: import("@angular/core").WritableSignal<Date>;
654
+ /** Dia com o foco/roving tabindex na grade. */
655
+ protected readonly focused: import("@angular/core").WritableSignal<Date>;
656
+ protected readonly hover: import("@angular/core").WritableSignal<Date | null>;
657
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
658
+ protected onChange: (value: Date | ZurDateRange | null) => void;
659
+ protected onTouched: () => void;
660
+ protected readonly weeks: import("@angular/core").Signal<Date[][]>;
661
+ protected readonly weekdays: import("@angular/core").Signal<{
662
+ short: string;
663
+ long: string;
664
+ }[]>;
665
+ /** "Novembro de 2026": só a primeira letra maiúscula (CSS capitalize faria "De"). */
666
+ protected readonly monthTitle: import("@angular/core").Signal<string>;
667
+ protected readonly displayValue: import("@angular/core").Signal<string>;
668
+ format(date: Date | null): string;
669
+ protected fullDate(date: Date): string;
670
+ protected iso(date: Date): string;
671
+ protected isDisabled(): boolean;
672
+ protected isToday(date: Date): boolean;
673
+ protected isFocusTarget(date: Date): boolean;
674
+ protected isOutOfBounds(date: Date): boolean;
675
+ protected isSelected(date: Date): boolean;
676
+ /** Fim efetivo da faixa: o escolhido ou, enquanto escolhe, o dia sob o mouse. */
677
+ private rangeEnd;
678
+ protected inRange(date: Date): boolean;
679
+ protected isRangeEdge(date: Date, edge: 'start' | 'end'): boolean;
680
+ toggle(): void;
681
+ private show;
682
+ close(returnFocus?: boolean): void;
683
+ protected shiftMonth(delta: number): void;
684
+ protected pick(date: Date): void;
685
+ protected onGridKeydown(event: KeyboardEvent): void;
686
+ protected onDocumentClick(event: MouseEvent): void;
687
+ /** Move o foco do navegador para o botão do dia depois da renderização. */
688
+ private focusDay;
689
+ private clamp;
690
+ private firstOfMonth;
691
+ writeValue(value: Date | ZurDateRange | null): void;
692
+ registerOnChange(fn: (value: Date | ZurDateRange | null) => void): void;
693
+ registerOnTouched(fn: () => void): void;
694
+ setDisabledState(isDisabled: boolean): void;
695
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurDatePicker, never>;
696
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurDatePicker, "zur-date-picker", never, {
697
+ "label": {
698
+ "alias": "label";
699
+ "required": false;
700
+ "isSignal": true;
701
+ };
702
+ "placeholder": {
703
+ "alias": "placeholder";
704
+ "required": false;
705
+ "isSignal": true;
706
+ };
707
+ "hint": {
708
+ "alias": "hint";
709
+ "required": false;
710
+ "isSignal": true;
711
+ };
712
+ "error": {
713
+ "alias": "error";
714
+ "required": false;
715
+ "isSignal": true;
716
+ };
717
+ "mode": {
718
+ "alias": "mode";
719
+ "required": false;
720
+ "isSignal": true;
721
+ };
722
+ "min": {
723
+ "alias": "min";
724
+ "required": false;
725
+ "isSignal": true;
726
+ };
727
+ "max": {
728
+ "alias": "max";
729
+ "required": false;
730
+ "isSignal": true;
731
+ };
732
+ "disabled": {
733
+ "alias": "disabled";
734
+ "required": false;
735
+ "isSignal": true;
736
+ };
737
+ }, {}, never, never, true, never>;
738
+ }
739
+ export type ZurUploadStatus = 'pending' | 'uploading' | 'done' | 'error';
740
+ /** Um arquivo na lista do `zur-file-upload`. Atualize `progress`/`status` de fora. */
741
+ export interface ZurUploadFile {
742
+ id: string;
743
+ file: File;
744
+ /** 0–100 enquanto envia; `null` esconde a barra. */
745
+ progress: number | null;
746
+ status: ZurUploadStatus;
747
+ error?: string;
748
+ }
749
+ /** Formata bytes em B, KB ou MB no locale informado. */
750
+ export declare function zurFormatBytes(bytes: number, locale?: string): string;
751
+ /** Confere um arquivo contra uma lista no formato do atributo `accept` (`.pdf,image/*`). */
752
+ export declare function zurAcceptsFile(file: File, accept: string): boolean;
753
+ /**
754
+ * Área de envio de arquivos: arrastar e soltar ou escolher no computador, com
755
+ * validação de tipo (`accept`) e tamanho (`maxSize`, em bytes). Os arquivos aceitos
756
+ * entram em `files` (two-way) e saem em `filesAdded`; o componente não faz o envio —
757
+ * quem usa atualiza `progress` e `status` de cada item.
758
+ *
759
+ * ```html
760
+ * <zur-file-upload label="Fotos da planta" accept="image/*" [maxSize]="5_000_000"
761
+ * multiple [(files)]="fotos" (filesAdded)="enviar($event)" />
762
+ * ```
763
+ */
764
+ export declare class ZurFileUpload {
765
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
766
+ readonly label: import("@angular/core").InputSignal<string>;
767
+ readonly hint: import("@angular/core").InputSignal<string>;
768
+ /** Mesmo formato do atributo `accept` do input: `.pdf,image/*`. */
769
+ readonly accept: import("@angular/core").InputSignal<string>;
770
+ /** Tamanho máximo por arquivo, em bytes. `0` = sem limite. */
771
+ readonly maxSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
772
+ readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
773
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
774
+ /** Lista de arquivos aceitos (two-way). */
775
+ readonly files: import("@angular/core").ModelSignal<ZurUploadFile[]>;
776
+ /** Arquivos que acabaram de ser aceitos. */
777
+ readonly filesAdded: import("@angular/core").OutputEmitterRef<ZurUploadFile[]>;
778
+ readonly fileRemoved: import("@angular/core").OutputEmitterRef<ZurUploadFile>;
779
+ protected readonly id: string;
780
+ protected readonly dragging: import("@angular/core").WritableSignal<boolean>;
781
+ protected readonly rejected: import("@angular/core").WritableSignal<string[]>;
782
+ protected size(bytes: number): string;
783
+ /** Valida e adiciona arquivos — também pode ser chamado de fora. */
784
+ addFiles(list: FileList | File[]): void;
785
+ remove(item: ZurUploadFile): void;
786
+ protected onPick(event: Event): void;
787
+ protected onDragOver(event: DragEvent): void;
788
+ protected onDragLeave(event: DragEvent): void;
789
+ protected onDrop(event: DragEvent): void;
790
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurFileUpload, never>;
791
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurFileUpload, "zur-file-upload", never, {
792
+ "label": {
793
+ "alias": "label";
794
+ "required": false;
795
+ "isSignal": true;
796
+ };
797
+ "hint": {
798
+ "alias": "hint";
799
+ "required": false;
800
+ "isSignal": true;
801
+ };
802
+ "accept": {
803
+ "alias": "accept";
804
+ "required": false;
805
+ "isSignal": true;
806
+ };
807
+ "maxSize": {
808
+ "alias": "maxSize";
809
+ "required": false;
810
+ "isSignal": true;
811
+ };
812
+ "multiple": {
813
+ "alias": "multiple";
814
+ "required": false;
815
+ "isSignal": true;
816
+ };
817
+ "disabled": {
818
+ "alias": "disabled";
819
+ "required": false;
820
+ "isSignal": true;
821
+ };
822
+ "files": {
823
+ "alias": "files";
824
+ "required": false;
825
+ "isSignal": true;
826
+ };
827
+ }, {
828
+ "files": "filesChange";
829
+ "filesAdded": "filesAdded";
830
+ "fileRemoved": "fileRemoved";
831
+ }, never, never, true, never>;
832
+ }
833
+ /**
834
+ * Campo de tags: o usuário digita e Enter (ou vírgula) vira um chip; Backspace no
835
+ * campo vazio remove o último. Ignora repetidos (sem diferenciar acento/caixa).
836
+ * O valor é `string[]` e funciona com `ngModel` e formulários reativos.
837
+ *
838
+ * ```html
839
+ * <zur-chips label="Ambientes" placeholder="Sala, varanda…" [(ngModel)]="ambientes" />
840
+ * ```
841
+ */
842
+ export declare class ZurChips implements ControlValueAccessor {
843
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
844
+ readonly label: import("@angular/core").InputSignal<string>;
845
+ readonly placeholder: import("@angular/core").InputSignal<string>;
846
+ readonly hint: import("@angular/core").InputSignal<string>;
847
+ readonly error: import("@angular/core").InputSignal<string>;
848
+ /** Quantidade máxima de chips; `0` = sem limite. */
849
+ readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
850
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
851
+ protected readonly id: string;
852
+ readonly value: import("@angular/core").WritableSignal<string[]>;
853
+ protected readonly draft: import("@angular/core").WritableSignal<string>;
854
+ protected readonly announcement: import("@angular/core").WritableSignal<string>;
855
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
856
+ protected onChange: (value: string[]) => void;
857
+ protected onTouched: () => void;
858
+ protected isDisabled(): boolean;
859
+ protected full(): boolean;
860
+ protected onInput(event: Event): void;
861
+ protected onKeydown(event: KeyboardEvent): void;
862
+ /** Transforma o texto digitado em chip. */
863
+ protected commit(): void;
864
+ add(text: string): void;
865
+ remove(chip: string): void;
866
+ writeValue(value: string[] | null): void;
867
+ registerOnChange(fn: (value: string[]) => void): void;
868
+ registerOnTouched(fn: () => void): void;
869
+ setDisabledState(isDisabled: boolean): void;
870
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurChips, never>;
871
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurChips, "zur-chips", never, {
872
+ "label": {
873
+ "alias": "label";
874
+ "required": false;
875
+ "isSignal": true;
876
+ };
877
+ "placeholder": {
878
+ "alias": "placeholder";
879
+ "required": false;
880
+ "isSignal": true;
881
+ };
882
+ "hint": {
883
+ "alias": "hint";
884
+ "required": false;
885
+ "isSignal": true;
886
+ };
887
+ "error": {
888
+ "alias": "error";
889
+ "required": false;
890
+ "isSignal": true;
891
+ };
892
+ "max": {
893
+ "alias": "max";
894
+ "required": false;
895
+ "isSignal": true;
896
+ };
897
+ "disabled": {
898
+ "alias": "disabled";
899
+ "required": false;
900
+ "isSignal": true;
901
+ };
902
+ }, {}, never, never, true, never>;
903
+ }
904
+ /**
905
+ * Controle deslizante. Com `range`, tem dois controles e o valor é `[mínimo, máximo]`;
906
+ * sem, é um número. Teclado: setas (±step), PageUp/PageDown (±10 steps), Home/End.
907
+ * Clique na trilha move o controle mais próximo; arrastar funciona com mouse e toque.
908
+ *
909
+ * ```html
910
+ * <zur-slider label="Preço" range [min]="0" [max]="500" [step]="10"
911
+ * [format]="reais" [(ngModel)]="faixa" />
912
+ * ```
913
+ */
914
+ export declare class ZurSlider implements ControlValueAccessor {
915
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
916
+ private readonly host;
917
+ readonly label: import("@angular/core").InputSignal<string>;
918
+ readonly min: import("@angular/core").InputSignalWithTransform<number, unknown>;
919
+ readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
920
+ readonly step: import("@angular/core").InputSignalWithTransform<number, unknown>;
921
+ /** Dois controles: o valor vira `[mínimo, máximo]`. */
922
+ readonly range: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
923
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
924
+ /** Como mostrar/anunciar o valor (ex.: moeda). */
925
+ readonly format: import("@angular/core").InputSignal<(value: number) => string>;
926
+ protected readonly id: string;
927
+ /** `null` = ainda sem valor: usa o padrão (mínimo, ou a trilha toda no modo faixa). */
928
+ private readonly lowValue;
929
+ private readonly highValue;
930
+ protected readonly low: import("@angular/core").Signal<number>;
931
+ protected readonly high: import("@angular/core").Signal<number>;
932
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
933
+ protected dragging: 'low' | 'high' | null;
934
+ protected readonly thumbs: import("@angular/core").Signal<("low" | "high")[]>;
935
+ protected onChange: (value: number | [number, number]) => void;
936
+ protected onTouched: () => void;
937
+ /** No modo simples o valor vive em `high`; `low` é o mínimo da trilha. */
938
+ value(): number | [number, number];
939
+ protected isDisabled(): boolean;
940
+ protected percent(value: number): number;
941
+ protected thumbLabel(thumb: 'low' | 'high'): string | null;
942
+ private snap;
943
+ /** Atualiza um controle respeitando o outro (low ≤ high). */
944
+ setThumb(thumb: 'low' | 'high', raw: number): void;
945
+ protected onKeydown(event: KeyboardEvent, thumb: 'low' | 'high'): void;
946
+ private valueAt;
947
+ protected onTrackPointerDown(event: PointerEvent): void;
948
+ protected onPointerMove(event: PointerEvent): void;
949
+ writeValue(value: number | [number, number] | null): void;
950
+ registerOnChange(fn: (value: number | [number, number]) => void): void;
951
+ registerOnTouched(fn: () => void): void;
952
+ setDisabledState(isDisabled: boolean): void;
953
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSlider, never>;
954
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSlider, "zur-slider", never, {
955
+ "label": {
956
+ "alias": "label";
957
+ "required": false;
958
+ "isSignal": true;
959
+ };
960
+ "min": {
961
+ "alias": "min";
962
+ "required": false;
963
+ "isSignal": true;
964
+ };
965
+ "max": {
966
+ "alias": "max";
967
+ "required": false;
968
+ "isSignal": true;
969
+ };
970
+ "step": {
971
+ "alias": "step";
972
+ "required": false;
973
+ "isSignal": true;
974
+ };
975
+ "range": {
976
+ "alias": "range";
977
+ "required": false;
978
+ "isSignal": true;
979
+ };
980
+ "disabled": {
981
+ "alias": "disabled";
982
+ "required": false;
983
+ "isSignal": true;
984
+ };
985
+ "format": {
986
+ "alias": "format";
987
+ "required": false;
988
+ "isSignal": true;
989
+ };
990
+ }, {}, never, never, true, never>;
991
+ }
992
+ export interface ZurSegmentedOption {
993
+ value: string;
994
+ label: string;
995
+ }
996
+ export type ZurSegmentedSize = 'sm' | 'md';
997
+ /**
998
+ * Alternador em pílulas para poucas opções mutuamente exclusivas (visão em
999
+ * lista/grade, período). É um `radiogroup`: setas trocam a opção, Tab sai do grupo.
1000
+ *
1001
+ * ```html
1002
+ * <zur-segmented label="Visualização" [options]="visoes" [(ngModel)]="visao" />
1003
+ * ```
1004
+ */
1005
+ export declare class ZurSegmented implements ControlValueAccessor {
1006
+ private readonly host;
1007
+ readonly label: import("@angular/core").InputSignal<string>;
1008
+ readonly options: import("@angular/core").InputSignal<ZurSegmentedOption[]>;
1009
+ readonly size: import("@angular/core").InputSignal<ZurSegmentedSize>;
1010
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
1011
+ readonly value: import("@angular/core").WritableSignal<string | null>;
1012
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
1013
+ protected onChange: (value: string) => void;
1014
+ protected onTouched: () => void;
1015
+ protected isDisabled(): boolean;
1016
+ /** O item marcado (ou o primeiro, se nenhum) recebe o Tab. */
1017
+ protected isTabStop(i: number): boolean;
1018
+ select(value: string): void;
1019
+ protected onKeydown(event: KeyboardEvent): void;
1020
+ writeValue(value: string | null): void;
1021
+ registerOnChange(fn: (value: string) => void): void;
1022
+ registerOnTouched(fn: () => void): void;
1023
+ setDisabledState(isDisabled: boolean): void;
1024
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSegmented, never>;
1025
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSegmented, "zur-segmented", never, {
1026
+ "label": {
1027
+ "alias": "label";
1028
+ "required": false;
1029
+ "isSignal": true;
1030
+ };
1031
+ "options": {
1032
+ "alias": "options";
1033
+ "required": false;
1034
+ "isSignal": true;
1035
+ };
1036
+ "size": {
1037
+ "alias": "size";
1038
+ "required": false;
1039
+ "isSignal": true;
1040
+ };
1041
+ "disabled": {
1042
+ "alias": "disabled";
1043
+ "required": false;
1044
+ "isSignal": true;
1045
+ };
1046
+ }, {}, never, never, true, never>;
1047
+ }
360
1048
  /**
361
1049
  * Navbar 80px — canvas com hairline inferior (Airbnb top-nav).
362
1050
  * Slots: [zurNavbarLogo], [zurNavbarLinks], [zurNavbarActions].
@@ -422,6 +1110,7 @@ export interface ZurBreadcrumbItem {
422
1110
  }
423
1111
  /** Breadcrumb em caption muted com separador "/". */
424
1112
  export declare class ZurBreadcrumb {
1113
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
425
1114
  readonly items: import("@angular/core").InputSignal<ZurBreadcrumbItem[]>;
426
1115
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurBreadcrumb, never>;
427
1116
  static ɵcmp: i0.ɵɵComponentDeclaration<ZurBreadcrumb, "zur-breadcrumb", never, {
@@ -465,19 +1154,195 @@ export declare class ZurSidenavItem {
465
1154
  "required": false;
466
1155
  "isSignal": true;
467
1156
  };
468
- "active": {
469
- "alias": "active";
1157
+ "active": {
1158
+ "alias": "active";
1159
+ "required": false;
1160
+ "isSignal": true;
1161
+ };
1162
+ }, {}, never, ["[zurSidenavIcon]", "*"], true, never>;
1163
+ }
1164
+ /** Rótulo de seção da navegação lateral (caption em caixa alta). */
1165
+ export declare class ZurSidenavLabel {
1166
+ private readonly shell;
1167
+ protected readonly collapsed: import("@angular/core").Signal<boolean>;
1168
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidenavLabel, never>;
1169
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidenavLabel, "zur-sidenav-label", never, {}, {}, never, ["*"], true, never>;
1170
+ }
1171
+ export type ZurTableDensity = 'comfortable' | 'compact';
1172
+ export type ZurSortDirection = 'asc' | 'desc';
1173
+ export interface ZurSort {
1174
+ key: string;
1175
+ direction: ZurSortDirection;
1176
+ }
1177
+ /**
1178
+ * Estilo do Zuri para uma `<table>` nativa: cabeçalho em caption, linhas com
1179
+ * hairline, hover e densidade. A ordenação fica com você: marque as colunas com
1180
+ * `zurSortable` e reaja ao `sortChange`.
1181
+ *
1182
+ * ```html
1183
+ * <table zur-table (sortChange)="ordenar($event)">
1184
+ * <thead>
1185
+ * <tr><th zurSortable="nome">Nome</th><th>Produto</th></tr>
1186
+ * </thead>
1187
+ * <tbody>…</tbody>
1188
+ * </table>
1189
+ * ```
1190
+ */
1191
+ export declare class ZurTable {
1192
+ readonly density: import("@angular/core").InputSignal<ZurTableDensity>;
1193
+ /** Emite a coluna e a direção sempre que o usuário ordena. */
1194
+ readonly sortChange: import("@angular/core").OutputEmitterRef<ZurSort>;
1195
+ readonly sort: import("@angular/core").WritableSignal<ZurSort | null>;
1196
+ toggleSort(key: string): void;
1197
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTable, never>;
1198
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurTable, "table[zur-table]", never, {
1199
+ "density": {
1200
+ "alias": "density";
1201
+ "required": false;
1202
+ "isSignal": true;
1203
+ };
1204
+ }, {
1205
+ "sortChange": "sortChange";
1206
+ }, never, ["*"], true, never>;
1207
+ }
1208
+ /** Torna um `<th>` ordenável dentro de `table[zur-table]`. O valor é a chave da coluna. */
1209
+ export declare class ZurSortable {
1210
+ protected readonly table: ZurTable;
1211
+ readonly zurSortable: import("@angular/core").InputSignal<string>;
1212
+ protected readonly ariaSort: import("@angular/core").Signal<"none" | "ascending" | "descending">;
1213
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSortable, never>;
1214
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSortable, "th[zurSortable]", never, {
1215
+ "zurSortable": {
1216
+ "alias": "zurSortable";
1217
+ "required": true;
1218
+ "isSignal": true;
1219
+ };
1220
+ }, {}, never, ["*"], true, never>;
1221
+ }
1222
+ type PageItem = number | 'gap';
1223
+ /**
1224
+ * Paginação: anterior, números (com reticências quando são muitos) e próxima.
1225
+ * `page` começa em 1 e é two-way.
1226
+ *
1227
+ * ```html
1228
+ * <zur-pagination [total]="248" [pageSize]="20" [(page)]="pagina" />
1229
+ * ```
1230
+ */
1231
+ export declare class ZurPagination {
1232
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1233
+ /** Página atual, começando em 1. */
1234
+ readonly page: import("@angular/core").ModelSignal<number>;
1235
+ /** Total de itens. */
1236
+ readonly total: import("@angular/core").InputSignal<number>;
1237
+ readonly pageSize: import("@angular/core").InputSignal<number>;
1238
+ /** Quantas páginas mostrar de cada lado da atual. */
1239
+ readonly siblings: import("@angular/core").InputSignal<number>;
1240
+ readonly pageCount: import("@angular/core").Signal<number>;
1241
+ protected readonly items: import("@angular/core").Signal<PageItem[]>;
1242
+ protected go(p: number): void;
1243
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurPagination, never>;
1244
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurPagination, "zur-pagination", never, {
1245
+ "page": {
1246
+ "alias": "page";
1247
+ "required": false;
1248
+ "isSignal": true;
1249
+ };
1250
+ "total": {
1251
+ "alias": "total";
1252
+ "required": true;
1253
+ "isSignal": true;
1254
+ };
1255
+ "pageSize": {
1256
+ "alias": "pageSize";
1257
+ "required": false;
1258
+ "isSignal": true;
1259
+ };
1260
+ "siblings": {
1261
+ "alias": "siblings";
1262
+ "required": false;
1263
+ "isSignal": true;
1264
+ };
1265
+ }, {
1266
+ "page": "pageChange";
1267
+ }, never, never, true, never>;
1268
+ }
1269
+ /**
1270
+ * Seções expansíveis. Por padrão só uma fica aberta por vez; com `multi`, várias.
1271
+ * Setas ↑/↓, Home e End movem o foco entre os cabeçalhos.
1272
+ *
1273
+ * ```html
1274
+ * <zur-accordion>
1275
+ * <zur-accordion-item title="Como cuidar da planta?">…</zur-accordion-item>
1276
+ * <zur-accordion-item title="Posso cancelar?">…</zur-accordion-item>
1277
+ * </zur-accordion>
1278
+ * ```
1279
+ */
1280
+ export declare class ZurAccordion {
1281
+ private readonly host;
1282
+ /** Permite várias seções abertas ao mesmo tempo. */
1283
+ readonly multi: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
1284
+ private readonly items;
1285
+ /** Chamado por um item ao abrir: fecha os outros quando não é `multi`. */
1286
+ itemOpened(opened: ZurAccordionItem): void;
1287
+ protected onKeydown(event: KeyboardEvent): void;
1288
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurAccordion, never>;
1289
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurAccordion, "zur-accordion", never, {
1290
+ "multi": {
1291
+ "alias": "multi";
1292
+ "required": false;
1293
+ "isSignal": true;
1294
+ };
1295
+ }, {}, ["items"], ["*"], true, never>;
1296
+ }
1297
+ export declare class ZurAccordionItem {
1298
+ private readonly accordion;
1299
+ readonly title: import("@angular/core").InputSignal<string>;
1300
+ readonly open: import("@angular/core").ModelSignal<boolean>;
1301
+ protected readonly id: string;
1302
+ toggle(): void;
1303
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurAccordionItem, never>;
1304
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurAccordionItem, "zur-accordion-item", never, {
1305
+ "title": {
1306
+ "alias": "title";
1307
+ "required": true;
1308
+ "isSignal": true;
1309
+ };
1310
+ "open": {
1311
+ "alias": "open";
1312
+ "required": false;
1313
+ "isSignal": true;
1314
+ };
1315
+ }, {
1316
+ "open": "openChange";
1317
+ }, never, ["*"], true, never>;
1318
+ }
1319
+ /**
1320
+ * Estado vazio: ícone, título, descrição e ações, centralizados. Use em listas,
1321
+ * buscas sem resultado ou telas que ainda não têm conteúdo.
1322
+ *
1323
+ * ```html
1324
+ * <zur-empty-state title="Seu carrinho está vazio" description="Quando você adicionar uma planta, ela aparece aqui.">
1325
+ * <svg zurEmptyIcon …></svg>
1326
+ * <button zur-button>Explorar</button>
1327
+ * </zur-empty-state>
1328
+ * ```
1329
+ */
1330
+ export declare class ZurEmptyState {
1331
+ readonly title: import("@angular/core").InputSignal<string>;
1332
+ readonly description: import("@angular/core").InputSignal<string>;
1333
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurEmptyState, never>;
1334
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurEmptyState, "zur-empty-state", never, {
1335
+ "title": {
1336
+ "alias": "title";
1337
+ "required": true;
1338
+ "isSignal": true;
1339
+ };
1340
+ "description": {
1341
+ "alias": "description";
470
1342
  "required": false;
471
1343
  "isSignal": true;
472
1344
  };
473
- }, {}, never, ["[zurSidenavIcon]", "*"], true, never>;
474
- }
475
- /** Rótulo de seção da navegação lateral (caption em caixa alta). */
476
- export declare class ZurSidenavLabel {
477
- private readonly shell;
478
- protected readonly collapsed: import("@angular/core").Signal<boolean>;
479
- static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidenavLabel, never>;
480
- static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidenavLabel, "zur-sidenav-label", never, {}, {}, never, ["*"], true, never>;
1345
+ }, {}, never, ["[zurEmptyIcon]", "*"], true, never>;
481
1346
  }
482
1347
  /**
483
1348
  * Passo numerado (círculo verde + título) com conteúdo projetado abaixo.
@@ -553,6 +1418,7 @@ export declare const ZUR_LAYOUT_WIDTH_STYLES = "\n :host([data-width='fluid'])
553
1418
  * `[zurSidebarFooter]`.
554
1419
  */
555
1420
  export declare class ZurSidebar implements OnInit {
1421
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
556
1422
  protected readonly shell: ZurShellState;
557
1423
  /** Recolhida só vale fora do mobile (a gaveta sempre abre completa). */
558
1424
  protected readonly collapsed: import("@angular/core").Signal<boolean>;
@@ -568,6 +1434,7 @@ export declare class ZurSidebar implements OnInit {
568
1434
  * Slots: `[zurTopbarStart]` (logo/título), `[zurTopbarLinks]`, `[zurTopbarActions]`.
569
1435
  */
570
1436
  export declare class ZurTopbar implements OnInit {
1437
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
571
1438
  private readonly doc;
572
1439
  protected readonly shell: ZurShellState | null;
573
1440
  /** Esconde ao rolar para baixo e reaparece ao rolar para cima. */
@@ -590,9 +1457,9 @@ export declare class ZurTopbar implements OnInit {
590
1457
  * Cabeçalho de página: breadcrumb opcional, título, descrição e ações.
591
1458
  *
592
1459
  * ```html
593
- * <zur-page-header title="Reservas" description="Gerencie as reservas.">
1460
+ * <zur-page-header title="Pedidos" description="Gerencie os pedidos.">
594
1461
  * <zur-breadcrumb [items]="trilha" />
595
- * <button zurPageHeaderActions zur-button>Nova reserva</button>
1462
+ * <button zurPageHeaderActions zur-button>Novo pedido</button>
596
1463
  * </zur-page-header>
597
1464
  * ```
598
1465
  */
@@ -615,6 +1482,7 @@ export declare class ZurPageHeader {
615
1482
  }
616
1483
  /** Rodapé simples: conteúdo à esquerda (ex.: copyright), `[zurFooterLinks]` à direita. */
617
1484
  export declare class ZurFooter {
1485
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
618
1486
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurFooter, never>;
619
1487
  static ɵcmp: i0.ɵɵComponentDeclaration<ZurFooter, "zur-footer", never, {}, {}, never, ["*", "[zurFooterLinks]"], true, never>;
620
1488
  }
@@ -680,6 +1548,7 @@ export declare class ZurDashboardLayout {
680
1548
  * ```
681
1549
  */
682
1550
  export declare class ZurListDetailLayout {
1551
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
683
1552
  /** Mobile: `true` mostra o detalhe; `false` mostra a lista. */
684
1553
  readonly detailOpen: import("@angular/core").ModelSignal<boolean>;
685
1554
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurListDetailLayout, never>;
@@ -701,13 +1570,14 @@ export declare class ZurListDetailLayout {
701
1570
  *
702
1571
  * ```html
703
1572
  * <zur-form-layout [steps]="['Dados', 'Pagamento', 'Revisão']" [current]="1">
704
- * <zur-page-header title="Nova reserva" />
1573
+ * <zur-page-header title="Novo pedido" />
705
1574
  * <zur-input label="Nome" />
706
1575
  * <div zurLayoutActions><button zur-button>Continuar</button></div>
707
1576
  * </zur-form-layout>
708
1577
  * ```
709
1578
  */
710
1579
  export declare class ZurFormLayout {
1580
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
711
1581
  readonly width: import("@angular/core").InputSignal<ZurLayoutWidth>;
712
1582
  /** Rótulos das etapas do wizard; vazio = formulário simples. */
713
1583
  readonly steps: import("@angular/core").InputSignal<string[]>;
@@ -809,10 +1679,11 @@ export declare class ZurErrorLayout {
809
1679
  * Fecha por ESC, clique no scrim ou no botão ×.
810
1680
  *
811
1681
  * ```html
812
- * <zur-modal [(open)]="aberto" title="Confirmar reserva">…</zur-modal>
1682
+ * <zur-modal [(open)]="aberto" title="Confirmar pedido">…</zur-modal>
813
1683
  * ```
814
1684
  */
815
1685
  export declare class ZurModal {
1686
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
816
1687
  readonly open: import("@angular/core").ModelSignal<boolean>;
817
1688
  readonly title: import("@angular/core").InputSignal<string>;
818
1689
  close(): void;
@@ -851,6 +1722,7 @@ export declare class ZurToastService {
851
1722
  * ZurToastService. Coloque uma única instância no shell da aplicação.
852
1723
  */
853
1724
  export declare class ZurToastContainer {
1725
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
854
1726
  protected readonly service: ZurToastService;
855
1727
  static ɵfac: i0.ɵɵFactoryDeclaration<ZurToastContainer, never>;
856
1728
  static ɵcmp: i0.ɵɵComponentDeclaration<ZurToastContainer, "zur-toast-container", never, {}, {}, never, never, true, never>;
@@ -929,4 +1801,553 @@ export declare class ZurSkeleton {
929
1801
  "isSignal": true;
930
1802
  };
931
1803
  }, {}, never, never, true, never>;
932
- }
1804
+ }
1805
+ export type ZurProgressSize = 'sm' | 'md';
1806
+ /**
1807
+ * Barra de progresso linear. Com `value` (0 a `max`) é determinada; sem `value`
1808
+ * (ou `null`), fica indeterminada, com animação contínua.
1809
+ *
1810
+ * ```html
1811
+ * <zur-progress [value]="60" label="Enviando arquivo" />
1812
+ * <zur-progress /> <!-- indeterminada -->
1813
+ * ```
1814
+ */
1815
+ export declare class ZurProgress {
1816
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1817
+ /** Valor atual (0 a `max`). `null` = indeterminada. */
1818
+ readonly value: import("@angular/core").InputSignal<number | null>;
1819
+ readonly max: import("@angular/core").InputSignal<number>;
1820
+ readonly size: import("@angular/core").InputSignal<ZurProgressSize>;
1821
+ /** Rótulo para leitores de tela. Padrão: "Progresso". */
1822
+ readonly label: import("@angular/core").InputSignal<string>;
1823
+ protected readonly indeterminate: import("@angular/core").Signal<boolean>;
1824
+ protected readonly clamped: import("@angular/core").Signal<number>;
1825
+ protected readonly percent: import("@angular/core").Signal<number>;
1826
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurProgress, never>;
1827
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurProgress, "zur-progress", never, {
1828
+ "value": {
1829
+ "alias": "value";
1830
+ "required": false;
1831
+ "isSignal": true;
1832
+ };
1833
+ "max": {
1834
+ "alias": "max";
1835
+ "required": false;
1836
+ "isSignal": true;
1837
+ };
1838
+ "size": {
1839
+ "alias": "size";
1840
+ "required": false;
1841
+ "isSignal": true;
1842
+ };
1843
+ "label": {
1844
+ "alias": "label";
1845
+ "required": false;
1846
+ "isSignal": true;
1847
+ };
1848
+ }, {}, never, never, true, never>;
1849
+ }
1850
+ export type ZurDrawerSide = 'left' | 'right';
1851
+ /**
1852
+ * Painel lateral deslizante (gaveta) sobre a página, para filtros, detalhes ou
1853
+ * formulários curtos. Fecha com ESC, clique no fundo ou no botão de fechar; o foco
1854
+ * fica preso dentro dele enquanto aberto e volta para quem o abriu ao fechar.
1855
+ *
1856
+ * ```html
1857
+ * <button zur-button (click)="filtros = true">Filtros</button>
1858
+ * <zur-drawer [(open)]="filtros" title="Filtros">…</zur-drawer>
1859
+ * ```
1860
+ */
1861
+ export declare class ZurDrawer {
1862
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1863
+ private readonly doc;
1864
+ readonly open: import("@angular/core").ModelSignal<boolean>;
1865
+ readonly title: import("@angular/core").InputSignal<string>;
1866
+ readonly side: import("@angular/core").InputSignal<ZurDrawerSide>;
1867
+ private readonly panel;
1868
+ private returnFocusTo;
1869
+ constructor();
1870
+ close(): void;
1871
+ /** Mantém o Tab circulando dentro do painel. */
1872
+ protected trapFocus(event: KeyboardEvent): void;
1873
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurDrawer, never>;
1874
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurDrawer, "zur-drawer", never, {
1875
+ "open": {
1876
+ "alias": "open";
1877
+ "required": false;
1878
+ "isSignal": true;
1879
+ };
1880
+ "title": {
1881
+ "alias": "title";
1882
+ "required": false;
1883
+ "isSignal": true;
1884
+ };
1885
+ "side": {
1886
+ "alias": "side";
1887
+ "required": false;
1888
+ "isSignal": true;
1889
+ };
1890
+ }, {
1891
+ "open": "openChange";
1892
+ }, never, ["*", "[zurDrawerActions]"], true, never>;
1893
+ }
1894
+ export type ZurPopoverPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
1895
+ /**
1896
+ * Conteúdo flutuante ancorado a um gatilho (filtros, detalhes, ações). Abre no
1897
+ * clique do elemento marcado com `zurPopoverTrigger`, fecha com ESC ou clique fora,
1898
+ * e devolve o foco ao gatilho.
1899
+ *
1900
+ * ```html
1901
+ * <zur-popover label="Filtros">
1902
+ * <button zur-button variant="secondary" zurPopoverTrigger>Filtros</button>
1903
+ * …conteúdo…
1904
+ * </zur-popover>
1905
+ * ```
1906
+ */
1907
+ export declare class ZurPopover {
1908
+ private readonly host;
1909
+ private readonly doc;
1910
+ readonly open: import("@angular/core").ModelSignal<boolean>;
1911
+ readonly placement: import("@angular/core").InputSignal<ZurPopoverPlacement>;
1912
+ /** Nome do painel para leitores de tela. */
1913
+ readonly label: import("@angular/core").InputSignal<string>;
1914
+ readonly panelId: string;
1915
+ private readonly panel;
1916
+ /** Preenchido pela diretiva do gatilho. */
1917
+ trigger: HTMLElement | null;
1918
+ constructor();
1919
+ toggle(): void;
1920
+ /** Fecha; com `returnFocus`, devolve o foco ao gatilho (ex.: ao apertar ESC). */
1921
+ close(returnFocus?: boolean): void;
1922
+ protected onDocumentClick(event: MouseEvent): void;
1923
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurPopover, never>;
1924
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurPopover, "zur-popover", never, {
1925
+ "open": {
1926
+ "alias": "open";
1927
+ "required": false;
1928
+ "isSignal": true;
1929
+ };
1930
+ "placement": {
1931
+ "alias": "placement";
1932
+ "required": false;
1933
+ "isSignal": true;
1934
+ };
1935
+ "label": {
1936
+ "alias": "label";
1937
+ "required": false;
1938
+ "isSignal": true;
1939
+ };
1940
+ }, {
1941
+ "open": "openChange";
1942
+ }, never, ["[zurPopoverTrigger]", "*"], true, never>;
1943
+ }
1944
+ /** Marca o elemento que abre o `zur-popover` e liga os atributos ARIA a ele. */
1945
+ export declare class ZurPopoverTrigger {
1946
+ protected readonly popover: any;
1947
+ constructor();
1948
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurPopoverTrigger, never>;
1949
+ static ɵdir: i0.ɵɵDirectiveDeclaration<ZurPopoverTrigger, "[zurPopoverTrigger]", never, {}, {}, never, never, true, never>;
1950
+ }
1951
+ /**
1952
+ * Contêiner de conversa. A área de mensagens é um `role="log"` que rola sozinha para
1953
+ * o fim quando chega mensagem nova ou o texto cresce (streaming) — a menos que o
1954
+ * usuário tenha subido para ler o histórico. O compositor vai por último.
1955
+ *
1956
+ * ```html
1957
+ * <zur-chat style="height: 480px">
1958
+ * <zur-chat-divider>Hoje</zur-chat-divider>
1959
+ * <zur-chat-message from="them" author="Ana" time="10:02">Oi! Como posso ajudar?</zur-chat-message>
1960
+ * <zur-chat-message from="me" time="10:03">Minha jiboia está amarelando.</zur-chat-message>
1961
+ * <zur-chat-typing name="Ana" />
1962
+ * <zur-chat-composer (send)="enviar($event)" />
1963
+ * </zur-chat>
1964
+ * ```
1965
+ */
1966
+ export declare class ZurChat {
1967
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1968
+ readonly label: import("@angular/core").InputSignal<string>;
1969
+ private readonly log;
1970
+ private stick;
1971
+ constructor();
1972
+ /** Rola até a última mensagem. */
1973
+ scrollToBottom(): void;
1974
+ protected onScroll(): void;
1975
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurChat, never>;
1976
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurChat, "zur-chat", never, {
1977
+ "label": {
1978
+ "alias": "label";
1979
+ "required": false;
1980
+ "isSignal": true;
1981
+ };
1982
+ }, {}, never, ["*", "zur-chat-composer"], true, never>;
1983
+ }
1984
+ /** Uma mensagem. `continued` agrupa com a anterior do mesmo autor (esconde avatar e nome). */
1985
+ export declare class ZurChatMessage {
1986
+ readonly from: import("@angular/core").InputSignal<"me" | "them">;
1987
+ readonly author: import("@angular/core").InputSignal<string>;
1988
+ readonly avatar: import("@angular/core").InputSignal<string | null>;
1989
+ /** Texto curto de horário, já formatado ("10:42"). */
1990
+ readonly time: import("@angular/core").InputSignal<string>;
1991
+ readonly continued: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
1992
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurChatMessage, never>;
1993
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurChatMessage, "zur-chat-message", never, {
1994
+ "from": {
1995
+ "alias": "from";
1996
+ "required": false;
1997
+ "isSignal": true;
1998
+ };
1999
+ "author": {
2000
+ "alias": "author";
2001
+ "required": false;
2002
+ "isSignal": true;
2003
+ };
2004
+ "avatar": {
2005
+ "alias": "avatar";
2006
+ "required": false;
2007
+ "isSignal": true;
2008
+ };
2009
+ "time": {
2010
+ "alias": "time";
2011
+ "required": false;
2012
+ "isSignal": true;
2013
+ };
2014
+ "continued": {
2015
+ "alias": "continued";
2016
+ "required": false;
2017
+ "isSignal": true;
2018
+ };
2019
+ }, {}, never, ["*"], true, never>;
2020
+ }
2021
+ /** Separador de data/assunto entre grupos de mensagens. */
2022
+ export declare class ZurChatDivider {
2023
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurChatDivider, never>;
2024
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurChatDivider, "zur-chat-divider", never, {}, {}, never, ["*"], true, never>;
2025
+ }
2026
+ /** Indicador "digitando…" com três pontos (parados se o usuário pede menos movimento). */
2027
+ export declare class ZurChatTyping {
2028
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
2029
+ readonly name: import("@angular/core").InputSignal<string>;
2030
+ readonly avatar: import("@angular/core").InputSignal<string | null>;
2031
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurChatTyping, never>;
2032
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurChatTyping, "zur-chat-typing", never, {
2033
+ "name": {
2034
+ "alias": "name";
2035
+ "required": true;
2036
+ "isSignal": true;
2037
+ };
2038
+ "avatar": {
2039
+ "alias": "avatar";
2040
+ "required": false;
2041
+ "isSignal": true;
2042
+ };
2043
+ }, {}, never, never, true, never>;
2044
+ }
2045
+ /**
2046
+ * Campo de envio: cresce com o texto até `maxRows`, Enter envia, Shift+Enter quebra
2047
+ * linha. Com `attach`, mostra o botão de anexo e emite os arquivos escolhidos.
2048
+ */
2049
+ export declare class ZurChatComposer {
2050
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
2051
+ readonly placeholder: import("@angular/core").InputSignal<string>;
2052
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
2053
+ readonly attach: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
2054
+ readonly accept: import("@angular/core").InputSignal<string>;
2055
+ /** Linhas máximas antes de rolar. */
2056
+ readonly maxRows: import("@angular/core").InputSignalWithTransform<number, unknown>;
2057
+ readonly send: import("@angular/core").OutputEmitterRef<string>;
2058
+ readonly attached: import("@angular/core").OutputEmitterRef<File[]>;
2059
+ protected readonly text: import("@angular/core").WritableSignal<string>;
2060
+ protected readonly canSend: import("@angular/core").Signal<boolean>;
2061
+ private readonly field;
2062
+ protected onInput(event: Event): void;
2063
+ protected onKeydown(event: KeyboardEvent): void;
2064
+ submit(): void;
2065
+ protected onFiles(event: Event): void;
2066
+ private resize;
2067
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurChatComposer, never>;
2068
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurChatComposer, "zur-chat-composer", never, {
2069
+ "placeholder": {
2070
+ "alias": "placeholder";
2071
+ "required": false;
2072
+ "isSignal": true;
2073
+ };
2074
+ "disabled": {
2075
+ "alias": "disabled";
2076
+ "required": false;
2077
+ "isSignal": true;
2078
+ };
2079
+ "attach": {
2080
+ "alias": "attach";
2081
+ "required": false;
2082
+ "isSignal": true;
2083
+ };
2084
+ "accept": {
2085
+ "alias": "accept";
2086
+ "required": false;
2087
+ "isSignal": true;
2088
+ };
2089
+ "maxRows": {
2090
+ "alias": "maxRows";
2091
+ "required": false;
2092
+ "isSignal": true;
2093
+ };
2094
+ }, {
2095
+ "send": "send";
2096
+ "attached": "attached";
2097
+ }, never, never, true, never>;
2098
+ }
2099
+ export interface ZurCommand {
2100
+ id: string;
2101
+ label: string;
2102
+ /** Título do grupo em que o comando aparece. */
2103
+ group?: string;
2104
+ description?: string;
2105
+ /** Atalho exibido à direita, ex.: `['G', 'P']` ou `['Ctrl', 'N']`. */
2106
+ shortcut?: string[];
2107
+ /** Atributo `d` de um path SVG 24×24 (traço), desenhado como ícone. */
2108
+ icon?: string;
2109
+ /** Termos extras que também acham o comando na busca. */
2110
+ keywords?: string[];
2111
+ }
2112
+ interface ZurCommandGroup {
2113
+ name: string;
2114
+ items: {
2115
+ command: ZurCommand;
2116
+ index: number;
2117
+ }[];
2118
+ }
2119
+ /**
2120
+ * Busca global de páginas e ações (estilo Linear/Raycast). Abre com Ctrl+K / ⌘K
2121
+ * (desligue com `[hotkey]="false"`) ou por `[(open)]`; filtra ignorando acentos e por
2122
+ * iniciais; setas navegam, Enter executa, Esc fecha e devolve o foco.
2123
+ *
2124
+ * ```html
2125
+ * <zur-command-palette [commands]="comandos" (selected)="executar($event)" />
2126
+ * ```
2127
+ */
2128
+ export declare class ZurCommandPalette {
2129
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
2130
+ private readonly doc;
2131
+ readonly commands: import("@angular/core").InputSignal<ZurCommand[]>;
2132
+ readonly open: import("@angular/core").ModelSignal<boolean>;
2133
+ readonly placeholder: import("@angular/core").InputSignal<string>;
2134
+ /** Abre/fecha com Ctrl+K / ⌘K. */
2135
+ readonly hotkey: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
2136
+ readonly selected: import("@angular/core").OutputEmitterRef<ZurCommand>;
2137
+ protected readonly listId: string;
2138
+ protected readonly query: import("@angular/core").WritableSignal<string>;
2139
+ protected readonly active: import("@angular/core").WritableSignal<number>;
2140
+ private readonly field;
2141
+ private returnFocus;
2142
+ /** Comandos filtrados, na ordem em que aparecem (agrupados). */
2143
+ protected readonly flat: import("@angular/core").Signal<ZurCommand[]>;
2144
+ protected readonly groups: import("@angular/core").Signal<ZurCommandGroup[]>;
2145
+ constructor();
2146
+ protected optionId(i: number): string;
2147
+ show(): void;
2148
+ close(): void;
2149
+ protected run(command: ZurCommand): void;
2150
+ protected onInput(event: Event): void;
2151
+ protected onDocumentKeydown(event: KeyboardEvent): void;
2152
+ protected onKeydown(event: KeyboardEvent): void;
2153
+ private scrollActiveIntoView;
2154
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurCommandPalette, never>;
2155
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurCommandPalette, "zur-command-palette", never, {
2156
+ "commands": {
2157
+ "alias": "commands";
2158
+ "required": false;
2159
+ "isSignal": true;
2160
+ };
2161
+ "open": {
2162
+ "alias": "open";
2163
+ "required": false;
2164
+ "isSignal": true;
2165
+ };
2166
+ "placeholder": {
2167
+ "alias": "placeholder";
2168
+ "required": false;
2169
+ "isSignal": true;
2170
+ };
2171
+ "hotkey": {
2172
+ "alias": "hotkey";
2173
+ "required": false;
2174
+ "isSignal": true;
2175
+ };
2176
+ }, {
2177
+ "open": "openChange";
2178
+ "selected": "selected";
2179
+ }, never, never, true, never>;
2180
+ }
2181
+ export type ZurNotificationKind = 'info' | 'success' | 'warning' | 'error';
2182
+ export interface ZurNotification {
2183
+ id: string;
2184
+ title: string;
2185
+ body?: string;
2186
+ /** Quando aconteceu — decide o grupo (Hoje / Anteriores). */
2187
+ date: Date;
2188
+ /** Texto curto de horário já formatado ("há 5 min", "ontem"). */
2189
+ time?: string;
2190
+ read: boolean;
2191
+ kind?: ZurNotificationKind;
2192
+ }
2193
+ /**
2194
+ * Sino com contador de não lidas que abre um painel com as notificações agrupadas
2195
+ * em Hoje e Anteriores. Os dados vêm de fora: o componente avisa `read` (clique em
2196
+ * um item) e `readAll`, e quem usa atualiza a lista.
2197
+ *
2198
+ * ```html
2199
+ * <zur-notification-center [notifications]="avisos()"
2200
+ * (read)="marcarLida($event)" (readAll)="marcarTodas()" />
2201
+ * ```
2202
+ */
2203
+ export declare class ZurNotificationCenter {
2204
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
2205
+ readonly notifications: import("@angular/core").InputSignal<ZurNotification[]>;
2206
+ readonly placement: import("@angular/core").InputSignal<ZurPopoverPlacement>;
2207
+ readonly open: import("@angular/core").ModelSignal<boolean>;
2208
+ /** Texto abaixo de "Nada por aqui" quando a lista está vazia. */
2209
+ readonly emptyDescription: import("@angular/core").InputSignal<string>;
2210
+ /** Clique em uma notificação (para marcá-la como lida e navegar). */
2211
+ readonly read: import("@angular/core").OutputEmitterRef<ZurNotification>;
2212
+ readonly readAll: import("@angular/core").OutputEmitterRef<void>;
2213
+ protected readonly unread: import("@angular/core").Signal<number>;
2214
+ protected readonly groups: import("@angular/core").Signal<{
2215
+ name: string;
2216
+ items: ZurNotification[];
2217
+ }[]>;
2218
+ protected onItem(item: ZurNotification): void;
2219
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurNotificationCenter, never>;
2220
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurNotificationCenter, "zur-notification-center", never, {
2221
+ "notifications": {
2222
+ "alias": "notifications";
2223
+ "required": false;
2224
+ "isSignal": true;
2225
+ };
2226
+ "placement": {
2227
+ "alias": "placement";
2228
+ "required": false;
2229
+ "isSignal": true;
2230
+ };
2231
+ "open": {
2232
+ "alias": "open";
2233
+ "required": false;
2234
+ "isSignal": true;
2235
+ };
2236
+ "emptyDescription": {
2237
+ "alias": "emptyDescription";
2238
+ "required": false;
2239
+ "isSignal": true;
2240
+ };
2241
+ }, {
2242
+ "open": "openChange";
2243
+ "read": "read";
2244
+ "readAll": "readAll";
2245
+ }, never, never, true, never>;
2246
+ }
2247
+ export interface ZurKanbanItem {
2248
+ id: string;
2249
+ title?: string;
2250
+ }
2251
+ export interface ZurKanbanColumn<T extends ZurKanbanItem = ZurKanbanItem> {
2252
+ id: string;
2253
+ title: string;
2254
+ items: T[];
2255
+ }
2256
+ export interface ZurKanbanMove<T extends ZurKanbanItem = ZurKanbanItem> {
2257
+ item: T;
2258
+ from: string;
2259
+ to: string;
2260
+ fromIndex: number;
2261
+ toIndex: number;
2262
+ }
2263
+ /** Template do cartão: `<ng-template zurKanbanCard let-item let-column="column">`. */
2264
+ export declare class ZurKanbanCard {
2265
+ readonly template: TemplateRef<{
2266
+ $implicit: ZurKanbanItem;
2267
+ column: ZurKanbanColumn;
2268
+ }>;
2269
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurKanbanCard, never>;
2270
+ static ɵdir: i0.ɵɵDirectiveDeclaration<ZurKanbanCard, "ng-template[zurKanbanCard]", never, {}, {}, never, never, true, never>;
2271
+ }
2272
+ interface Grab {
2273
+ itemId: string;
2274
+ /** Posição antes do arrasto por teclado, para o Esc desfazer. */
2275
+ origin: {
2276
+ column: string;
2277
+ index: number;
2278
+ };
2279
+ }
2280
+ /** Move um item entre colunas devolvendo um novo array (imutável). */
2281
+ export declare function zurKanbanMove<T extends ZurKanbanItem>(columns: ZurKanbanColumn<T>[], itemId: string, to: string, toIndex: number): {
2282
+ columns: ZurKanbanColumn<T>[];
2283
+ move: ZurKanbanMove<T>;
2284
+ } | null;
2285
+ /**
2286
+ * Quadro de colunas com cartões arrastáveis. Arrasta com mouse/toque (drag and drop
2287
+ * nativo) ou teclado: Espaço pega o cartão, setas movem (↑↓ na coluna, ←→ entre
2288
+ * colunas), Espaço solta e Esc desfaz — cada passo é anunciado a leitores de tela.
2289
+ * `columns` é two-way e `moved` informa cada movimento.
2290
+ *
2291
+ * ```html
2292
+ * <zur-kanban [(columns)]="colunas" (moved)="salvar($event)">
2293
+ * <ng-template zurKanbanCard let-item>{{ item.title }}</ng-template>
2294
+ * </zur-kanban>
2295
+ * ```
2296
+ */
2297
+ export declare class ZurKanban {
2298
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
2299
+ private readonly host;
2300
+ readonly columns: import("@angular/core").ModelSignal<ZurKanbanColumn<ZurKanbanItem>[]>;
2301
+ /** Rótulo do botão "adicionar" no pé de cada coluna; vazio esconde o botão. */
2302
+ readonly addLabel: import("@angular/core").InputSignal<string>;
2303
+ /** Texto usado nos anúncios do teclado. Padrão: `title` ou `id` do item. */
2304
+ readonly cardLabel: import("@angular/core").InputSignal<(item: ZurKanbanItem) => string>;
2305
+ readonly moved: import("@angular/core").OutputEmitterRef<ZurKanbanMove<ZurKanbanItem>>;
2306
+ readonly add: import("@angular/core").OutputEmitterRef<string>;
2307
+ protected readonly cardTemplate: import("@angular/core").Signal<ZurKanbanCard | undefined>;
2308
+ protected readonly instructionsId: string;
2309
+ protected readonly dragId: import("@angular/core").WritableSignal<string | null>;
2310
+ protected readonly dropTarget: import("@angular/core").WritableSignal<{
2311
+ column: string;
2312
+ index: number;
2313
+ } | null>;
2314
+ protected readonly grab: import("@angular/core").WritableSignal<Grab | null>;
2315
+ protected readonly announcement: import("@angular/core").WritableSignal<string>;
2316
+ protected labelOf(item: ZurKanbanItem): string;
2317
+ private columnTitle;
2318
+ private locate;
2319
+ /** Aplica o movimento; retorna se algo mudou. */
2320
+ moveItem(itemId: string, to: string, toIndex: number): boolean;
2321
+ protected onDragStart(event: DragEvent, itemId: string): void;
2322
+ protected onDragOver(event: DragEvent, column: string): void;
2323
+ protected onDragLeave(event: DragEvent): void;
2324
+ protected onDrop(event: DragEvent, column: string): void;
2325
+ protected onDragEnd(): void;
2326
+ protected onKeydown(event: KeyboardEvent, item: ZurKanbanItem, column: string): void;
2327
+ /** Soltar ao sair do cartão (Tab) para não deixar um cartão "preso". */
2328
+ protected onBlur(item: ZurKanbanItem): void;
2329
+ private refocus;
2330
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurKanban, never>;
2331
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurKanban, "zur-kanban", never, {
2332
+ "columns": {
2333
+ "alias": "columns";
2334
+ "required": false;
2335
+ "isSignal": true;
2336
+ };
2337
+ "addLabel": {
2338
+ "alias": "addLabel";
2339
+ "required": false;
2340
+ "isSignal": true;
2341
+ };
2342
+ "cardLabel": {
2343
+ "alias": "cardLabel";
2344
+ "required": false;
2345
+ "isSignal": true;
2346
+ };
2347
+ }, {
2348
+ "columns": "columnsChange";
2349
+ "moved": "moved";
2350
+ "add": "add";
2351
+ }, ["cardTemplate"], never, true, never>;
2352
+ }
2353
+ export {};