@12-apps/ui 5.0.0 → 5.0.1

package/dist/types/components/data-display/DataViews/data-views-layout-context.d.ts

@@ -0,0 +1,137 @@
+import { type ReactNode } from "react";
+import { type DataViewsLayout } from "./data-views-types";
+/**
+ * The DataViews layout (view type): the dense "Tabela" grid, the "Grade" of
+ * cards, the "Lista" of full-width rows, or the "Quadro" board of state columns.
+ * Shared across the toolbar (the toggle) and the body (the selector) via context
+ * so a single source of truth drives what renders — each layout only appears
+ * when the table opts into it (`renderCard` for the grade, `renderListRow` for
+ * the lista, `board` + `renderCard` for the quadro).
+ */
+export type { DataViewsLayout };
+interface DataViewsLayoutValue {
+    layout: DataViewsLayout;
+    setLayout: (layout: DataViewsLayout) => void;
+    /** How much air each record gets — see {@link DataViewsDensity}. */
+    density: DataViewsDensity;
+    setDensity: (density: DataViewsDensity) => void;
+    /** Whether the cards layout is available (a `renderCard` was supplied). */
+    canUseCards: boolean;
+    /** Whether the list layout is available (a `renderListRow` was supplied). */
+    canUseList: boolean;
+    /** Whether the board layout is available (a `board` config AND a `renderCard`). */
+    canUseBoard: boolean;
+    /** Card-size zoom (0–100); drives the card grid's min column width. */
+    zoom: number;
+    setZoom: (zoom: number) => void;
+}
+/**
+ * How much room each record gets. It means different things per layout, and
+ * that is the point — one control, phrased in the terms of what is on screen:
+ *
+ * - table / list → row height ("Baixa / Média / Alta")
+ * - cards        → how many fit per row ("Muitos / Médio / Poucos")
+ *
+ * The board is unaffected: its cards are already sized by the zoom slider.
+ */
+export type DataViewsDensity = "compact" | "cozy" | "comfortable";
+/** Vertical padding (theme spacing units) per density, for a table or list row. */
+export declare const DENSITY_ROW_PADDING: Record<DataViewsDensity, number>;
+/**
+ * The card WIDTH each density aims for, as a multiple of the base card width.
+ *
+ * Density used to cap the column COUNT, with a track floor of
+ * `max(baseWidth, 100% / count)`. That base is a constant, so wherever it won
+ * the arithmetic every density produced an identical track — "Muitos" and
+ * "Medio" both drew 3 cards of 279px at md — and where the percentage won
+ * instead, on a wide screen, the count was pinned and each card grew to a share
+ * of the viewport: ~430px of card holding one chip and two lines of text.
+ *
+ * One width per density fixes both, because the number `auto-fill` divides by
+ * now differs per density at every size. The spread is chosen so the three land
+ * on DIFFERENT column counts across the range rather than by eye — 4/3/2 at md,
+ * 6/4/3 at lg, 7/5/4 at xl, 13/9/8 at 2560.
+ */
+export declare const DENSITY_CARD_SCALE: Record<DataViewsDensity, number>;
+/** The width a card aims for: the base width, scaled by zoom, then by density. */
+export declare function cardTargetWidthFor(zoom: number, density: DataViewsDensity): number;
+/**
+ * The BOARD's column-width multiplier per density.
+ *
+ * Density means "how much air a record gets", and on a board that is the column
+ * width — narrow columns fit more etapas on screen, wide ones give each card
+ * room to be read. Without this the board was the one layout the Exibição tab
+ * offered nothing for: the format tile switched to Quadro and the whole density
+ * section vanished, which reads as a control that broke rather than one that
+ * does not apply.
+ *
+ * The spread is deliberately narrower than the card grid's. A board column has
+ * a hard floor (`MIN_COLUMN_WIDTH` — a card below it stops being readable), so
+ * a multiplier that undershoots it buys nothing and makes "Estreita" a tile
+ * that does nothing on a phone.
+ */
+export declare const DENSITY_BOARD_SCALE: Record<DataViewsDensity, number>;
+/**
+ * Map the 0–100 zoom to the card SIZE multiplier. This is the single knob: the
+ * card's width is {@link BASE_CARD_WIDTH} × scale and its padding + typography
+ * scale by the same factor, so the whole card grows together (scale 2 → twice
+ * the size, proportion preserved by the aspect ratio). Passed to a card via
+ * `DataViewCardSelection.scale`.
+ */
+export declare function cardScaleForZoom(zoom: number): number;
+/** The card grid's min column width in px = base width × the zoom size multiplier. */
+export declare function cardMinWidthForZoom(zoom: number): number;
+/** Which layouts this table can actually render. */
+interface LayoutAvailability {
+    canUseCards: boolean;
+    canUseList: boolean;
+    canUseBoard: boolean;
+}
+interface LayoutProviderProps extends Partial<LayoutAvailability> {
+    /** Which layout to show first when the user has expressed no preference. */
+    defaultLayout?: DataViewsLayout;
+    /**
+     * The layout an APPLIED SAVED VIEW pins, when it stored one. It wins over the
+     * remembered preference for as long as that view is applied — the view is a
+     * snapshot someone chose to keep — but it does NOT overwrite the preference:
+     * only the toggle does that, because only the toggle is the user saying so.
+     */
+    viewLayout?: DataViewsLayout;
+    /**
+     * Ignore — and stop writing — the remembered cross-screen preference, making
+     * `defaultLayout` authoritative for this table.
+     *
+     * For a table that exists to SHOW a particular layout rather than to be
+     * browsed: a Storybook story called "Board", a docs example, a screenshot
+     * harness. Without it the remembered preference wins, so opening "Board"
+     * after having clicked Tabela anywhere renders a table — the demonstration
+     * silently showing the wrong thing, and a shared link doing it for everyone
+     * whose preference differs.
+     *
+     * A real screen leaves this off: remembering how someone likes to read
+     * lists is the point.
+     */
+    ignoreStoredLayout?: boolean;
+    children: ReactNode;
+}
+/**
+ * Provides the view-type state, seeded from (in order) the applied saved view's
+ * layout, the user's remembered cross-screen preference, then `defaultLayout` —
+ * each pinned to what this table can actually render.
+ */
+export declare function DataViewsLayoutProvider({ canUseCards, canUseList, canUseBoard, defaultLayout, viewLayout, ignoreStoredLayout, children, }: LayoutProviderProps): React.JSX.Element;
+/** Read the current DataViews layout. Throws outside a provider. */
+export declare function useDataViewsLayout(): DataViewsLayoutValue;
+/**
+ * Card-size slider for the toolbar — shown in the CARD-BASED layouts ("Grade"
+ * and "Quadro"), mirroring the tabwoah view-selector's zoom. The board reuses
+ * the same `renderCard`, so the same knob scales both.
+ *
+ * Deliberately ABSENT in "Lista" and "Tabela" (FUT-733): a list row is
+ * full-width and sized by its content, so a card-size multiplier has nothing to
+ * act on — a slider that moved and changed nothing would be worse than none.
+ */
+export declare function DataViewsZoomSlider({ testIdPrefix }: {
+    testIdPrefix: string;
+}): React.JSX.Element | null;
+//# sourceMappingURL=data-views-layout-context.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-layout-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-layout-context.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-layout-context.tsx"],"names":[],"mappings":"AAEA,OAAO,EAA2D,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAOhG,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE9E;;;;;;;GAOG;AACH,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC,UAAU,oBAAoB;IAC5B,MAAM,EAAE,eAAe,CAAC;IACxB,SAAS,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;IAC7C,oEAAoE;IACpE,OAAO,EAAE,gBAAgB,CAAC;IAC1B,UAAU,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAChD,2EAA2E;IAC3E,WAAW,EAAE,OAAO,CAAC;IACrB,6EAA6E;IAC7E,UAAU,EAAE,OAAO,CAAC;IACpB,mFAAmF;IACnF,WAAW,EAAE,OAAO,CAAC;IACrB,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AA0BD;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,MAAM,GAAG,aAAa,CAAC;AAKlE,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAIhE,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAI/D,CAAC;AAEF,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAElF;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAIhE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,oDAAoD;AACpD,UAAU,kBAAkB;IAC1B,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;CACtB;AA6DD,UAAU,mBAAoB,SAAQ,OAAO,CAAC,kBAAkB,CAAC;IAC/D,4EAA4E;IAC5E,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,WAAmB,EACnB,UAAkB,EAClB,WAAmB,EACnB,aAAuB,EACvB,UAAU,EACV,kBAA0B,EAC1B,QAAQ,GACT,EAAE,mBAAmB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAgDzC;AAED,oEAAoE;AACpE,wBAAgB,kBAAkB,IAAI,oBAAoB,CAMzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,YAAY,EAAE,EAAE;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CA6BxG"}

