@juau/zuri 0.0.0-stage → 0.1.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.
@@ -0,0 +1,1391 @@
1
+ import * as i0 from "@angular/core";
2
+ import { ElementRef, InjectionToken, OnDestroy, OnInit, Provider } from "@angular/core";
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
+ /** Botão de fechar (modal, toast, drawer). */
11
+ close: string;
12
+ /** Botão de voltar (lista e detalhe no mobile). */
13
+ back: string;
14
+ /** Botão do topbar que recolhe a sidebar ou abre a gaveta. */
15
+ toggleNav: string;
16
+ /** Região da sidebar. */
17
+ sideNav: string;
18
+ /** Links do topbar. */
19
+ topNav: string;
20
+ /** Links do rodapé. */
21
+ footerNav: string;
22
+ /** Lista de etapas do formulário/wizard. */
23
+ steps: string;
24
+ /** Painel da lista (lista e detalhe). */
25
+ list: string;
26
+ /** Painel do detalhe (lista e detalhe). */
27
+ detail: string;
28
+ /** Região do breadcrumb. */
29
+ breadcrumb: string;
30
+ /** Botão de tema quando o tema atual é escuro. */
31
+ themeToLight: string;
32
+ /** Botão de tema quando o tema atual é claro. */
33
+ themeToDark: string;
34
+ /** Paginação. */
35
+ pagination: string;
36
+ previousPage: string;
37
+ nextPage: string;
38
+ /** Rótulo de cada página, ex.: "Página 3". */
39
+ page: (n: number) => string;
40
+ /** Rótulo padrão da barra de progresso. */
41
+ progress: string;
42
+ /** Contador de caracteres do textarea, ex.: "12 de 200 caracteres". */
43
+ characterCount: (count: number, max: number) => string;
44
+ }
45
+ export declare const ZUR_I18N_PT: ZurI18n;
46
+ export declare const ZUR_I18N_EN: ZurI18n;
47
+ /** Textos usados pelos componentes. Padrão: português. */
48
+ export declare const ZUR_I18N: InjectionToken<ZurI18n>;
49
+ /**
50
+ * Define o idioma dos textos internos dos componentes.
51
+ *
52
+ * ```ts
53
+ * bootstrapApplication(App, { providers: [provideZuriI18n('en')] });
54
+ * // ou só algumas chaves, sobre o português:
55
+ * provideZuriI18n({ close: 'Fechar janela' });
56
+ * // ou sobre o inglês:
57
+ * provideZuriI18n({ ...ZUR_I18N_EN, close: 'Dismiss' });
58
+ * ```
59
+ */
60
+ export declare function provideZuriI18n(config: 'pt' | 'en' | Partial<ZurI18n>): Provider;
61
+ export type ZurTheme = 'light' | 'dark';
62
+ /**
63
+ * Elemento cujo `data-theme` o serviço controla. Fornecido por `zurThemeScope`
64
+ * para criar um tema isolado; sem ele, o serviço controla o `<html>`.
65
+ */
66
+ export declare const ZUR_THEME_SCOPE: InjectionToken<ElementRef<HTMLElement>>;
67
+ /**
68
+ * Controla o tema claro/escuro do Zuri.
69
+ *
70
+ * - Global (padrão): aplica `data-theme` no `<html>`, persiste em localStorage e usa
71
+ * `prefers-color-scheme` como padrão na primeira visita.
72
+ * - Escopo (`zurThemeScope`): aplica `data-theme` só no elemento do escopo, não persiste
73
+ * e segue o tema global até o usuário alternar localmente.
74
+ */
75
+ export declare class ZurThemeService {
76
+ private readonly doc;
77
+ private readonly scope;
78
+ /** Serviço do nível acima, quando este é um escopo (ver `zurThemeScope`). */
79
+ private readonly parent;
80
+ readonly theme: import("@angular/core").WritableSignal<ZurTheme>;
81
+ constructor();
82
+ toggle(): void;
83
+ set(theme: ZurTheme): void;
84
+ private initialTheme;
85
+ private apply;
86
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurThemeService, never>;
87
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
88
+ }
89
+ /**
90
+ * Botão circular sol/lua que alterna entre os temas claro e escuro.
91
+ * Mostra a lua no tema claro ("ir para o escuro") e o sol no escuro.
92
+ */
93
+ export declare class ZurThemeToggle {
94
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
95
+ protected readonly themeService: ZurThemeService;
96
+ protected readonly isDark: import("@angular/core").Signal<boolean>;
97
+ protected readonly label: import("@angular/core").Signal<string>;
98
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurThemeToggle, never>;
99
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurThemeToggle, "zur-theme-toggle", never, {}, {}, never, never, true, never>;
100
+ }
101
+ /**
102
+ * Cria um tema isolado: o `zur-theme-toggle` (e qualquer `ZurThemeService`) dentro do
103
+ * elemento muda só o tema dele, sem tocar no resto da página. Começa no tema da página,
104
+ * acompanha-o quando ele muda e não persiste a escolha local.
105
+ *
106
+ * ```html
107
+ * <div zurThemeScope>
108
+ * <zur-navbar>… <zur-theme-toggle /> …</zur-navbar>
109
+ * </div>
110
+ * ```
111
+ */
112
+ export declare class ZurThemeScope {
113
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurThemeScope, never>;
114
+ static ɵdir: i0.ɵɵDirectiveDeclaration<ZurThemeScope, "[zurThemeScope]", never, {}, {}, never, never, true, never>;
115
+ }
116
+ export type ZurLogoVariant = 'horizontal' | 'symbol' | 'auto';
117
+ /**
118
+ * Logo do Zuri: o Z com broto é a primeira letra de "zuri". As cores vêm dos tokens
119
+ * (`--zur-primary`, `--zur-primary-active`, `--zur-ink`), então acompanha o tema
120
+ * claro/escuro sozinho.
121
+ *
122
+ * - `horizontal`: símbolo + "zuri";
123
+ * - `symbol`: só o símbolo (favicon, sidebar recolhida);
124
+ * - `auto`: horizontal, mas vira símbolo quando a sidebar do layout está recolhida.
125
+ *
126
+ * ```html
127
+ * <zur-logo />
128
+ * <zur-logo variant="symbol" [size]="24" />
129
+ * ```
130
+ */
131
+ export declare class ZurLogo {
132
+ private readonly shell;
133
+ readonly variant: import("@angular/core").InputSignal<ZurLogoVariant>;
134
+ /** Altura em px (a largura segue a proporção do logo). */
135
+ readonly size: import("@angular/core").InputSignal<number>;
136
+ protected readonly symbolOnly: import("@angular/core").Signal<boolean>;
137
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurLogo, never>;
138
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurLogo, "zur-logo", never, {
139
+ "variant": {
140
+ "alias": "variant";
141
+ "required": false;
142
+ "isSignal": true;
143
+ };
144
+ "size": {
145
+ "alias": "size";
146
+ "required": false;
147
+ "isSignal": true;
148
+ };
149
+ }, {}, never, never, true, never>;
150
+ }
151
+ export type ZurButtonVariant = 'primary' | 'secondary' | 'ghost' | 'pill';
152
+ export type ZurButtonSize = 'sm' | 'md' | 'lg';
153
+ /**
154
+ * Botão do Zuri. Aplicado como atributo em <button> ou <a> nativos
155
+ * para preservar semântica e acessibilidade.
156
+ *
157
+ * ```html
158
+ * <button zur-button variant="primary" size="md">Reservar</button>
159
+ * ```
160
+ */
161
+ export declare class ZurButton {
162
+ readonly variant: import("@angular/core").InputSignal<ZurButtonVariant>;
163
+ readonly size: import("@angular/core").InputSignal<ZurButtonSize>;
164
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurButton, never>;
165
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurButton, "button[zur-button], a[zur-button]", never, {
166
+ "variant": {
167
+ "alias": "variant";
168
+ "required": false;
169
+ "isSignal": true;
170
+ };
171
+ "size": {
172
+ "alias": "size";
173
+ "required": false;
174
+ "isSignal": true;
175
+ };
176
+ }, {}, never, ["*"], true, never>;
177
+ }
178
+ export type ZurBadgeColor = 'mint' | 'success' | 'warning' | 'error' | 'info' | 'neutral';
179
+ /** Badge/tag em pill com as cores soft do sistema. */
180
+ export declare class ZurBadge {
181
+ readonly color: import("@angular/core").InputSignal<ZurBadgeColor>;
182
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurBadge, never>;
183
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurBadge, "zur-badge", never, {
184
+ "color": {
185
+ "alias": "color";
186
+ "required": false;
187
+ "isSignal": true;
188
+ };
189
+ }, {}, never, ["*"], true, never>;
190
+ }
191
+ /**
192
+ * Card do Zuri — superfície 14px com hairline.
193
+ * Com `interactive`, eleva ao tier único de sombra no hover (Airbnb).
194
+ */
195
+ export declare class ZurCard {
196
+ readonly interactive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
197
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurCard, never>;
198
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurCard, "zur-card", never, {
199
+ "interactive": {
200
+ "alias": "interactive";
201
+ "required": false;
202
+ "isSignal": true;
203
+ };
204
+ }, {}, never, ["*"], true, never>;
205
+ }
206
+ export type ZurAvatarSize = 'sm' | 'md' | 'lg';
207
+ /** Avatar circular com imagem ou iniciais derivadas do nome. */
208
+ export declare class ZurAvatar {
209
+ readonly name: import("@angular/core").InputSignal<string>;
210
+ readonly src: import("@angular/core").InputSignal<string | null>;
211
+ readonly size: import("@angular/core").InputSignal<ZurAvatarSize>;
212
+ protected readonly initials: import("@angular/core").Signal<string>;
213
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurAvatar, never>;
214
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurAvatar, "zur-avatar", never, {
215
+ "name": {
216
+ "alias": "name";
217
+ "required": false;
218
+ "isSignal": true;
219
+ };
220
+ "src": {
221
+ "alias": "src";
222
+ "required": false;
223
+ "isSignal": true;
224
+ };
225
+ "size": {
226
+ "alias": "size";
227
+ "required": false;
228
+ "isSignal": true;
229
+ };
230
+ }, {}, never, never, true, never>;
231
+ }
232
+ /**
233
+ * Campo de texto do Zuri — 56px, label em caption acima,
234
+ * foco com borda 2px ink (sem glow, Airbnb), erro em vermelho semântico.
235
+ */
236
+ export declare class ZurInput implements ControlValueAccessor {
237
+ readonly label: import("@angular/core").InputSignal<string>;
238
+ readonly type: import("@angular/core").InputSignal<string>;
239
+ readonly placeholder: import("@angular/core").InputSignal<string>;
240
+ readonly hint: import("@angular/core").InputSignal<string>;
241
+ readonly error: import("@angular/core").InputSignal<string>;
242
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
243
+ protected readonly id: string;
244
+ protected readonly value: import("@angular/core").WritableSignal<string>;
245
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
246
+ protected onChange: (value: string) => void;
247
+ protected onTouched: () => void;
248
+ protected isDisabled(): boolean;
249
+ protected get describedBy(): string | null;
250
+ protected onInput(event: Event): void;
251
+ writeValue(value: string | null): void;
252
+ registerOnChange(fn: (value: string) => void): void;
253
+ registerOnTouched(fn: () => void): void;
254
+ setDisabledState(isDisabled: boolean): void;
255
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurInput, never>;
256
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurInput, "zur-input", never, {
257
+ "label": {
258
+ "alias": "label";
259
+ "required": false;
260
+ "isSignal": true;
261
+ };
262
+ "type": {
263
+ "alias": "type";
264
+ "required": false;
265
+ "isSignal": true;
266
+ };
267
+ "placeholder": {
268
+ "alias": "placeholder";
269
+ "required": false;
270
+ "isSignal": true;
271
+ };
272
+ "hint": {
273
+ "alias": "hint";
274
+ "required": false;
275
+ "isSignal": true;
276
+ };
277
+ "error": {
278
+ "alias": "error";
279
+ "required": false;
280
+ "isSignal": true;
281
+ };
282
+ "disabled": {
283
+ "alias": "disabled";
284
+ "required": false;
285
+ "isSignal": true;
286
+ };
287
+ }, {}, never, never, true, never>;
288
+ }
289
+ export interface ZurSelectOption {
290
+ value: string;
291
+ label: string;
292
+ }
293
+ /** Select do Zuri — mesmo chrome do input, seta customizada, nativo por baixo. */
294
+ export declare class ZurSelect implements ControlValueAccessor {
295
+ readonly label: import("@angular/core").InputSignal<string>;
296
+ readonly placeholder: import("@angular/core").InputSignal<string>;
297
+ readonly options: import("@angular/core").InputSignal<ZurSelectOption[]>;
298
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
299
+ protected readonly id: string;
300
+ protected readonly value: import("@angular/core").WritableSignal<string>;
301
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
302
+ protected onChange: (value: string) => void;
303
+ protected onTouched: () => void;
304
+ protected isDisabled(): boolean;
305
+ protected onSelect(event: Event): void;
306
+ writeValue(value: string | null): void;
307
+ registerOnChange(fn: (value: string) => void): void;
308
+ registerOnTouched(fn: () => void): void;
309
+ setDisabledState(isDisabled: boolean): void;
310
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSelect, never>;
311
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSelect, "zur-select", never, {
312
+ "label": {
313
+ "alias": "label";
314
+ "required": false;
315
+ "isSignal": true;
316
+ };
317
+ "placeholder": {
318
+ "alias": "placeholder";
319
+ "required": false;
320
+ "isSignal": true;
321
+ };
322
+ "options": {
323
+ "alias": "options";
324
+ "required": false;
325
+ "isSignal": true;
326
+ };
327
+ "disabled": {
328
+ "alias": "disabled";
329
+ "required": false;
330
+ "isSignal": true;
331
+ };
332
+ }, {}, never, never, true, never>;
333
+ }
334
+ /** Checkbox 20px — marcado em menta com check em tinta profunda. */
335
+ export declare class ZurCheckbox implements ControlValueAccessor {
336
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
337
+ protected readonly id: string;
338
+ protected readonly checked: import("@angular/core").WritableSignal<boolean>;
339
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
340
+ protected onChange: (value: boolean) => void;
341
+ protected onTouched: () => void;
342
+ protected isDisabled(): boolean;
343
+ protected onToggle(event: Event): void;
344
+ writeValue(value: boolean | null): void;
345
+ registerOnChange(fn: (value: boolean) => void): void;
346
+ registerOnTouched(fn: () => void): void;
347
+ setDisabledState(isDisabled: boolean): void;
348
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurCheckbox, never>;
349
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurCheckbox, "zur-checkbox", never, {
350
+ "disabled": {
351
+ "alias": "disabled";
352
+ "required": false;
353
+ "isSignal": true;
354
+ };
355
+ }, {}, never, ["*"], true, never>;
356
+ }
357
+ /**
358
+ * Radio 20px do Zuri. Vincule todos os radios de um grupo ao mesmo
359
+ * FormControl/ngModel e dê a eles o mesmo `name`.
360
+ */
361
+ export declare class ZurRadio implements ControlValueAccessor {
362
+ readonly value: import("@angular/core").InputSignal<string>;
363
+ readonly name: import("@angular/core").InputSignal<string>;
364
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
365
+ protected readonly id: string;
366
+ protected readonly model: import("@angular/core").WritableSignal<string | null>;
367
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
368
+ protected onChange: (value: string) => void;
369
+ protected onTouched: () => void;
370
+ protected checked(): boolean;
371
+ protected isDisabled(): boolean;
372
+ protected onSelect(): void;
373
+ writeValue(value: string | null): void;
374
+ registerOnChange(fn: (value: string) => void): void;
375
+ registerOnTouched(fn: () => void): void;
376
+ setDisabledState(isDisabled: boolean): void;
377
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurRadio, never>;
378
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurRadio, "zur-radio", never, {
379
+ "value": {
380
+ "alias": "value";
381
+ "required": true;
382
+ "isSignal": true;
383
+ };
384
+ "name": {
385
+ "alias": "name";
386
+ "required": false;
387
+ "isSignal": true;
388
+ };
389
+ "disabled": {
390
+ "alias": "disabled";
391
+ "required": false;
392
+ "isSignal": true;
393
+ };
394
+ }, {}, never, ["*"], true, never>;
395
+ }
396
+ export declare class ZurSwitch implements ControlValueAccessor {
397
+ /** Liga o texto projetado ao botão como nome acessível. */
398
+ protected readonly labelId: string;
399
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
400
+ protected readonly checked: import("@angular/core").WritableSignal<boolean>;
401
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
402
+ protected onChange: (value: boolean) => void;
403
+ protected onTouched: () => void;
404
+ protected isDisabled(): boolean;
405
+ protected toggle(): void;
406
+ writeValue(value: boolean | null): void;
407
+ registerOnChange(fn: (value: boolean) => void): void;
408
+ registerOnTouched(fn: () => void): void;
409
+ setDisabledState(isDisabled: boolean): void;
410
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSwitch, never>;
411
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSwitch, "zur-switch", never, {
412
+ "disabled": {
413
+ "alias": "disabled";
414
+ "required": false;
415
+ "isSignal": true;
416
+ };
417
+ }, {}, never, ["*"], true, never>;
418
+ }
419
+ /**
420
+ * Área de texto do Zuri: mesmo visual do `zur-input`, com contador opcional
421
+ * quando `maxlength` é definido. Funciona com `ngModel` e formulários reativos.
422
+ *
423
+ * ```html
424
+ * <zur-textarea label="Mensagem" [maxlength]="200" [(ngModel)]="mensagem" />
425
+ * ```
426
+ */
427
+ export declare class ZurTextarea implements ControlValueAccessor {
428
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
429
+ readonly label: import("@angular/core").InputSignal<string>;
430
+ readonly placeholder: import("@angular/core").InputSignal<string>;
431
+ readonly hint: import("@angular/core").InputSignal<string>;
432
+ readonly error: import("@angular/core").InputSignal<string>;
433
+ readonly rows: import("@angular/core").InputSignalWithTransform<number, unknown>;
434
+ /** Limite de caracteres; quando definido, mostra o contador. */
435
+ readonly maxlength: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
436
+ readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
437
+ protected readonly id: string;
438
+ protected readonly value: import("@angular/core").WritableSignal<string>;
439
+ protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
440
+ protected onChange: (value: string) => void;
441
+ protected onTouched: () => void;
442
+ protected readonly describedBy: import("@angular/core").Signal<string | null>;
443
+ protected isDisabled(): boolean;
444
+ protected onInput(event: Event): void;
445
+ writeValue(value: string | null): void;
446
+ registerOnChange(fn: (value: string) => void): void;
447
+ registerOnTouched(fn: () => void): void;
448
+ setDisabledState(isDisabled: boolean): void;
449
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTextarea, never>;
450
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurTextarea, "zur-textarea", never, {
451
+ "label": {
452
+ "alias": "label";
453
+ "required": false;
454
+ "isSignal": true;
455
+ };
456
+ "placeholder": {
457
+ "alias": "placeholder";
458
+ "required": false;
459
+ "isSignal": true;
460
+ };
461
+ "hint": {
462
+ "alias": "hint";
463
+ "required": false;
464
+ "isSignal": true;
465
+ };
466
+ "error": {
467
+ "alias": "error";
468
+ "required": false;
469
+ "isSignal": true;
470
+ };
471
+ "rows": {
472
+ "alias": "rows";
473
+ "required": false;
474
+ "isSignal": true;
475
+ };
476
+ "maxlength": {
477
+ "alias": "maxlength";
478
+ "required": false;
479
+ "isSignal": true;
480
+ };
481
+ "disabled": {
482
+ "alias": "disabled";
483
+ "required": false;
484
+ "isSignal": true;
485
+ };
486
+ }, {}, never, never, true, never>;
487
+ }
488
+ /**
489
+ * Navbar 80px — canvas com hairline inferior (Airbnb top-nav).
490
+ * Slots: [zurNavbarLogo], [zurNavbarLinks], [zurNavbarActions].
491
+ * Hospeda o <zur-theme-toggle> no slot de ações.
492
+ */
493
+ export declare class ZurNavbar {
494
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurNavbar, never>;
495
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurNavbar, "zur-navbar", never, {}, {}, never, ["[zurNavbarLogo]", "[zurNavbarLinks]", "[zurNavbarActions]"], true, never>;
496
+ }
497
+ /** Painel individual dentro de <zur-tabs>. */
498
+ export declare class ZurTab {
499
+ readonly label: import("@angular/core").InputSignal<string>;
500
+ readonly active: import("@angular/core").WritableSignal<boolean>;
501
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTab, never>;
502
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurTab, "zur-tab", never, {
503
+ "label": {
504
+ "alias": "label";
505
+ "required": true;
506
+ "isSignal": true;
507
+ };
508
+ }, {}, never, ["*"], true, never>;
509
+ }
510
+ /** Tabs com sublinhado 2px ink na aba ativa (Airbnb product-tabs). */
511
+ export declare class ZurTabs {
512
+ readonly index: import("@angular/core").ModelSignal<number>;
513
+ protected readonly tabs: import("@angular/core").Signal<readonly ZurTab[]>;
514
+ constructor();
515
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTabs, never>;
516
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurTabs, "zur-tabs", never, {
517
+ "index": {
518
+ "alias": "index";
519
+ "required": false;
520
+ "isSignal": true;
521
+ };
522
+ }, {
523
+ "index": "indexChange";
524
+ }, ["tabs"], ["*"], true, never>;
525
+ }
526
+ /** Item clicável dentro de <zur-menu>. */
527
+ export declare class ZurMenuItem {
528
+ readonly selected: import("@angular/core").OutputEmitterRef<void>;
529
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurMenuItem, never>;
530
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurMenuItem, "zur-menu-item", never, {}, {
531
+ "selected": "selected";
532
+ }, never, ["*"], true, never>;
533
+ }
534
+ /**
535
+ * Menu dropdown — gatilho via slot [zurMenuTrigger], painel no tier
536
+ * único de sombra. Fecha ao clicar fora ou pressionar ESC.
537
+ */
538
+ export declare class ZurMenu {
539
+ private readonly host;
540
+ readonly open: import("@angular/core").WritableSignal<boolean>;
541
+ toggle(): void;
542
+ close(): void;
543
+ protected onDocumentClick(event: MouseEvent): void;
544
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurMenu, never>;
545
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurMenu, "zur-menu", never, {}, {}, never, ["[zurMenuTrigger]", "*"], true, never>;
546
+ }
547
+ export interface ZurBreadcrumbItem {
548
+ label: string;
549
+ href?: string;
550
+ }
551
+ /** Breadcrumb em caption muted com separador "/". */
552
+ export declare class ZurBreadcrumb {
553
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
554
+ readonly items: import("@angular/core").InputSignal<ZurBreadcrumbItem[]>;
555
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurBreadcrumb, never>;
556
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurBreadcrumb, "zur-breadcrumb", never, {
557
+ "items": {
558
+ "alias": "items";
559
+ "required": false;
560
+ "isSignal": true;
561
+ };
562
+ }, {}, never, never, true, never>;
563
+ }
564
+ export type ZurSidenavItemLevel = 'primary' | 'secondary';
565
+ /**
566
+ * Navegação lateral do Zuri. Agrupa links (`zur-sidenav-item`) e rótulos de
567
+ * seção (`zur-sidenav-label`).
568
+ *
569
+ * ```html
570
+ * <zur-sidenav aria-label="Principal">
571
+ * <a zur-sidenav-item routerLink="/" routerLinkActive="active">Home</a>
572
+ * </zur-sidenav>
573
+ * ```
574
+ */
575
+ export declare class ZurSidenav {
576
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidenav, never>;
577
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidenav, "zur-sidenav", never, {}, {}, never, ["*"], true, never>;
578
+ }
579
+ /**
580
+ * Item da navegação lateral, aplicado a `<a>` ou `<button>`.
581
+ * Fica destacado (verde sólido) quando `active` é verdadeiro ou quando o
582
+ * elemento recebe a classe `active` (ex.: via `routerLinkActive="active"`).
583
+ */
584
+ export declare class ZurSidenavItem {
585
+ private readonly shell;
586
+ readonly level: import("@angular/core").InputSignal<ZurSidenavItemLevel>;
587
+ readonly active: import("@angular/core").InputSignal<boolean>;
588
+ /** `true` quando a sidebar do layout está recolhida (só ícones). */
589
+ protected readonly collapsed: import("@angular/core").Signal<boolean>;
590
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidenavItem, never>;
591
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidenavItem, "a[zur-sidenav-item], button[zur-sidenav-item]", never, {
592
+ "level": {
593
+ "alias": "level";
594
+ "required": false;
595
+ "isSignal": true;
596
+ };
597
+ "active": {
598
+ "alias": "active";
599
+ "required": false;
600
+ "isSignal": true;
601
+ };
602
+ }, {}, never, ["[zurSidenavIcon]", "*"], true, never>;
603
+ }
604
+ /** Rótulo de seção da navegação lateral (caption em caixa alta). */
605
+ export declare class ZurSidenavLabel {
606
+ private readonly shell;
607
+ protected readonly collapsed: import("@angular/core").Signal<boolean>;
608
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidenavLabel, never>;
609
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidenavLabel, "zur-sidenav-label", never, {}, {}, never, ["*"], true, never>;
610
+ }
611
+ export type ZurTableDensity = 'comfortable' | 'compact';
612
+ export type ZurSortDirection = 'asc' | 'desc';
613
+ export interface ZurSort {
614
+ key: string;
615
+ direction: ZurSortDirection;
616
+ }
617
+ /**
618
+ * Estilo do Zuri para uma `<table>` nativa: cabeçalho em caption, linhas com
619
+ * hairline, hover e densidade. A ordenação fica com você: marque as colunas com
620
+ * `zurSortable` e reaja ao `sortChange`.
621
+ *
622
+ * ```html
623
+ * <table zur-table (sortChange)="ordenar($event)">
624
+ * <thead>
625
+ * <tr><th zurSortable="nome">Nome</th><th>Destino</th></tr>
626
+ * </thead>
627
+ * <tbody>…</tbody>
628
+ * </table>
629
+ * ```
630
+ */
631
+ export declare class ZurTable {
632
+ readonly density: import("@angular/core").InputSignal<ZurTableDensity>;
633
+ /** Emite a coluna e a direção sempre que o usuário ordena. */
634
+ readonly sortChange: import("@angular/core").OutputEmitterRef<ZurSort>;
635
+ readonly sort: import("@angular/core").WritableSignal<ZurSort | null>;
636
+ toggleSort(key: string): void;
637
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTable, never>;
638
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurTable, "table[zur-table]", never, {
639
+ "density": {
640
+ "alias": "density";
641
+ "required": false;
642
+ "isSignal": true;
643
+ };
644
+ }, {
645
+ "sortChange": "sortChange";
646
+ }, never, ["*"], true, never>;
647
+ }
648
+ /** Torna um `<th>` ordenável dentro de `table[zur-table]`. O valor é a chave da coluna. */
649
+ export declare class ZurSortable {
650
+ protected readonly table: ZurTable;
651
+ readonly zurSortable: import("@angular/core").InputSignal<string>;
652
+ protected readonly ariaSort: import("@angular/core").Signal<"none" | "ascending" | "descending">;
653
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSortable, never>;
654
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSortable, "th[zurSortable]", never, {
655
+ "zurSortable": {
656
+ "alias": "zurSortable";
657
+ "required": true;
658
+ "isSignal": true;
659
+ };
660
+ }, {}, never, ["*"], true, never>;
661
+ }
662
+ type PageItem = number | 'gap';
663
+ /**
664
+ * Paginação: anterior, números (com reticências quando são muitos) e próxima.
665
+ * `page` começa em 1 e é two-way.
666
+ *
667
+ * ```html
668
+ * <zur-pagination [total]="248" [pageSize]="20" [(page)]="pagina" />
669
+ * ```
670
+ */
671
+ export declare class ZurPagination {
672
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
673
+ /** Página atual, começando em 1. */
674
+ readonly page: import("@angular/core").ModelSignal<number>;
675
+ /** Total de itens. */
676
+ readonly total: import("@angular/core").InputSignal<number>;
677
+ readonly pageSize: import("@angular/core").InputSignal<number>;
678
+ /** Quantas páginas mostrar de cada lado da atual. */
679
+ readonly siblings: import("@angular/core").InputSignal<number>;
680
+ readonly pageCount: import("@angular/core").Signal<number>;
681
+ protected readonly items: import("@angular/core").Signal<PageItem[]>;
682
+ protected go(p: number): void;
683
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurPagination, never>;
684
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurPagination, "zur-pagination", never, {
685
+ "page": {
686
+ "alias": "page";
687
+ "required": false;
688
+ "isSignal": true;
689
+ };
690
+ "total": {
691
+ "alias": "total";
692
+ "required": true;
693
+ "isSignal": true;
694
+ };
695
+ "pageSize": {
696
+ "alias": "pageSize";
697
+ "required": false;
698
+ "isSignal": true;
699
+ };
700
+ "siblings": {
701
+ "alias": "siblings";
702
+ "required": false;
703
+ "isSignal": true;
704
+ };
705
+ }, {
706
+ "page": "pageChange";
707
+ }, never, never, true, never>;
708
+ }
709
+ /**
710
+ * Seções expansíveis. Por padrão só uma fica aberta por vez; com `multi`, várias.
711
+ * Setas ↑/↓, Home e End movem o foco entre os cabeçalhos.
712
+ *
713
+ * ```html
714
+ * <zur-accordion>
715
+ * <zur-accordion-item title="Como funciona o check-in?">…</zur-accordion-item>
716
+ * <zur-accordion-item title="Posso cancelar?">…</zur-accordion-item>
717
+ * </zur-accordion>
718
+ * ```
719
+ */
720
+ export declare class ZurAccordion {
721
+ private readonly host;
722
+ /** Permite várias seções abertas ao mesmo tempo. */
723
+ readonly multi: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
724
+ private readonly items;
725
+ /** Chamado por um item ao abrir: fecha os outros quando não é `multi`. */
726
+ itemOpened(opened: ZurAccordionItem): void;
727
+ protected onKeydown(event: KeyboardEvent): void;
728
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurAccordion, never>;
729
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurAccordion, "zur-accordion", never, {
730
+ "multi": {
731
+ "alias": "multi";
732
+ "required": false;
733
+ "isSignal": true;
734
+ };
735
+ }, {}, ["items"], ["*"], true, never>;
736
+ }
737
+ export declare class ZurAccordionItem {
738
+ private readonly accordion;
739
+ readonly title: import("@angular/core").InputSignal<string>;
740
+ readonly open: import("@angular/core").ModelSignal<boolean>;
741
+ protected readonly id: string;
742
+ toggle(): void;
743
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurAccordionItem, never>;
744
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurAccordionItem, "zur-accordion-item", never, {
745
+ "title": {
746
+ "alias": "title";
747
+ "required": true;
748
+ "isSignal": true;
749
+ };
750
+ "open": {
751
+ "alias": "open";
752
+ "required": false;
753
+ "isSignal": true;
754
+ };
755
+ }, {
756
+ "open": "openChange";
757
+ }, never, ["*"], true, never>;
758
+ }
759
+ /**
760
+ * Estado vazio: ícone, título, descrição e ações, centralizados. Use em listas,
761
+ * buscas sem resultado ou telas que ainda não têm conteúdo.
762
+ *
763
+ * ```html
764
+ * <zur-empty-state title="Nenhuma reserva" description="Quando você reservar, ela aparece aqui.">
765
+ * <svg zurEmptyIcon …></svg>
766
+ * <button zur-button>Explorar</button>
767
+ * </zur-empty-state>
768
+ * ```
769
+ */
770
+ export declare class ZurEmptyState {
771
+ readonly title: import("@angular/core").InputSignal<string>;
772
+ readonly description: import("@angular/core").InputSignal<string>;
773
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurEmptyState, never>;
774
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurEmptyState, "zur-empty-state", never, {
775
+ "title": {
776
+ "alias": "title";
777
+ "required": true;
778
+ "isSignal": true;
779
+ };
780
+ "description": {
781
+ "alias": "description";
782
+ "required": false;
783
+ "isSignal": true;
784
+ };
785
+ }, {}, never, ["[zurEmptyIcon]", "*"], true, never>;
786
+ }
787
+ /**
788
+ * Passo numerado (círculo verde + título) com conteúdo projetado abaixo.
789
+ *
790
+ * ```html
791
+ * <zur-step number="1" title="Instale o pacote">
792
+ * <p>Conteúdo do passo…</p>
793
+ * </zur-step>
794
+ * ```
795
+ */
796
+ export declare class ZurStep {
797
+ readonly number: import("@angular/core").InputSignal<string | number>;
798
+ readonly title: import("@angular/core").InputSignal<string>;
799
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurStep, never>;
800
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurStep, "zur-step", never, {
801
+ "number": {
802
+ "alias": "number";
803
+ "required": true;
804
+ "isSignal": true;
805
+ };
806
+ "title": {
807
+ "alias": "title";
808
+ "required": true;
809
+ "isSignal": true;
810
+ };
811
+ }, {}, never, ["*"], true, never>;
812
+ }
813
+ export type ZurViewport = 'mobile' | 'tablet' | 'desktop';
814
+ /** Breakpoints do Zuri: mobile < 768 ≤ tablet < 1024 ≤ desktop. */
815
+ export declare const ZUR_BREAKPOINTS: {
816
+ readonly tablet: 768;
817
+ readonly desktop: 1024;
818
+ };
819
+ /**
820
+ * Estado compartilhado entre um layout e seus filhos (`zur-sidebar`, `zur-topbar`).
821
+ * É provido por cada layout com sidebar — não use diretamente.
822
+ *
823
+ * - desktop: sidebar fixa, recolhível pelo usuário;
824
+ * - tablet: começa recolhida (só ícones), expansível;
825
+ * - mobile: sidebar vira gaveta (`drawerOpen`).
826
+ */
827
+ export declare class ZurShellState {
828
+ private readonly doc;
829
+ readonly viewport: import("@angular/core").WritableSignal<ZurViewport>;
830
+ readonly collapsed: import("@angular/core").WritableSignal<boolean>;
831
+ readonly drawerOpen: import("@angular/core").WritableSignal<boolean>;
832
+ /** Preenchido pelo `zur-sidebar` ao existir — o topbar usa para mostrar o botão de menu. */
833
+ readonly hasSidebar: import("@angular/core").WritableSignal<boolean>;
834
+ constructor();
835
+ /** Mobile: abre/fecha a gaveta. Demais telas: recolhe/expande a sidebar. */
836
+ toggle(): void;
837
+ closeDrawer(): void;
838
+ private measure;
839
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurShellState, never>;
840
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
841
+ }
842
+ /**
843
+ * Largura do conteúdo dos layouts:
844
+ * - `fluid`: ocupa tudo (dashboards, lista-detalhe);
845
+ * - `wide`: ~1100px centralizado (landing);
846
+ * - `reading`: ~760px (documentação, formulários);
847
+ * - `narrow`: ~440px (autenticação, erro).
848
+ */
849
+ export type ZurLayoutWidth = 'fluid' | 'wide' | 'reading' | 'narrow';
850
+ /** Estilos compartilhados: mapeia `data-width` para `--zur-layout-max`. */
851
+ export declare const ZUR_LAYOUT_WIDTH_STYLES = "\n :host([data-width='fluid']) { --zur-layout-max: none; }\n :host([data-width='wide']) { --zur-layout-max: 1100px; }\n :host([data-width='reading']) { --zur-layout-max: 760px; }\n :host([data-width='narrow']) { --zur-layout-max: 440px; }\n";
852
+ /**
853
+ * Sidebar de layout: fixa no desktop, recolhível (só ícones) e gaveta no mobile.
854
+ * Deve ficar dentro de um layout que a suporte (`zur-dashboard-layout`,
855
+ * `zur-docs-layout`). O botão que a controla vive no `zur-topbar`.
856
+ *
857
+ * Slots: `[zurSidebarHeader]` (logo), conteúdo padrão (`zur-sidenav`),
858
+ * `[zurSidebarFooter]`.
859
+ */
860
+ export declare class ZurSidebar implements OnInit {
861
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
862
+ protected readonly shell: ZurShellState;
863
+ /** Recolhida só vale fora do mobile (a gaveta sempre abre completa). */
864
+ protected readonly collapsed: import("@angular/core").Signal<boolean>;
865
+ ngOnInit(): void;
866
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidebar, never>;
867
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidebar, "zur-sidebar", never, {}, {}, never, ["[zurSidebarHeader]", "*", "[zurSidebarFooter]"], true, never>;
868
+ }
869
+ /**
870
+ * Topbar de layout: fica fixa (sticky) no topo; com `hideOnScroll` (padrão)
871
+ * some ao rolar para baixo e volta ao rolar para cima. Dentro de um layout com
872
+ * sidebar, mostra o botão de menu (recolher no desktop, gaveta no mobile).
873
+ *
874
+ * Slots: `[zurTopbarStart]` (logo/título), `[zurTopbarLinks]`, `[zurTopbarActions]`.
875
+ */
876
+ export declare class ZurTopbar implements OnInit {
877
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
878
+ private readonly doc;
879
+ protected readonly shell: ZurShellState | null;
880
+ /** Esconde ao rolar para baixo e reaparece ao rolar para cima. */
881
+ readonly hideOnScroll: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
882
+ protected readonly hidden: import("@angular/core").WritableSignal<boolean>;
883
+ private lastY;
884
+ protected expanded(): boolean;
885
+ ngOnInit(): void;
886
+ protected onScroll(): void;
887
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTopbar, never>;
888
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurTopbar, "zur-topbar", never, {
889
+ "hideOnScroll": {
890
+ "alias": "hideOnScroll";
891
+ "required": false;
892
+ "isSignal": true;
893
+ };
894
+ }, {}, never, ["[zurTopbarStart]", "[zurTopbarLinks]", "[zurTopbarActions]"], true, never>;
895
+ }
896
+ /**
897
+ * Cabeçalho de página: breadcrumb opcional, título, descrição e ações.
898
+ *
899
+ * ```html
900
+ * <zur-page-header title="Reservas" description="Gerencie as reservas.">
901
+ * <zur-breadcrumb [items]="trilha" />
902
+ * <button zurPageHeaderActions zur-button>Nova reserva</button>
903
+ * </zur-page-header>
904
+ * ```
905
+ */
906
+ export declare class ZurPageHeader {
907
+ readonly title: import("@angular/core").InputSignal<string>;
908
+ readonly description: import("@angular/core").InputSignal<string>;
909
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurPageHeader, never>;
910
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurPageHeader, "zur-page-header", never, {
911
+ "title": {
912
+ "alias": "title";
913
+ "required": true;
914
+ "isSignal": true;
915
+ };
916
+ "description": {
917
+ "alias": "description";
918
+ "required": false;
919
+ "isSignal": true;
920
+ };
921
+ }, {}, never, ["zur-breadcrumb", "[zurPageHeaderActions]"], true, never>;
922
+ }
923
+ /** Rodapé simples: conteúdo à esquerda (ex.: copyright), `[zurFooterLinks]` à direita. */
924
+ export declare class ZurFooter {
925
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
926
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurFooter, never>;
927
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurFooter, "zur-footer", never, {}, {}, never, ["*", "[zurFooterLinks]"], true, never>;
928
+ }
929
+ /**
930
+ * Landing / página descritiva: topbar no topo, seções longas centralizadas
931
+ * (~1100px) e rodapé. Slots por elemento: `zur-topbar`, conteúdo, `zur-footer`.
932
+ *
933
+ * ```html
934
+ * <zur-landing-layout>
935
+ * <zur-topbar>…</zur-topbar>
936
+ * <section>…</section>
937
+ * <zur-footer>…</zur-footer>
938
+ * </zur-landing-layout>
939
+ * ```
940
+ */
941
+ export declare class ZurLandingLayout {
942
+ readonly width: import("@angular/core").InputSignal<ZurLayoutWidth>;
943
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurLandingLayout, never>;
944
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurLandingLayout, "zur-landing-layout", never, {
945
+ "width": {
946
+ "alias": "width";
947
+ "required": false;
948
+ "isSignal": true;
949
+ };
950
+ }, {}, never, ["zur-topbar", "*", "zur-footer"], true, never>;
951
+ }
952
+ /**
953
+ * Dashboard / admin: sidebar à esquerda (recolhível; gaveta no mobile), topbar
954
+ * sticky e área principal fluida. Slots: `zur-sidebar`, `zur-topbar`, conteúdo.
955
+ *
956
+ * ```html
957
+ * <zur-dashboard-layout>
958
+ * <zur-sidebar>…</zur-sidebar>
959
+ * <zur-topbar>…</zur-topbar>
960
+ * <zur-page-header title="Visão geral" />
961
+ * </zur-dashboard-layout>
962
+ * ```
963
+ */
964
+ export declare class ZurDashboardLayout {
965
+ readonly width: import("@angular/core").InputSignal<ZurLayoutWidth>;
966
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurDashboardLayout, never>;
967
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurDashboardLayout, "zur-dashboard-layout", never, {
968
+ "width": {
969
+ "alias": "width";
970
+ "required": false;
971
+ "isSignal": true;
972
+ };
973
+ }, {}, never, ["zur-sidebar", "zur-topbar", "*", "zur-footer"], true, never>;
974
+ }
975
+ /**
976
+ * Lista e detalhe (master-detail): lista à esquerda (360px) e detalhe à direita.
977
+ * No mobile mostra um painel por vez — `detailOpen` decide qual, e o botão
978
+ * "Voltar" fecha o detalhe.
979
+ *
980
+ * Slots: `zur-topbar`, `[zurList]` (lista), `[zurDetail]` (detalhe).
981
+ *
982
+ * ```html
983
+ * <zur-list-detail-layout [(detailOpen)]="aberto">
984
+ * <zur-topbar>…</zur-topbar>
985
+ * <ul zurList>…</ul>
986
+ * <article zurDetail>…</article>
987
+ * </zur-list-detail-layout>
988
+ * ```
989
+ */
990
+ export declare class ZurListDetailLayout {
991
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
992
+ /** Mobile: `true` mostra o detalhe; `false` mostra a lista. */
993
+ readonly detailOpen: import("@angular/core").ModelSignal<boolean>;
994
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurListDetailLayout, never>;
995
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurListDetailLayout, "zur-list-detail-layout", never, {
996
+ "detailOpen": {
997
+ "alias": "detailOpen";
998
+ "required": false;
999
+ "isSignal": true;
1000
+ };
1001
+ }, {
1002
+ "detailOpen": "detailOpenChange";
1003
+ }, never, ["zur-topbar", "[zurList]", "[zurDetail]"], true, never>;
1004
+ }
1005
+ /**
1006
+ * Formulário e wizard: coluna centralizada (~760px), indicador de etapas
1007
+ * opcional (`steps` + `current`) e barra de ações fixa no rodapé da tela.
1008
+ *
1009
+ * Slots: `zur-topbar`, conteúdo (campos), `[zurLayoutActions]` (botões).
1010
+ *
1011
+ * ```html
1012
+ * <zur-form-layout [steps]="['Dados', 'Pagamento', 'Revisão']" [current]="1">
1013
+ * <zur-page-header title="Nova reserva" />
1014
+ * <zur-input label="Nome" />
1015
+ * <div zurLayoutActions><button zur-button>Continuar</button></div>
1016
+ * </zur-form-layout>
1017
+ * ```
1018
+ */
1019
+ export declare class ZurFormLayout {
1020
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1021
+ readonly width: import("@angular/core").InputSignal<ZurLayoutWidth>;
1022
+ /** Rótulos das etapas do wizard; vazio = formulário simples. */
1023
+ readonly steps: import("@angular/core").InputSignal<string[]>;
1024
+ /** Índice (0-based) da etapa atual. */
1025
+ readonly current: import("@angular/core").InputSignal<number>;
1026
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurFormLayout, never>;
1027
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurFormLayout, "zur-form-layout", never, {
1028
+ "width": {
1029
+ "alias": "width";
1030
+ "required": false;
1031
+ "isSignal": true;
1032
+ };
1033
+ "steps": {
1034
+ "alias": "steps";
1035
+ "required": false;
1036
+ "isSignal": true;
1037
+ };
1038
+ "current": {
1039
+ "alias": "current";
1040
+ "required": false;
1041
+ "isSignal": true;
1042
+ };
1043
+ }, {}, never, ["zur-topbar", "*", "[zurLayoutActions]"], true, never>;
1044
+ }
1045
+ /**
1046
+ * Documentação: sidebar de navegação (recolhível; gaveta no mobile) e texto
1047
+ * centralizado em coluna de leitura (~760px). Slots: `zur-sidebar`,
1048
+ * `zur-topbar`, conteúdo, `zur-footer`.
1049
+ */
1050
+ export declare class ZurDocsLayout {
1051
+ readonly width: import("@angular/core").InputSignal<ZurLayoutWidth>;
1052
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurDocsLayout, never>;
1053
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurDocsLayout, "zur-docs-layout", never, {
1054
+ "width": {
1055
+ "alias": "width";
1056
+ "required": false;
1057
+ "isSignal": true;
1058
+ };
1059
+ }, {}, never, ["zur-sidebar", "zur-topbar", "*", "zur-footer"], true, never>;
1060
+ }
1061
+ /**
1062
+ * Autenticação: card centralizado (~440px) sobre o fundo da página.
1063
+ * Slots: `[zurAuthBrand]` (logo acima), conteúdo (formulário no card),
1064
+ * `[zurAuthFooter]` (links abaixo).
1065
+ */
1066
+ export declare class ZurAuthLayout {
1067
+ readonly width: import("@angular/core").InputSignal<ZurLayoutWidth>;
1068
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurAuthLayout, never>;
1069
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurAuthLayout, "zur-auth-layout", never, {
1070
+ "width": {
1071
+ "alias": "width";
1072
+ "required": false;
1073
+ "isSignal": true;
1074
+ };
1075
+ }, {}, never, ["[zurAuthBrand]", "*", "[zurAuthFooter]"], true, never>;
1076
+ }
1077
+ /**
1078
+ * Erro e 404: código grande, título, descrição e ações. Conteúdo padrão
1079
+ * (botões/links de saída) aparece abaixo da descrição.
1080
+ *
1081
+ * ```html
1082
+ * <zur-error-layout code="404" title="Página não encontrada" description="…">
1083
+ * <a zur-button variant="primary" routerLink="/">Voltar ao início</a>
1084
+ * </zur-error-layout>
1085
+ * ```
1086
+ */
1087
+ export declare class ZurErrorLayout {
1088
+ readonly width: import("@angular/core").InputSignal<ZurLayoutWidth>;
1089
+ /** Código do erro exibido em destaque (ex.: "404"). */
1090
+ readonly code: import("@angular/core").InputSignal<string>;
1091
+ readonly title: import("@angular/core").InputSignal<string>;
1092
+ readonly description: import("@angular/core").InputSignal<string>;
1093
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurErrorLayout, never>;
1094
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurErrorLayout, "zur-error-layout", never, {
1095
+ "width": {
1096
+ "alias": "width";
1097
+ "required": false;
1098
+ "isSignal": true;
1099
+ };
1100
+ "code": {
1101
+ "alias": "code";
1102
+ "required": false;
1103
+ "isSignal": true;
1104
+ };
1105
+ "title": {
1106
+ "alias": "title";
1107
+ "required": true;
1108
+ "isSignal": true;
1109
+ };
1110
+ "description": {
1111
+ "alias": "description";
1112
+ "required": false;
1113
+ "isSignal": true;
1114
+ };
1115
+ }, {}, never, ["*"], true, never>;
1116
+ }
1117
+ /**
1118
+ * Modal — superfície 20px com padding 32px sobre scrim 50%.
1119
+ * Fecha por ESC, clique no scrim ou no botão ×.
1120
+ *
1121
+ * ```html
1122
+ * <zur-modal [(open)]="aberto" title="Confirmar reserva">…</zur-modal>
1123
+ * ```
1124
+ */
1125
+ export declare class ZurModal {
1126
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1127
+ readonly open: import("@angular/core").ModelSignal<boolean>;
1128
+ readonly title: import("@angular/core").InputSignal<string>;
1129
+ close(): void;
1130
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurModal, never>;
1131
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurModal, "zur-modal", never, {
1132
+ "open": {
1133
+ "alias": "open";
1134
+ "required": false;
1135
+ "isSignal": true;
1136
+ };
1137
+ "title": {
1138
+ "alias": "title";
1139
+ "required": false;
1140
+ "isSignal": true;
1141
+ };
1142
+ }, {
1143
+ "open": "openChange";
1144
+ }, never, ["*", "[zurModalActions]"], true, never>;
1145
+ }
1146
+ export type ZurToastKind = 'neutral' | 'success' | 'error';
1147
+ export interface ZurToast {
1148
+ id: number;
1149
+ message: string;
1150
+ kind: ZurToastKind;
1151
+ }
1152
+ /** Fila de toasts — use junto com <zur-toast-container>. */
1153
+ export declare class ZurToastService {
1154
+ readonly toasts: import("@angular/core").WritableSignal<ZurToast[]>;
1155
+ show(message: string, kind?: ZurToastKind, durationMs?: number): void;
1156
+ dismiss(id: number): void;
1157
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurToastService, never>;
1158
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
1159
+ }
1160
+ /**
1161
+ * Container fixo (inferior central) que renderiza os toasts do
1162
+ * ZurToastService. Coloque uma única instância no shell da aplicação.
1163
+ */
1164
+ export declare class ZurToastContainer {
1165
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1166
+ protected readonly service: ZurToastService;
1167
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurToastContainer, never>;
1168
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurToastContainer, "zur-toast-container", never, {}, {}, never, never, true, never>;
1169
+ }
1170
+ /**
1171
+ * Tooltip — bolha ink 8px com caption invertida, posicionada acima
1172
+ * do elemento no hover/focus.
1173
+ *
1174
+ * ```html
1175
+ * <button zur-button zurTooltip="Salvar nos favoritos">♥</button>
1176
+ * ```
1177
+ */
1178
+ export declare class ZurTooltip implements OnDestroy {
1179
+ readonly zurTooltip: import("@angular/core").InputSignal<string>;
1180
+ private readonly host;
1181
+ private readonly doc;
1182
+ private bubble;
1183
+ protected show(): void;
1184
+ protected hide(): void;
1185
+ ngOnDestroy(): void;
1186
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurTooltip, never>;
1187
+ static ɵdir: i0.ɵɵDirectiveDeclaration<ZurTooltip, "[zurTooltip]", never, {
1188
+ "zurTooltip": {
1189
+ "alias": "zurTooltip";
1190
+ "required": true;
1191
+ "isSignal": true;
1192
+ };
1193
+ }, {}, never, never, true, never>;
1194
+ }
1195
+ export type ZurAlertKind = 'success' | 'warning' | 'error' | 'info';
1196
+ /** Alert em banda soft da cor semântica, com ícone e raio 14px. */
1197
+ export declare class ZurAlert {
1198
+ readonly kind: import("@angular/core").InputSignal<ZurAlertKind>;
1199
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurAlert, never>;
1200
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurAlert, "zur-alert", never, {
1201
+ "kind": {
1202
+ "alias": "kind";
1203
+ "required": false;
1204
+ "isSignal": true;
1205
+ };
1206
+ }, {}, never, ["*"], true, never>;
1207
+ }
1208
+ export type ZurSpinnerSize = 'sm' | 'md' | 'lg';
1209
+ /** Anel giratório em menta — 20/32/48px. */
1210
+ export declare class ZurSpinner {
1211
+ readonly size: import("@angular/core").InputSignal<ZurSpinnerSize>;
1212
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSpinner, never>;
1213
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSpinner, "zur-spinner", never, {
1214
+ "size": {
1215
+ "alias": "size";
1216
+ "required": false;
1217
+ "isSignal": true;
1218
+ };
1219
+ }, {}, never, never, true, never>;
1220
+ }
1221
+ /** Placeholder pulsante em surface-strong. */
1222
+ export declare class ZurSkeleton {
1223
+ readonly width: import("@angular/core").InputSignal<string>;
1224
+ readonly height: import("@angular/core").InputSignal<string>;
1225
+ readonly circle: import("@angular/core").InputSignal<boolean>;
1226
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurSkeleton, never>;
1227
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurSkeleton, "zur-skeleton", never, {
1228
+ "width": {
1229
+ "alias": "width";
1230
+ "required": false;
1231
+ "isSignal": true;
1232
+ };
1233
+ "height": {
1234
+ "alias": "height";
1235
+ "required": false;
1236
+ "isSignal": true;
1237
+ };
1238
+ "circle": {
1239
+ "alias": "circle";
1240
+ "required": false;
1241
+ "isSignal": true;
1242
+ };
1243
+ }, {}, never, never, true, never>;
1244
+ }
1245
+ export type ZurProgressSize = 'sm' | 'md';
1246
+ /**
1247
+ * Barra de progresso linear. Com `value` (0 a `max`) é determinada; sem `value`
1248
+ * (ou `null`), fica indeterminada, com animação contínua.
1249
+ *
1250
+ * ```html
1251
+ * <zur-progress [value]="60" label="Enviando arquivo" />
1252
+ * <zur-progress /> <!-- indeterminada -->
1253
+ * ```
1254
+ */
1255
+ export declare class ZurProgress {
1256
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1257
+ /** Valor atual (0 a `max`). `null` = indeterminada. */
1258
+ readonly value: import("@angular/core").InputSignal<number | null>;
1259
+ readonly max: import("@angular/core").InputSignal<number>;
1260
+ readonly size: import("@angular/core").InputSignal<ZurProgressSize>;
1261
+ /** Rótulo para leitores de tela. Padrão: "Progresso". */
1262
+ readonly label: import("@angular/core").InputSignal<string>;
1263
+ protected readonly indeterminate: import("@angular/core").Signal<boolean>;
1264
+ protected readonly clamped: import("@angular/core").Signal<number>;
1265
+ protected readonly percent: import("@angular/core").Signal<number>;
1266
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurProgress, never>;
1267
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurProgress, "zur-progress", never, {
1268
+ "value": {
1269
+ "alias": "value";
1270
+ "required": false;
1271
+ "isSignal": true;
1272
+ };
1273
+ "max": {
1274
+ "alias": "max";
1275
+ "required": false;
1276
+ "isSignal": true;
1277
+ };
1278
+ "size": {
1279
+ "alias": "size";
1280
+ "required": false;
1281
+ "isSignal": true;
1282
+ };
1283
+ "label": {
1284
+ "alias": "label";
1285
+ "required": false;
1286
+ "isSignal": true;
1287
+ };
1288
+ }, {}, never, never, true, never>;
1289
+ }
1290
+ export type ZurDrawerSide = 'left' | 'right';
1291
+ /**
1292
+ * Painel lateral deslizante (gaveta) sobre a página, para filtros, detalhes ou
1293
+ * formulários curtos. Fecha com ESC, clique no fundo ou no botão de fechar; o foco
1294
+ * fica preso dentro dele enquanto aberto e volta para quem o abriu ao fechar.
1295
+ *
1296
+ * ```html
1297
+ * <button zur-button (click)="filtros = true">Filtros</button>
1298
+ * <zur-drawer [(open)]="filtros" title="Filtros">…</zur-drawer>
1299
+ * ```
1300
+ */
1301
+ export declare class ZurDrawer {
1302
+ protected readonly i18n: import("@juau/zuri").ZurI18n;
1303
+ private readonly doc;
1304
+ readonly open: import("@angular/core").ModelSignal<boolean>;
1305
+ readonly title: import("@angular/core").InputSignal<string>;
1306
+ readonly side: import("@angular/core").InputSignal<ZurDrawerSide>;
1307
+ private readonly panel;
1308
+ private returnFocusTo;
1309
+ constructor();
1310
+ close(): void;
1311
+ /** Mantém o Tab circulando dentro do painel. */
1312
+ protected trapFocus(event: KeyboardEvent): void;
1313
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurDrawer, never>;
1314
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurDrawer, "zur-drawer", never, {
1315
+ "open": {
1316
+ "alias": "open";
1317
+ "required": false;
1318
+ "isSignal": true;
1319
+ };
1320
+ "title": {
1321
+ "alias": "title";
1322
+ "required": false;
1323
+ "isSignal": true;
1324
+ };
1325
+ "side": {
1326
+ "alias": "side";
1327
+ "required": false;
1328
+ "isSignal": true;
1329
+ };
1330
+ }, {
1331
+ "open": "openChange";
1332
+ }, never, ["*", "[zurDrawerActions]"], true, never>;
1333
+ }
1334
+ export type ZurPopoverPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
1335
+ /**
1336
+ * Conteúdo flutuante ancorado a um gatilho (filtros, detalhes, ações). Abre no
1337
+ * clique do elemento marcado com `zurPopoverTrigger`, fecha com ESC ou clique fora,
1338
+ * e devolve o foco ao gatilho.
1339
+ *
1340
+ * ```html
1341
+ * <zur-popover label="Filtros">
1342
+ * <button zur-button variant="secondary" zurPopoverTrigger>Filtros</button>
1343
+ * …conteúdo…
1344
+ * </zur-popover>
1345
+ * ```
1346
+ */
1347
+ export declare class ZurPopover {
1348
+ private readonly host;
1349
+ private readonly doc;
1350
+ readonly open: import("@angular/core").ModelSignal<boolean>;
1351
+ readonly placement: import("@angular/core").InputSignal<ZurPopoverPlacement>;
1352
+ /** Nome do painel para leitores de tela. */
1353
+ readonly label: import("@angular/core").InputSignal<string>;
1354
+ readonly panelId: string;
1355
+ private readonly panel;
1356
+ /** Preenchido pela diretiva do gatilho. */
1357
+ trigger: HTMLElement | null;
1358
+ constructor();
1359
+ toggle(): void;
1360
+ /** Fecha; com `returnFocus`, devolve o foco ao gatilho (ex.: ao apertar ESC). */
1361
+ close(returnFocus?: boolean): void;
1362
+ protected onDocumentClick(event: MouseEvent): void;
1363
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurPopover, never>;
1364
+ static ɵcmp: i0.ɵɵComponentDeclaration<ZurPopover, "zur-popover", never, {
1365
+ "open": {
1366
+ "alias": "open";
1367
+ "required": false;
1368
+ "isSignal": true;
1369
+ };
1370
+ "placement": {
1371
+ "alias": "placement";
1372
+ "required": false;
1373
+ "isSignal": true;
1374
+ };
1375
+ "label": {
1376
+ "alias": "label";
1377
+ "required": false;
1378
+ "isSignal": true;
1379
+ };
1380
+ }, {
1381
+ "open": "openChange";
1382
+ }, never, ["[zurPopoverTrigger]", "*"], true, never>;
1383
+ }
1384
+ /** Marca o elemento que abre o `zur-popover` e liga os atributos ARIA a ele. */
1385
+ export declare class ZurPopoverTrigger {
1386
+ protected readonly popover: any;
1387
+ constructor();
1388
+ static ɵfac: i0.ɵɵFactoryDeclaration<ZurPopoverTrigger, never>;
1389
+ static ɵdir: i0.ɵɵDirectiveDeclaration<ZurPopoverTrigger, "[zurPopoverTrigger]", never, {}, {}, never, never, true, never>;
1390
+ }
1391
+ export {};