@area8975/ui 0.2.2-dev.49 → 0.2.2-dev.50

package/types/area8975-ui-segmented.d.ts

@@ -0,0 +1,41 @@
+import * as i0 from "@angular/core";
+export interface SegmentedOption<T> {
+  value: T;
+  label: string;
+  /** Read out instead of `label`, for when the label is abbreviated, e.g. "6M". */
+  ariaLabel?: string;
+}
+export declare class UiSegmentedComponent<T> {
+  readonly options: import("@angular/core").InputSignal<SegmentedOption<T>[]>;
+  readonly value: import("@angular/core").ModelSignal<T>;
+  /** What the options choose between, e.g. "How far back the charts go". */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /** Stretches to the container's width with the options sharing it evenly. */
+  readonly fill: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly name: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiSegmentedComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiSegmentedComponent<any>, "ui-segmented", never, {
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": true;
+      "isSignal": true;
+    };
+    "fill": {
+      "alias": "fill";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}

package/types/area8975-ui-select.d.ts

@@ -0,0 +1,293 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { InputValidation } from "@area8975/ui/input";
+import { UiOverlayCloseBehaviour } from "@area8975/ui/overlay";
+import { Placement } from "@floating-ui/dom";
+import { Observable } from "rxjs";
+export interface SelectDataSourceParameters {
+  query: string;
+  page: number;
+  size: number;
+}
+export interface SelectDataSourceContent<Model> {
+  items: Model[];
+  hasMore: boolean;
+}
+export interface SelectDataSource<Model> {
+  load(params: SelectDataSourceParameters): Observable<SelectDataSourceContent<Model>>;
+}
+export declare class SelectLocalDataSource<Model> implements SelectDataSource<Model> {
+  private readonly items;
+  private readonly search;
+  constructor(items: Model[], search: (item: Model, query: string) => boolean);
+  load(params: SelectDataSourceParameters): Observable<SelectDataSourceContent<Model>>;
+}
+export declare class SelectRemoteDataSource<Model> implements SelectDataSource<Model> {
+  private readonly fetch;
+  constructor(fetch: (params: SelectDataSourceParameters) => Observable<SelectDataSourceContent<Model>>);
+  load(params: SelectDataSourceParameters): Observable<SelectDataSourceContent<Model>>;
+}
+export type SearchMode = 'none' | 'inline' | 'dropdown';
+/** How a multiple select shows its selection when closed. */
+export declare const SelectMultipleDisplays: readonly ["text", "tags"];
+/** @see {@link SelectMultipleDisplays} */
+export type SelectMultipleDisplay = typeof SelectMultipleDisplays[number];
+/** Context for a projected `#option` template. */
+export interface SelectOptionContext<Model> {
+  $implicit: Model;
+  selected: boolean;
+  active: boolean;
+}
+/** Context for a projected `#trigger` template, single select only. */
+export interface SelectTriggerContext<Model> {
+  $implicit: Model;
+}
+/** Context for a projected `#leading` template, inline search single select only. */
+export interface SelectLeadingContext<Model> {
+  $implicit: Model;
+}
+/** One line in the open list. Groups are headings, the rest can be picked. */
+export type SelectRow<Model> = {
+  kind: 'group';
+  id: string;
+  label: string;
+} | {
+  kind: 'clear';
+  id: string;
+  index: number;
+} | {
+  kind: 'create';
+  id: string;
+  index: number;
+  query: string;
+} | {
+  kind: 'item';
+  id: string;
+  index: number;
+  item: Model;
+  label: string;
+  selected: boolean;
+};
+export declare class UiSelectComponent<Model = unknown> {
+  readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  readonly placement: import("@angular/core").InputSignal<Placement>;
+  readonly closeBehaviour: import("@angular/core").InputSignal<UiOverlayCloseBehaviour>;
+  readonly dataSource: import("@angular/core").InputSignal<SelectDataSource<Model>>;
+  readonly items: import("@angular/core").WritableSignal<Model[]>;
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  /** Goes on the trigger (or the inline search box), pass it to ui-field's `for`. */
+  readonly id: import("@angular/core").InputSignal<string>;
+  readonly describedBy: import("@angular/core").InputSignal<string>;
+  readonly pageSize: import("@angular/core").InputSignal<number>;
+  readonly searchMode: import("@angular/core").InputSignal<SearchMode>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly validationState: import("@angular/core").ModelSignal<InputValidation>;
+  readonly clearable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly clearLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Offers a "Create" row when a search matches nothing. Needs a
+   * searchMode, the parent handles `create` and adds the new item.
+   */
+  readonly creatable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly createLabel: import("@angular/core").InputSignal<(query: string) => string>;
+  /** Puts a heading above each run of items in the same group. Expects items sorted by group. */
+  readonly groupBy: import("@angular/core").InputSignal<((item: Model) => string | null) | null>;
+  /** Scrolls the selected option into view when the list opens. */
+  readonly scrollToSelected: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Lets several items be picked, bound through `selectedItems`. */
+  readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly multipleDisplay: import("@angular/core").InputSignal<"text" | "tags">;
+  /** In text display, swaps the list of names for a count past this many. 0 always counts. */
+  readonly counterAfter: import("@angular/core").InputSignal<number | null>;
+  readonly counterLabel: import("@angular/core").InputSignal<(count: number) => string>;
+  readonly compareWith: import("@angular/core").InputSignal<(a: Model, b: Model) => boolean>;
+  readonly displayWith: import("@angular/core").InputSignal<(item: Model) => string>;
+  readonly selectionChange: import("@angular/core").OutputEmitterRef<Model | null>;
+  /** Emits the search text when the "Create" row is picked. */
+  readonly create: import("@angular/core").OutputEmitterRef<string>;
+  readonly selectedItem: import("@angular/core").ModelSignal<Model | null>;
+  readonly selectedItems: import("@angular/core").ModelSignal<Model[]>;
+  readonly query: import("@angular/core").WritableSignal<string>;
+  readonly loading: import("@angular/core").WritableSignal<boolean>;
+  readonly hasMore: import("@angular/core").WritableSignal<boolean>;
+  readonly optionTemplate: import("@angular/core").Signal<TemplateRef<SelectOptionContext<Model>> | undefined>;
+  readonly triggerTemplate: import("@angular/core").Signal<TemplateRef<SelectTriggerContext<Model>> | undefined>;
+  /** With an inline search, shown before the chosen item's text, e.g. its colour. Single select only. */
+  readonly leadingTemplate: import("@angular/core").Signal<TemplateRef<SelectLeadingContext<Model>> | undefined>;
+  /** Index into the pickable rows, the one keyboard focus sits on. */
+  readonly activeIndex: import("@angular/core").WritableSignal<number>;
+  readonly listId: string;
+  readonly hasSelection: import("@angular/core").Signal<boolean>;
+  readonly triggerLabel: import("@angular/core").Signal<string>;
+  readonly isEmpty: import("@angular/core").Signal<boolean>;
+  /** Tags only replace the trigger text when there's no inline search box. */
+  readonly showTags: import("@angular/core").Signal<boolean>;
+  readonly showLeading: import("@angular/core").Signal<boolean>;
+  /** Typing replaces the chosen item's text, so its leading content sits out the search. */
+  readonly leadingHidden: import("@angular/core").Signal<boolean>;
+  /** The text to create from, or null when there's nothing to offer. */
+  readonly createQuery: import("@angular/core").Signal<string | null>;
+  readonly rows: import("@angular/core").Signal<SelectRow<Model>[]>;
+  private readonly pickable;
+  readonly activeId: import("@angular/core").Signal<string | null>;
+  private page;
+  private readonly load$;
+  private readonly host;
+  private readonly injector;
+  private readonly destroyRef;
+  private readonly cdr;
+  constructor();
+  private fetchPage;
+  private applyResult;
+  open(): void;
+  toggle(): void;
+  select(item: Model): void;
+  isSelected(item: Model): boolean;
+  toggleItem(item: Model): void;
+  removeItem(item: Model): void;
+  clear(): void;
+  onItemClick(item: Model): void;
+  onCreate(): void;
+  onKeydown(event: KeyboardEvent): void;
+  onFocusOut(event: FocusEvent): void;
+  setActive(index: number): void;
+  loadFirstPage(): void;
+  loadNextPage(): void;
+  onQueryChange(query: string): void;
+  onScroll(scrollContainer: HTMLElement): void;
+  private pickActive;
+  private moveActive;
+  private scrollActiveIntoView;
+  private focusTrigger;
+  private searchInput;
+  private rowId;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiSelectComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiSelectComponent<any>, "ui-select", never, {
+    "placement": {
+      "alias": "placement";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeBehaviour": {
+      "alias": "closeBehaviour";
+      "required": false;
+      "isSignal": true;
+    };
+    "dataSource": {
+      "alias": "dataSource";
+      "required": true;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "describedBy": {
+      "alias": "describedBy";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageSize": {
+      "alias": "pageSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "searchMode": {
+      "alias": "searchMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "validationState": {
+      "alias": "validationState";
+      "required": false;
+      "isSignal": true;
+    };
+    "clearable": {
+      "alias": "clearable";
+      "required": false;
+      "isSignal": true;
+    };
+    "clearLabel": {
+      "alias": "clearLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "creatable": {
+      "alias": "creatable";
+      "required": false;
+      "isSignal": true;
+    };
+    "createLabel": {
+      "alias": "createLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "groupBy": {
+      "alias": "groupBy";
+      "required": false;
+      "isSignal": true;
+    };
+    "scrollToSelected": {
+      "alias": "scrollToSelected";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiple": {
+      "alias": "multiple";
+      "required": false;
+      "isSignal": true;
+    };
+    "multipleDisplay": {
+      "alias": "multipleDisplay";
+      "required": false;
+      "isSignal": true;
+    };
+    "counterAfter": {
+      "alias": "counterAfter";
+      "required": false;
+      "isSignal": true;
+    };
+    "counterLabel": {
+      "alias": "counterLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "compareWith": {
+      "alias": "compareWith";
+      "required": false;
+      "isSignal": true;
+    };
+    "displayWith": {
+      "alias": "displayWith";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectedItem": {
+      "alias": "selectedItem";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectedItems": {
+      "alias": "selectedItems";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "validationState": "validationStateChange";
+    "selectionChange": "selectionChange";
+    "create": "create";
+    "selectedItem": "selectedItemChange";
+    "selectedItems": "selectedItemsChange";
+  }, ["optionTemplate", "triggerTemplate", "leadingTemplate"], never, true, never>;
+}

package/types/area8975-ui-sidebar-group.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+export declare class UiSidebarGroupComponent {
+  private readonly sidebar;
+  readonly label: import("@angular/core").InputSignal<string>;
+  protected readonly labelId: string;
+  readonly isCollapsed: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiSidebarGroupComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiSidebarGroupComponent, "ui-sidebar-group", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}

package/types/area8975-ui-sidebar-item.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+export declare class UiSidebarItemComponent {
+  private readonly sidebar;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly icon: import("@angular/core").InputSignal<string>;
+  readonly isCollapsed: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiSidebarItemComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiSidebarItemComponent, "ui-sidebar-item", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["ui-badge"], true, never>;
+}

package/types/area8975-ui-sidebar.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+export declare class UiSidebarComponent {
+  readonly isOpen: import("@angular/core").ModelSignal<boolean>;
+  readonly isCollapsed: import("@angular/core").Signal<boolean>;
+  readonly toggle: () => void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiSidebarComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiSidebarComponent, "ui-sidebar", ["uiSidebar"], {
+    "isOpen": {
+      "alias": "isOpen";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "isOpen": "isOpenChange";
+  }, never, ["*", "[sidebar-footer]"], true, never>;
+}

package/types/area8975-ui-skeleton.d.ts

@@ -0,0 +1,35 @@
+import * as i0 from "@angular/core";
+/**
+ * A placeholder shown while content loads. Size it with classes on the
+ * element, e.g. `class="w-48"` for text or `class="size-12"` for a circle.
+ */
+export declare class UiSkeletonComponent {
+  readonly shape: import("@angular/core").InputSignal<"text" | "circle" | "rect">;
+  readonly animated: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Text only, stacks this many lines with a shorter last one. */
+  readonly lines: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  protected readonly lineIndexes: import("@angular/core").Signal<number[]>;
+  readonly generatedClasses: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiSkeletonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiSkeletonComponent, "ui-skeleton", never, {
+    "shape": {
+      "alias": "shape";
+      "required": false;
+      "isSignal": true;
+    };
+    "animated": {
+      "alias": "animated";
+      "required": false;
+      "isSignal": true;
+    };
+    "lines": {
+      "alias": "lines";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** What a skeleton stands in for, lines of text, an avatar or a block. */
+export declare const SkeletonShapes: readonly ["text", "circle", "rect"];
+/** @see {@link SkeletonShapes} */
+export type SkeletonShape = typeof SkeletonShapes[number];

package/types/area8975-ui-stat.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+/** Each stat is its own `dl`, so wrap a row of them in a plain div. */
+export declare class UiStatComponent {
+  readonly label: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiStatComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiStatComponent, "ui-stat", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, ["*", "[stat-change]", "[stat-note]"], true, never>;
+}

package/types/area8975-ui-switch.d.ts

@@ -0,0 +1,32 @@
+import * as i0 from "@angular/core";
+export declare class UiSwitchComponent {
+  readonly value: import("@angular/core").ModelSignal<boolean>;
+  readonly id: import("@angular/core").InputSignal<string>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiSwitchComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiSwitchComponent, "ui-switch", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
+}

package/types/area8975-ui-tab.d.ts

@@ -0,0 +1,45 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+export declare class UiTabDirective {
+  label: import("@angular/core").InputSignal<string>;
+  disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  active: import("@angular/core").ModelSignal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiTabDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<UiTabDirective, "[uiTab]", never, {
+    "label": {
+      "alias": "uiTab";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "active": {
+      "alias": "active";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "active": "activeChange";
+  }, never, never, true, never>;
+}
+export type TabButtonAppearance = 'solid' | 'underline';
+export declare class UiTabComponent {
+  readonly tabs: import("@angular/core").Signal<readonly UiTabDirective[]>;
+  readonly selectedIndex: import("@angular/core").WritableSignal<number>;
+  readonly actions: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+  readonly appearance: import("@angular/core").InputSignal<TabButtonAppearance>;
+  readonly generatedButtonClasses: import("@angular/core").Signal<string>;
+  constructor();
+  select(index: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiTabComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiTabComponent, "ui-tab", never, {
+    "appearance": {
+      "alias": "appearance";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["tabs", "actions"], ["*"], true, never>;
+}

package/types/area8975-ui-table-filters.d.ts

@@ -0,0 +1,138 @@
+import { DateRange, IsoDate } from "@area8975/ui/calendar";
+import { DateRangePreset } from "@area8975/ui/date-range-picker";
+import * as i0 from "@angular/core";
+export declare const TableFiltersBreakpoints: {
+  readonly sm: "40rem";
+  readonly md: "48rem";
+  readonly lg: "64rem";
+  readonly xl: "80rem";
+  readonly '2xl': "96rem";
+};
+/** @see {@link TableFiltersBreakpoints} */
+export type TableFiltersBreakpoint = keyof typeof TableFiltersBreakpoints;
+export interface TableFacetOption {
+  value: unknown;
+  label: string;
+}
+/** Writes the picked value, or an array when `multiple`, under `id`. */
+export interface TableOptionsFacet {
+  id: string;
+  label: string;
+  kind: 'options';
+  options: TableFacetOption[];
+  multiple?: boolean;
+  /** Shows this many options, plus any picked, then a "Show N more" toggle. Leave out to show them all. */
+  visibleOptions?: number;
+}
+/** Writes `{ start, end }` ISO dates under `id`. */
+export interface TableDateRangeFacet {
+  id: string;
+  label: string;
+  kind: 'dateRange';
+  /** Quick picks, see date-range-presets.ts for ready made ones. */
+  presets?: DateRangePreset[];
+  placeholder?: string;
+  min?: IsoDate | null;
+  max?: IsoDate | null;
+}
+/** Either end is null when it's open. */
+export interface TableAmountRange {
+  min: number | null;
+  max: number | null;
+}
+export interface TableAmountRangePreset {
+  label: string;
+  range: TableAmountRange;
+}
+/** Writes `{ min, max }` under `id`, both ends included, with at least one of them set. */
+export interface TableAmountRangeFacet {
+  id: string;
+  label: string;
+  kind: 'amountRange';
+  presets?: TableAmountRangePreset[];
+  /** Shown before each amount, such as a currency symbol. */
+  prefix?: string;
+}
+export type TableFacet = TableOptionsFacet | TableDateRangeFacet | TableAmountRangeFacet;
+export type TableFacetDateRange = DateRange;
+type Filters = Record<string, unknown>;
+type RangeMode = 'any' | 'custom' | number;
+type AmountEnd = keyof TableAmountRange;
+export declare class UiTableFiltersComponent {
+  private readonly registry;
+  readonly facets: import("@angular/core").InputSignal<TableFacet[]>;
+  /** The `tableId` of a ui-table to filter, it can render before or after this. */
+  readonly table: import("@angular/core").InputSignal<string | null>;
+  readonly value: import("@angular/core").ModelSignal<Filters>;
+  /** Below this breakpoint the panel becomes a Filters button and a drawer. */
+  readonly collapseBelow: import("@angular/core").InputSignal<"sm" | "md" | "lg" | "xl" | "2xl">;
+  protected readonly idPrefix: string;
+  protected readonly anyRange: RangeMode;
+  protected readonly customRange: RangeMode;
+  private readonly customRanges;
+  private readonly amountDrafts;
+  private readonly expanded;
+  private readonly linked;
+  protected readonly appliedCount: import("@angular/core").Signal<number>;
+  protected readonly anyApplied: import("@angular/core").Signal<boolean>;
+  private readonly window;
+  protected readonly wide: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  protected groupName(facet: TableFacet): string;
+  protected choiceId(facet: TableFacet, choice: number | string): string;
+  protected picked(facet: TableOptionsFacet): unknown;
+  protected pick(facet: TableOptionsFacet, value: unknown): void;
+  protected isChecked(facet: TableOptionsFacet, option: TableFacetOption): boolean;
+  protected check(facet: TableOptionsFacet, option: TableFacetOption, checked: boolean): void;
+  protected isExpanded(facet: TableOptionsFacet): boolean;
+  protected isShown(facet: TableOptionsFacet, option: TableFacetOption, index: number): boolean;
+  /** How many options collapsing hides, 0 when there's nothing to toggle. */
+  protected hiddenCount(facet: TableOptionsFacet): number;
+  protected toggleExpanded(facet: TableOptionsFacet): void;
+  protected range(facet: TableDateRangeFacet): DateRange;
+  protected dateMode(facet: TableDateRangeFacet): RangeMode;
+  protected pickDate(facet: TableDateRangeFacet, mode: RangeMode): void;
+  protected setRange(facet: TableDateRangeFacet, range: DateRange): void;
+  protected amountRange(facet: TableAmountRangeFacet): TableAmountRange | undefined;
+  protected amountMode(facet: TableAmountRangeFacet): RangeMode;
+  protected pickAmount(facet: TableAmountRangeFacet, mode: RangeMode): void;
+  protected amountText(facet: TableAmountRangeFacet, end: AmountEnd): string;
+  protected typeAmount(facet: TableAmountRangeFacet, end: AmountEnd, text: string): void;
+  protected isAmountValid(facet: TableAmountRangeFacet, end: AmountEnd): boolean;
+  protected clearAll(): void;
+  private setCustom;
+  private forgetAmountDraft;
+  private isPastCutoff;
+  private isSelected;
+  private apply;
+  private write;
+  private currentFilters;
+  private ownFilters;
+  private withoutOwn;
+  private hasAny;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UiTableFiltersComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UiTableFiltersComponent, "ui-table-filters", never, {
+    "facets": {
+      "alias": "facets";
+      "required": true;
+      "isSignal": true;
+    };
+    "table": {
+      "alias": "table";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapseBelow": {
+      "alias": "collapseBelow";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}