package/dist/types/components/data-display/DataViews/data-views-more-fields.d.ts

@@ -0,0 +1,37 @@
+import type { OverflowField } from "./data-views-overflow";
+import type { RangeValue } from "./data-views-types";
+/** What each field's control needs, minus the panel's own chrome. */
+export interface MoreFieldProps {
+    pills: Record<string, string[]>;
+    ranges: Record<string, RangeValue>;
+    onTogglePill: (fieldId: string, value: string, checked: boolean) => void;
+    onChangeRange: (fieldId: string, range: RangeValue) => void;
+    testIdPrefix: string;
+}
+/**
+ * The trigger, badged with how many fields had no room on the bar — and told
+ * apart when some of them are APPLIED.
+ *
+ * An applied filter can land in here now (it is ranked first, not exempt), so
+ * this button is the only thing on screen still saying it exists. A neutral
+ * badge reading "3" would make "three filters you have not used" and "three
+ * filters narrowing this list" look identical, which is the whole failure the
+ * old exemption was written to avoid. So an overflow holding applied filters
+ * takes the applied tone and counts them in its own badge.
+
+/**
+ * Whether a field has anything applied, and how to unapply it — the two shapes
+ * (a pill's selected values, a range's bounds) answered in one place so the
+ * group that renders them stays a renderer.
+ */
+export declare function fieldClearing<T extends Record<string, unknown>>({ field, pills, ranges, onTogglePill, onChangeRange, }: {
+    field: OverflowField<T>;
+} & Pick<MoreFieldProps, "pills" | "ranges" | "onTogglePill" | "onChangeRange">): {
+    applied: boolean;
+    clear: () => void;
+};
+/** One labelled group in the panel: the field's name, then its control. */
+export declare function MoreGroup<T extends Record<string, unknown>>({ field, pills, ranges, onTogglePill, onChangeRange, testIdPrefix, }: {
+    field: OverflowField<T>;
+} & MoreFieldProps): React.JSX.Element;
+//# sourceMappingURL=data-views-more-fields.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-more-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-more-fields.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-more-fields.tsx"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAG3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,qEAAqE;AACrE,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACzE,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5D,YAAY,EAAE,MAAM,CAAC;CACtB;AAgID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC/D,KAAK,EACL,KAAK,EACL,MAAM,EACN,YAAY,EACZ,aAAa,GACd,EAAE;IACD,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CACzB,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,eAAe,CAAC,GAAG;IAChF,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAYA;AAGD,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC3D,KAAK,EACL,KAAK,EACL,MAAM,EACN,YAAY,EACZ,aAAa,EACb,YAAY,GACb,EAAE;IACD,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CACzB,GAAG,cAAc,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAuDrC"}

package/dist/types/components/data-display/DataViews/data-views-more-filters.d.ts

@@ -0,0 +1,36 @@
+import { type MoreFieldProps } from "./data-views-more-fields";
+import type { OverflowField } from "./data-views-overflow";
+/**
+ * "MAIS" — the filter overflow: its trigger, its panel and its footer. What
+ * goes INSIDE it is `data-views-more-fields`.
+ *
+ * It holds the fields that had no room on the toolbar. An applied filter is
+ * ranked ahead of an idle one for the visible slots but is NOT exempt (see
+ * `useFilterOverflow`), so an applied filter can be in here — on a phone, most
+ * of them are. That is why the trigger changes tone and counts the applied
+ * ones: a filter you cannot see is a filter you forget you set, and the badge
+ * is what stops that.
+ */
+interface MoreFiltersProps<T extends Record<string, unknown>> extends MoreFieldProps {
+    fields: OverflowField<T>[];
+}
+/** The overflow trigger + panel. Renders nothing when everything fits. */
+export declare function MoreFilters<T extends Record<string, unknown>>({ fields, onOpenChange, onClearAll, anyApplied, compact, ...rest }: MoreFiltersProps<T> & {
+    /** Icon only — the same rung that strips Exibir/Exportar. */
+    compact?: boolean;
+    /** Clears every filter, not just the ones in here. */
+    onClearAll: () => void;
+    /** Whether anything is applied anywhere — the footer is pointless otherwise. */
+    anyApplied: boolean;
+    /**
+     * So the shell can FREEZE the measured split while this panel is open.
+     *
+     * Applying a filter in here makes its field active, and an active field
+     * takes an inline slot first — so the field being edited was promoted OUT of
+     * this panel mid-keystroke, taking the focused input with it. Typing "12"
+     * got as far as "1" and then had nowhere to go.
+     */
+    onOpenChange?: (open: boolean) => void;
+}): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=data-views-more-filters.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-more-filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-more-filters.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-more-filters.tsx"],"names":[],"mappings":"AAgBA,OAAO,EAA4B,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;;;;;;;;GAUG;AAEH,UAAU,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAE,SAAQ,cAAc;IAClF,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;CAC5B;AAiJD,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC7D,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,OAAe,EACf,GAAG,IAAI,EACR,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG;IACvB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sDAAsD;IACtD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,gFAAgF;IAChF,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACxC,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAsD3B"}

package/dist/types/components/data-display/DataViews/data-views-number-input.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+/**
+ * pt-BR text → number, or `undefined` when it is not one (yet).
+ *
+ * `.` is a thousands group and `,` is the decimal point, EXCEPT when a lone dot
+ * is followed by one or two digits and no comma is present — `50.00` and `1.5`
+ * are decimals somebody typed, while `1.234` is a thousand.
+ */
+export declare function parsePtBrNumber(text: string): number | undefined;
+/**
+ * A stored bound → the text the merchant reads, with a comma for the decimal
+ * point.
+ *
+ * It takes a STRING too, and that is not defensive typing: a range restored
+ * from the URL arrives as one (`?totalCents_gte=5000`). Narrowing to `number`
+ * and dropping the rest emptied the field on every reload — and then the next
+ * keystroke wrote a bound built from nothing.
+ */
+export declare function formatPtBrNumber(amount: number | string | undefined): string;
+/**
+ * One end of a numeric range. The BOUND stays a plain `number` — nothing
+ * downstream learns that the typing surface changed.
+ */
+export declare function NumberBoundInput({ label, value, unit, onChange, testId, }: {
+    label: string;
+    /** The applied bound. A range restored from the URL hands this over as a string. */
+    value: number | string | undefined;
+    /** Rendered as a start adornment ("R$"), not parsed out of the text. */
+    unit?: string;
+    onChange: (bound: number | undefined) => void;
+    testId: string;
+}): React.JSX.Element;
+//# sourceMappingURL=data-views-number-input.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-number-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-number-input.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-number-input.tsx"],"names":[],"mappings":"AAsCA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAKnD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAahE;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAG5E;AASD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,MAAM,GACP,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,oFAAoF;IACpF,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACnC,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;IAC9C,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CA8DpB"}

package/dist/types/components/data-display/DataViews/data-views-overflow-costs.d.ts

@@ -0,0 +1,127 @@
+/**
+ * WHAT EACH THING ON THE TOOLBAR COSTS, IN PIXELS.
+ *
+ * The pricing half of the collapse ladder, split from `data-views-overflow` at
+ * the file-size gate. Pure arithmetic and constants: no React, no measurement,
+ * no decisions. `data-views-overflow` measures the row and spends what this
+ * says it has.
+ *
+ * Every number here is either MEASURED in a browser (and says so) or
+ * deliberately generous. Over-pricing sheds one control too early, which the
+ * "Mais" button absorbs invisibly; under-pricing breaks the line.
+ */
+import type { OverflowField } from "./data-views-overflow";
+import type { RangeValue } from "./data-views-types";
+/**
+ * Rough rendered width of a control, in px.
+ *
+ * An ESTIMATE from the label text rather than a real measurement, deliberately:
+ * measuring the true width needs every control mounted first, and mounting them
+ * to decide whether to mount them is the layout thrash this hook exists to
+ * avoid. The estimate only has to rank controls and find the cut point — being
+ * a few px out moves the cut by at most one control, and the overflow catches it.
+ */
+export declare function estimateWidth(text: string, extra: number): number;
+/** Is a range bounded at either end? */
+export declare function isRangeSet(range: RangeValue | undefined): boolean;
+/** The label a pill actually renders, which is what decides its width. */
+export declare function pillText<T extends Record<string, unknown>>(field: OverflowField<T>, values: string[]): string;
+/** Fixed toolbar furniture the filters have to fit around, in px. */
+export declare const RESERVED: {
+    /** The search box never shrinks below this. */
+    readonly search: 200;
+    /**
+     * The "N de N" counter.
+     *
+     * MEASURED at 35px, plus its divider and gap. The old 96 was priced for a
+     * counter reading "1.234 de 5.678"; a phone shows "3 de 3", and charging
+     * nearly triple its rendered width came straight out of the filter budget.
+     */
+    readonly counter: 56;
+    /**
+     * ONE right-hand control (Exibir, or Exportar) WITH its text label.
+     *
+     * Priced per control rather than for the pair, because the pair is not what
+     * every page renders: "Exportar" exists only when the host passes an
+     * `exportConfig`, and several pages (Pedidos among them) put their export in
+     * the PAGE HEADER instead. Charging 216 there billed the filters for a button
+     * that was never on the bar — ~108px of budget spent on nothing, which on a
+     * phone is the difference between one filter pill and none.
+     */
+    readonly displayControl: 108;
+    /**
+     * The same control as an icon only — step 2 of the ladder.
+     *
+     * MEASURED at 133px for the PAIR (66 each: a Button's minimum tap target is
+     * a good deal wider than the 20px glyph inside it); 70 keeps that total's
+     * slack at one control's granularity.
+     */
+    readonly displayControlCompact: 70;
+    /**
+     * What step 4 leaves behind: the search as a bare magnifier.
+     *
+     * MEASURED at 30px on the Pedidos bar (`…-search-all-collapsed`); 38 keeps a
+     * tap target's worth of slack over it.
+     */
+    readonly searchIcon: 38;
+    /**
+     * The narrowest keyword box still worth typing into — below it the operator
+     * cannot read back what they wrote, and the box takes over the cluster
+     * instead of sharing it (see `searchTakeover`).
+     *
+     * 120 rather than 140 because this is compared against the ESTIMATE, which
+     * over-prices on purpose (see `estimateWidth`). At 140 a large phone took the
+     * whole cluster to produce a box barely wider than the one it could have had
+     * while keeping its filters — paying for nothing.
+     */
+    readonly usableSearch: 120;
+    /**
+     * The "Mais" button, only charged when there IS an overflow — and priced by
+     * the state it is actually in, like the right-hand cluster beside it.
+     *
+     * MEASURED: 128px with its label, badge and chevron; 69px once the ladder has
+     * it down to icon + badge. One number for both was wrong in BOTH directions —
+     * it under-priced the wide bar (the row's own failure mode) and over-priced
+     * the narrow one by a whole pill.
+     */
+    readonly overflowButton: 136;
+    readonly overflowButtonCompact: 80;
+    /**
+     * "Limpar", only charged when there IS something to clear.
+     *
+     * It appears exactly when the row is at its widest — every applied filter
+     * has a longer label than the idle one it replaced — so leaving it unpriced
+     * would break the line at the one moment the operator most needs it.
+     * Measured at 64 as an icon; 72 with slack.
+     */
+    readonly clearAll: 72;
+    /**
+     * The row's own padding, plus the gaps BETWEEN the fixed furniture.
+     *
+     * Not the per-control gaps — `splitFilters` already adds a `GAP` for every
+     * filter it keeps, so counting a fourth one here charged one gap twice.
+     * MEASURED: 32px of padding (16 each side) + three 8px gaps between the
+     * search, the counter and the right cluster.
+     */
+    readonly chrome: 56;
+};
+/** The gap between two controls. */
+export declare const GAP = 8;
+/** What the right-hand cluster costs, given what the host actually renders. */
+export declare function rightClusterCost(hasExport: boolean, compact: boolean): number;
+/**
+ * What the toolbar furniture costs at a given rung of the ladder — the budget
+ * the filter controls have to fit AROUND.
+ *
+ * This exists because the two halves used to disagree. `splitFilters` priced
+ * the furniture at its widest (search 200 + counter 96 + right 216) and shed
+ * every filter to make room; the ladder then collapsed those very controls to
+ * 44 + 0 + 140 and nobody handed the ~330px back. On a 428px phone that showed
+ * as a bar carrying a magnifier, a "Mais 5" pill, and a band of nothing.
+ */
+export declare function furnitureCost(flags: {
+    searchCollapsed: boolean;
+    counterHidden: boolean;
+    compactControls: boolean;
+}, hasExport: boolean): number;
+//# sourceMappingURL=data-views-overflow-costs.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-overflow-costs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-overflow-costs.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-overflow-costs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAoBjE;AAED,wCAAwC;AACxC,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAEjE;AAED,0EAA0E;AAC1E,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAO7G;AAED,qEAAqE;AACrE,eAAO,MAAM,QAAQ;IACnB,+CAA+C;;IAE/C;;;;;;OAMG;;IAEH;;;;;;;;;OASG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;;;;;;;;OASG;;IAEH;;;;;;;;OAQG;;;IAGH;;;;;;;OAOG;;IAEH;;;;;;;OAOG;;CAEK,CAAC;AAEX,oCAAoC;AACpC,eAAO,MAAM,GAAG,IAAI,CAAC;AAErB,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAG7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE;IAAE,eAAe,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,EACrF,SAAS,EAAE,OAAO,GACjB,MAAM,CAOR"}

package/dist/types/components/data-display/DataViews/data-views-overflow.d.ts

@@ -0,0 +1,108 @@
+import type { FilterFieldConfig, RangeFieldConfig, RangeValue } from "./data-views-types";
+/**
+ * PROGRESSIVE COLLAPSE — which filter controls fit on the toolbar, measured.
+ *
+ * Two rules, and both come from watching the all-or-nothing version fail:
+ *
+ * 1. Controls shed ONE AT A TIME into an overflow, never all at once. With four
+ *    filters and room for three, hiding all four throws away the room that was
+ *    there.
+ * 2. An APPLIED filter is ranked first, not exempt. Applied controls take the
+ *    visible slots ahead of idle ones, and go into "Mais" like anything else
+ *    when even those slots run out. Exempting them outright — the earlier rule
+ *    — meant four applied filters on a phone claimed more width than the row
+ *    had, and the bar painted past its own edge: the pills were reachable only
+ *    by scrolling the toolbar sideways. Hiding one is safe because "Mais" says
+ *    how many applied filters are behind it; scrolling one off-screen says
+ *    nothing at all.
+ *
+ * It MEASURES rather than picking a breakpoint, which is what
+ * `FILTERS-CONTRACT.md` asks for: pages declare different numbers of filters
+ * with different label lengths, and the same page collapses at a different
+ * width in another language. A shared breakpoint is wrong for at least one
+ * table by construction.
+ *
+ * Collapsing is presentation only — nothing here emits a query, drops a filter
+ * or changes a rendered row.
+ */
+/** A filter control on the bar: a multi-select pill or a min/max range. */
+export interface OverflowField<T extends Record<string, unknown>> {
+    id: string;
+    label: string;
+    /** Which control it is — the caller renders the right one. */
+    group: "pill" | "range";
+    pill?: FilterFieldConfig<T>;
+    range?: RangeFieldConfig<T>;
+}
+/** What the caller renders inline, and what goes behind "Mais". */
+export interface OverflowSplit<T extends Record<string, unknown>> {
+    inline: OverflowField<T>[];
+    overflow: OverflowField<T>[];
+    /**
+     * Step 2 — Exibir/Exportar drop their text labels and become icons.
+     * Cheap: both keep their icon, their tooltip and their position.
+     */
+    compactControls: boolean;
+    /**
+     * Step 5, and the LAST resort — the "N de N" counter is dropped.
+     *
+     * Only once every control has already collapsed and the row STILL does not
+     * fit, which on a six-filter table is below about 400px. The counter goes
+     * last because it is the only thing left that reports rather than does: an
+     * operator can act without knowing the total, but not without the search.
+     */
+    counterHidden: boolean;
+    /**
+     * Step 4 — the search collapses to a magnifier that expands on click.
+     * The most expensive step, so it is taken last: the search is the one
+     * control on the bar that cannot be guessed from an icon's position.
+     */
+    searchCollapsed: boolean;
+    /**
+     * Step 6, below even the counter — "Limpar" leaves the bar.
+     *
+     * The one control here with a second home: the overflow panel's footer
+     * carries "Limpar todos os filtros". So it goes before the search icon or
+     * "Mais", neither of which has anywhere else to be.
+     */
+    clearAllHidden: boolean;
+    /**
+     * Expanding the magnifier must take the whole cluster, filters and all.
+     *
+     * Only on the rungs where what is left over would be too narrow to read —
+     * on a large phone the box simply shrinks and the filters stay, which is why
+     * this is its own answer rather than `searchCollapsed` reused.
+     */
+    searchTakeover: boolean;
+    /** Attach to the toolbar row being measured. */
+    barRef: React.RefObject<HTMLDivElement | null>;
+}
+/** Every declared control, pills first, in the order the bar renders them. */
+export declare function toOverflowFields<T extends Record<string, unknown>>(fields: FilterFieldConfig<T>[], rangeFields: RangeFieldConfig<T>[]): OverflowField<T>[];
+/**
+ * Split the declared filter controls into what fits and what goes behind
+ * "Mais", measured against the live toolbar width.
+ *
+ * Cached on a SIGNATURE rather than by `useMemo` over the inputs: hosts declare
+ * their fields inline, so `all` is a fresh array on every render while the
+ * configuration is unchanged, and a reference-keyed memo would never hit.
+ */
+export declare function useFilterOverflow<T extends Record<string, unknown>>(all: OverflowField<T>[], pills: Record<string, string[]>, ranges: Record<string, RangeValue>, 
+/**
+ * A filter control is open — hold the current answer until it closes.
+ *
+ * Applying a filter changes that control's LABEL ("Valor" becomes "Valor: ≥
+ * R$ 1"), which changes its measured width, which re-runs the whole split
+ * while its popover is open on top of it. Measured: setting a minimum moved
+ * the trigger 192px left, took the popover with it, and pushed two other
+ * controls into a newly-appeared "Mais 2" — so reaching for the second bound
+ * meant chasing the control across the row. Nobody sets a range that way.
+ *
+ * Frozen only for the duration: closing re-measures against the new labels,
+ * so the row still ends up correct, it just does not rearrange under a hand
+ * that is mid-edit.
+ */
+frozen?: boolean, 
+/** Whether "Exportar" is on the bar — see `rightClusterCost`. */
+hasExport?: boolean): OverflowSplit<T>;
+//# sourceMappingURL=data-views-overflow.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-overflow.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-overflow.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE1F;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,2EAA2E;AAC3E,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC9D,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACxB,IAAI,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAC5B,KAAK,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;CAC7B;AAED,mEAAmE;AACnE,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC9D,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3B,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7B;;;OAGG;IACH,eAAe,EAAE,OAAO,CAAC;IACzB;;;;;;;OAOG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;IACzB;;;;;;OAMG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB;;;;;;OAMG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,gDAAgD;IAChD,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;CAChD;AAED,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,EAC9B,WAAW,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,GACjC,aAAa,CAAC,CAAC,CAAC,EAAE,CAKpB;AAoMD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjE,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,EACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC;AAClC;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAQ;AACd,iEAAiE;AACjE,SAAS,UAAO,GACf,aAAa,CAAC,CAAC,CAAC,CAmBlB"}

package/dist/types/components/data-display/DataViews/data-views-pagination.d.ts

@@ -0,0 +1,11 @@
+import type { DataViewsController } from "./use-data-views-state";
+/**
+ * The server-mode pagination control rendered beneath the grid — shown only
+ * when the table is backend-driven and there is more than one page. Client-mode
+ * tables render every matched row at once, so they never show it (FUT-180).
+ */
+export declare function DataViewsPagination<T extends Record<string, unknown>>({ c, testIdPrefix, }: {
+    c: DataViewsController<T>;
+    testIdPrefix: string;
+}): React.JSX.Element | null;
+//# sourceMappingURL=data-views-pagination.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-pagination.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-pagination.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAElE;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACrE,CAAC,EACD,YAAY,GACb,EAAE;IACD,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAY3B"}

package/dist/types/components/data-display/DataViews/data-views-preset-chips.d.ts

@@ -0,0 +1,16 @@
+import type { RangePreset, RangeValue } from "./data-views-types";
+/**
+ * The preset row. Renders nothing when a field declares none, so a numeric
+ * range without host-configured windows keeps the popover it had.
+ *
+ * Carries no outer margin — the three surfaces that host it (the pill's
+ * popover, the slide-in panel, the "Mais" overflow) each sit it in a different
+ * stack, and a baked-in margin would be wrong in two of them.
+ */
+export declare function RangePresets({ presets, value, onChange, testId, }: {
+    presets: RangePreset[];
+    value: RangeValue;
+    onChange: (range: RangeValue) => void;
+    testId: string;
+}): React.JSX.Element | null;
+//# sourceMappingURL=data-views-preset-chips.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-preset-chips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-preset-chips.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-preset-chips.tsx"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AA2ClE;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,EAC3B,OAAO,EACP,KAAK,EACL,QAAQ,EACR,MAAM,GACP,EAAE;IACD,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAqB3B"}

package/dist/types/components/data-display/DataViews/data-views-preview.d.ts

@@ -0,0 +1,22 @@
+import type { DataViewColumn, DataViewState, FilterFieldConfig } from "./data-views-types";
+/**
+ * Human-readable summary of a view state (FUT-89), used by the save-view modal's
+ * preview and the manage dialog. Pure + label-driven so it is unit-testable and
+ * shared. Returns empty arrays for sections with nothing set.
+ */
+interface ViewStateDescription {
+    filters: string[];
+    /**
+     * The columns this view HIDES, not the ones it shows.
+     *
+     * A view that hides three of eleven columns listed eight names, which is a
+     * wall of text stating the default. What the operator needs to check before
+     * saving is what this view CHANGES — and for columns, the change is the
+     * hiding.
+     */
+    columns: string[];
+    sort: string[];
+}
+export declare function describeViewState<T extends Record<string, unknown>>(state: DataViewState, fields: FilterFieldConfig<T>[], columns: DataViewColumn<T>[]): ViewStateDescription;
+export {};
+//# sourceMappingURL=data-views-preview.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-preview.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,UAAU,oBAAoB;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAWD,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjE,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,EAC9B,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,GAC3B,oBAAoB,CAsBtB"}

package/dist/types/components/data-display/DataViews/data-views-range-pill.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { RangeFieldConfig, RangeValue } from './data-views-types';
+/**
+ * The `De`/`Até` pair for a range — shared by the pill's popover and the
+ * slide-in panel's day fields, so the two surfaces cannot drift on what a bound
+ * accepts or how it clears.
+ */
+export declare function RangeBounds<T extends Record<string, unknown>>({ field, value, onChange, testId, }: {
+    field: RangeFieldConfig<T>;
+    value: RangeValue;
+    onChange: (range: RangeValue) => void;
+    testId: string;
+}): React.JSX.Element;
+export declare function RangePill<T extends Record<string, unknown>>({ field, value, onChange, onOpenChange, testIdPrefix, }: {
+    field: RangeFieldConfig<T>;
+    value: RangeValue;
+    onChange: (range: RangeValue) => void;
+    /** So a measured toolbar can hold still while this is open. */
+    onOpenChange?: (open: boolean) => void;
+    testIdPrefix: string;
+}): React.JSX.Element;
+/**
+ * One range on the SLIDE-IN panel (and the narrow-screen modal): the numeric
+ * control the panel already had, or — for a day range, which that control cannot
+ * express — the same `De`/`Até` pair the pill's popover uses.
+ */
+export declare function PanelRangeField<T extends Record<string, unknown>>({ field, value, onChange, testId, }: {
+    field: RangeFieldConfig<T>;
+    value: RangeValue;
+    onChange: (range: RangeValue) => void;
+    testId: string;
+}): React.JSX.Element;
+//# sourceMappingURL=data-views-range-pill.d.ts.map

package/dist/types/components/data-display/DataViews/data-views-range-pill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-views-range-pill.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/DataViews/data-views-range-pill.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAaxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AA8CvE;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC7D,KAAK,EACL,KAAK,EACL,QAAQ,EACR,MAAM,GACP,EAAE;IACD,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAC3B,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAgDpB;AA4GD,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC3D,KAAK,EACL,KAAK,EACL,QAAQ,EACR,YAAY,EACZ,YAAY,GACb,EAAE;IACD,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAC3B,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,+DAA+D;IAC/D,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAkDpB;AAGD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACjE,KAAK,EACL,KAAK,EACL,QAAQ,EACR,MAAM,GACP,EAAE;IACD,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAC3B,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CA0BpB"}