@masmarino/gabarit 1.4.0 → 2.1.0

package/types/masmarino-gabarit-disclosure.d.ts

@@ -0,0 +1,44 @@
+import * as i0 from "@angular/core";
+type DisclosureAppearance = 'bordered' | 'plain';
+type DisclosureHeadingLevel = 2 | 3 | 4 | 5 | 6;
+export declare class Disclosure {
+  label: import("@angular/core").InputSignal<string>;
+  open: import("@angular/core").ModelSignal<boolean>;
+  icon: import("@angular/core").InputSignal<string | null>;
+  appearance: import("@angular/core").InputSignal<DisclosureAppearance>;
+  headingLevel: import("@angular/core").InputSignal<DisclosureHeadingLevel | null>;
+  protected readonly buttonId: string;
+  protected readonly panelId: string;
+  protected toggle(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Disclosure, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Disclosure, "gbt-disclosure", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "open": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "appearance": {
+      "alias": "appearance";
+      "required": false;
+      "isSignal": true;
+    };
+    "headingLevel": {
+      "alias": "headingLevel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "open": "openChange";
+  }, never, ["*"], true, never>;
+}
+export type { DisclosureAppearance, DisclosureHeadingLevel };

package/types/masmarino-gabarit-divider.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+type DividerOrientation = 'horizontal' | 'vertical';
+export declare class Divider {
+  orientation: import("@angular/core").InputSignal<DividerOrientation>;
+  label: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Divider, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Divider, "gbt-divider", never, {
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { DividerOrientation };

package/types/masmarino-gabarit-docs.d.ts

@@ -3,25 +3,19 @@ import { InjectionToken, Provider, Signal } from "@angular/core";
 import { Observable } from "rxjs";
 import { CanActivateFn, Routes } from "@angular/router";
 import { SafeHtml } from "@angular/platform-browser";
-import { AutocompleteSearchFn, PanelHeadingLevel } from "@masmarino/gabarit";
+import { AutocompleteSearchFn } from "@masmarino/gabarit/autocomplete";
+import { PanelHeadingLevel } from "@masmarino/gabarit/panel";
 interface DocsConfig {
-  /**
-   * Where the pages are, both as files and as the reader's routes: `<root>/index.json`, `<root>/<section>/<page>.md`,
-   * and the page `<root>/<section>/<page>`. `/docs` by default.
-   */
+  /** Where the files (`<root>/index.json`, `<root>/<section>/<page>.md`) and the routes live. `/docs` by default. */
   root: string;
-  /**
-   * The quotes that become callouts: a quote whose first word, in bold, is one of these keys (`> **Note** …`), drawn
-   * in the tone it maps to. Case does not matter.
-   */
+  /** A quote opening on one of these words in bold (`> **Note** …`) becomes a callout of that tone. Any case. */
   callouts: Readonly<Record<string, 'note' | 'warning'>>;
 }
 export declare const DEFAULT_DOCS_CONFIG: Readonly<DocsConfig>;
 export declare const DOCS_CONFIG: InjectionToken<DocsConfig>;
 /**
- * Where the shown page's title goes, for an app that names its pages somewhere of its own (a header, a breadcrumb):
- * called with the page's title, "not found" or the reader's name while loading. Without it the reader leaves the
- * title alone.
+ * Gets the shown page's title (or "not found", or the reader's name while loading), for an app that shows titles in
+ * its own header. Optional.
  */
 export declare const DOCS_TITLE: InjectionToken<(title: string) => void>;
 export declare function provideDocs(config?: Partial<DocsConfig>): Provider;
@@ -92,10 +86,7 @@ export declare function docsReadingOrder(index: DocsIndex): {
 /** Where `<root>` leads: the first page of the first section, or `null` for an empty index. */
 export declare function firstDocsPage(root: string, index: DocsIndex): string[] | null;
 export declare function locateDocsPage(root: string, index: DocsIndex, section: string | null, page: string | null): DocsLocation | null;
-/**
- * The documentation, shipped as static files under the configured root. The index and each page are fetched once
- * and kept, since they only change with a new version of the app. A failure isn't kept, so it gets retried.
- */
+/** Fetches the index and each page once; they only change with a new app version. Failures aren't cached. */
 export declare class DocsService {
   private readonly http;
   readonly root: string;
@@ -124,10 +115,7 @@ interface DocsSearchHit {
   };
 }
 export declare function searchTokens(query: string): string[];
-/**
- * Title, headings and body text of one page. Heading ids follow `gbt-markdown-view`: `user-content-<slug>` on every
- * h1–h4, and `-2`, `-3`… on a repeated slug in document order.
- */
+/** Title, headings and text of a page. Heading ids must match gbt-markdown-view's (`-2`, `-3` on repeats). */
 export declare function parseDocsPage(markdown: string): {
   headings: {
     id: string;
@@ -136,9 +124,8 @@ export declare function parseDocsPage(markdown: string): {
   body: string;
 };
 /**
- * Search over the whole documentation, in the browser. Nothing is fetched until the first search (or `prepare()`),
- * then every page once, kept by `DocsService`. Every word of the query must appear in the page; a word in the title
- * ranks higher than one in a heading, and a heading higher than the text.
+ * Searches every page in the browser, fetching them on first use. All words must match; title beats heading beats
+ * text.
  */
 export declare class DocsSearchService {
   private docs;
@@ -150,21 +137,11 @@ export declare class DocsSearchService {
   static ɵfac: i0.ɵɵFactoryDeclaration<DocsSearchService, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-/**
- * The root opens the first page of the index. If the index can't be read or is empty, the reader shows that itself,
- * inside its own layout.
- */
+/** Sends the root to the first page. A broken or empty index is left for the reader to show. */
 export declare const docsHomeGuard: CanActivateFn;
-/**
- * The reader's routes, to mount at the configured root: the root (to the first page), `<section>/<page>`, and any
- * other depth, which gets the reader's own "not found". `page` is the routed component that shows the reader (often
- * the app's own, wrapping `gbt-docs-page` in its layout).
- */
+/** The reader's routes, for the configured root. `page` loads the component that shows it (often the app's). */
 export declare function docsRoutes(page: () => Promise<unknown>): Routes;
-/**
- * The documentation's left column: the search field, then every section with its pages. Only the current section
- * starts open. On a narrow layout the sections fold behind a toggle and the search stays.
- */
+/** The left column: search, then the sections and their pages, only the current one open. */
 export declare class DocsNav {
   index: import("@angular/core").InputSignal<DocsIndex>;
   section: import("@angular/core").InputSignal<string | null>;
@@ -218,18 +195,12 @@ export declare function headingSlug(text: string): string;
 export declare function decodeFragment(rawFragment: string): string;
 /** The element a `#fragment` points at: the plain `id`, else the `user-content-` id or `<a name>` the sanitiser made. */
 export declare function findAnchorTarget(root: HTMLElement, rawFragment: string): HTMLElement | null;
-/**
- * A long code block or a wide table scrolls sideways, which a keyboard can only do once it takes the focus (WCAG
- * 2.1.1): each one becomes a named stop in the tab order. A table keeps its own role and gets only the stop and the
- * name.
- */
+/** A keyboard only scrolls a wide code block or table it has focused (WCAG 2.1.1): each gets a tab stop. */
 export declare function makeScrollableBlocksFocusable(container: HTMLElement, names: {
   codeBlock: string;
   table: string;
 }): void;
-/**
- * A task-list checkbox is named by its item's text, so a screen reader says what is done or still to do.
- */
+/** Names each task-list checkbox after its item, so a screen reader says what's done. */
 export declare function nameTaskCheckboxes(container: HTMLElement): void;
 /**
  * Markdown rendered to sanitised HTML, with the reading styles of the design system: headings, lists, code, tables,
@@ -239,10 +210,7 @@ export declare class MarkdownView {
   content: import("@angular/core").InputSignal<string>;
   /** Levels added to every heading (up to h6), so a `# Title` under the page's own headings keeps the outline. */
   headingOffset: import("@angular/core").InputSignal<number>;
-  /**
-   * Links under this prefix (`/docs` → `/docs/install/configuration#variables`) go through the router instead of
-   * reloading the app. Off by default: a link in a README is left to the browser.
-   */
+  /** Links under this prefix (say `/docs`) go through the router instead of reloading the app. Off by default. */
   routedLinkPrefix: import("@angular/core").InputSignal<string | null>;
   /** The h2–h4 headings, emitted after each render once their ids are in the DOM. */
   outline: import("@angular/core").OutputEmitterRef<MarkdownOutlineEntry[]>;
@@ -252,8 +220,8 @@ export declare class MarkdownView {
   private readonly container;
   constructor();
   /**
-   * In-content `#anchor` links would resolve against `<base href="/">` and load the home page, so a plain left click
-   * scrolls to the target inside this view and focuses it. Modified and middle clicks are left to the browser.
+   * A bare #anchor resolves against <base href="/"> and would load the home page, so a plain click scrolls here
+   * instead. Modified and middle clicks are the browser's.
    */
   protected onClick(event: MouseEvent): void;
   /** The `href` of a clicked in-content link under `routedLinkPrefix`, or `null` when the browser should follow it. */
@@ -292,11 +260,7 @@ type DocsView = {
   location: DocsLocation;
   content: string;
 };
-/**
- * One documentation page (`<root>/<section>/<page>`, read from the route): the navigation, the page with its
- * breadcrumb and neighbours, and on a wide screen the outline beside it. An unknown address gets a "not found" in the
- * same frame.
- */
+/** The routed page with its nav, breadcrumb, neighbours and outline, or a "not found" in the same frame. */
 export declare class DocsPage {
   private readonly docs;
   private readonly route;
@@ -358,10 +322,7 @@ export declare class DocsSearch {
 }
 /** An outline is worth a panel from two headings on: one heading is no table of contents. */
 export declare function hasOutline(entries: readonly MarkdownOutlineEntry[]): boolean;
-/**
- * The "On this page" panel beside rendered Markdown. Each entry links to `#user-content-…` on the current URL; the
- * router does no anchor scrolling, so the click scrolls to the heading and focuses it itself.
- */
+/** "On this page" for rendered Markdown. The router doesn't scroll to anchors, so a click does it here. */
 export declare class MarkdownOutline {
   entries: import("@angular/core").InputSignal<MarkdownOutlineEntry[]>;
   headingLevel: import("@angular/core").InputSignal<PanelHeadingLevel>;

package/types/masmarino-gabarit-drawer.d.ts

@@ -0,0 +1,51 @@
+import * as i0 from "@angular/core";
+import { OnDestroy } from "@angular/core";
+type DrawerEdge = 'right' | 'left' | 'top' | 'bottom';
+export declare class Drawer implements OnDestroy {
+  isOpen: import("@angular/core").InputSignal<boolean>;
+  edge: import("@angular/core").InputSignal<DrawerEdge>;
+  heading: import("@angular/core").InputSignal<string>;
+  headingLevel: import("@angular/core").InputSignal<1 | 2 | 3 | 4 | 5 | 6>;
+  closeLabel: import("@angular/core").InputSignal<string>;
+  closed: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly rendered: import("@angular/core").WritableSignal<boolean>;
+  private readonly panel;
+  private previouslyFocused;
+  private closeTimer;
+  constructor();
+  ngOnDestroy(): void;
+  protected onEscape(): void;
+  protected onBackdropClick(event: MouseEvent): void;
+  protected onPanelKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Drawer, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Drawer, "gbt-drawer", never, {
+    "isOpen": {
+      "alias": "isOpen";
+      "required": true;
+      "isSignal": true;
+    };
+    "edge": {
+      "alias": "edge";
+      "required": false;
+      "isSignal": true;
+    };
+    "heading": {
+      "alias": "heading";
+      "required": false;
+      "isSignal": true;
+    };
+    "headingLevel": {
+      "alias": "headingLevel";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "closed": "closed";
+  }, never, ["*"], true, never>;
+}
+export type { DrawerEdge };

package/types/masmarino-gabarit-empty-state.d.ts

@@ -0,0 +1,67 @@
+import * as i0 from "@angular/core";
+type EmptyStateIllustration = 'folder' | 'star' | 'checklist' | 'merge' | 'pipeline' | 'tag' | 'book' | 'server';
+type EmptyStateSize = 'default' | 'compact';
+type EmptyStateTone = 'default' | 'error';
+type EmptyStateHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export declare class EmptyState {
+  illustration: import("@angular/core").InputSignal<EmptyStateIllustration | null | undefined>;
+  heading: import("@angular/core").InputSignal<string>;
+  message: import("@angular/core").InputSignal<string>;
+  icon: import("@angular/core").InputSignal<string | null>;
+  size: import("@angular/core").InputSignal<EmptyStateSize>;
+  tone: import("@angular/core").InputSignal<EmptyStateTone>;
+  headingLevel: import("@angular/core").InputSignal<EmptyStateHeadingLevel | null>;
+  headingId: import("@angular/core").InputSignal<string | null>;
+  headingFocusable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly headingEl;
+  focusHeading(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<EmptyState, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<EmptyState, "gbt-empty-state", never, {
+    "illustration": {
+      "alias": "illustration";
+      "required": false;
+      "isSignal": true;
+    };
+    "heading": {
+      "alias": "heading";
+      "required": true;
+      "isSignal": true;
+    };
+    "message": {
+      "alias": "message";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "tone": {
+      "alias": "tone";
+      "required": false;
+      "isSignal": true;
+    };
+    "headingLevel": {
+      "alias": "headingLevel";
+      "required": false;
+      "isSignal": true;
+    };
+    "headingId": {
+      "alias": "headingId";
+      "required": false;
+      "isSignal": true;
+    };
+    "headingFocusable": {
+      "alias": "headingFocusable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export type { EmptyStateHeadingLevel, EmptyStateIllustration, EmptyStateSize, EmptyStateTone };

package/types/masmarino-gabarit-file-upload.d.ts

@@ -0,0 +1,95 @@
+import { ControlValueAccessor } from "@angular/forms";
+import * as i0 from "@angular/core";
+declare function formatFileSize(bytes: number): string;
+export declare class FileUpload implements ControlValueAccessor {
+  private readonly fileInput;
+  id: import("@angular/core").InputSignal<string>;
+  label: import("@angular/core").InputSignal<string>;
+  multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  accept: import("@angular/core").InputSignal<string>;
+  maxSizeMb: import("@angular/core").InputSignal<number | null>;
+  disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  errorMessage: import("@angular/core").InputSignal<string | null>;
+  dropLabel: import("@angular/core").InputSignal<string>;
+  removeLabel: import("@angular/core").InputSignal<(name: string) => string>;
+  oversizeMessage: import("@angular/core").InputSignal<(name: string, maxSizeMb: number) => string>;
+  extraFileMessage: import("@angular/core").InputSignal<(name: string) => string>;
+  protected readonly files: import("@angular/core").WritableSignal<File[]>;
+  protected readonly rejections: import("@angular/core").WritableSignal<string[]>;
+  protected readonly dragOver: import("@angular/core").WritableSignal<boolean>;
+  protected readonly formatFileSize: typeof formatFileSize;
+  private readonly formDisabled;
+  protected readonly isDisabled: import("@angular/core").Signal<boolean>;
+  private onChange;
+  private onTouched;
+  writeValue(value: File[] | null): void;
+  registerOnChange(fn: (value: File[]) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  protected openPicker(): void;
+  protected onFilesSelected(event: Event): void;
+  protected onDragEnter(event: DragEvent): void;
+  protected onDragOver(event: DragEvent): void;
+  protected onDragLeave(event: DragEvent): void;
+  protected onDrop(event: DragEvent): void;
+  protected removeFile(file: File): void;
+  private addFiles;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FileUpload, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FileUpload, "gbt-file-upload", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiple": {
+      "alias": "multiple";
+      "required": false;
+      "isSignal": true;
+    };
+    "accept": {
+      "alias": "accept";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxSizeMb": {
+      "alias": "maxSizeMb";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "dropLabel": {
+      "alias": "dropLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "removeLabel": {
+      "alias": "removeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "oversizeMessage": {
+      "alias": "oversizeMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "extraFileMessage": {
+      "alias": "extraFileMessage";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/masmarino-gabarit-floating-panel.d.ts

@@ -0,0 +1,7 @@
+interface FloatingPanelAnchor {
+  rect: DOMRect;
+  bottom: number;
+  left: number;
+}
+/** Returns `null` (panel closed, or trigger not in the DOM) when the caller should leave `panelStyle` untouched. */
+export declare function floatingPanelAnchor(open: boolean, trigger: HTMLElement | null, anchorBottom?: (rect: DOMRect) => number): FloatingPanelAnchor | null;

package/types/masmarino-gabarit-format.d.ts

@@ -0,0 +1,54 @@
+import * as i0 from "@angular/core";
+import { PipeTransform } from "@angular/core";
+interface FormatBytesOptions {
+  base?: 1000 | 1024;
+  decimals?: number;
+  binaryUnits?: 'iec' | 'legacy';
+}
+export declare function formatBytes(bytes: number, locale: string, options?: FormatBytesOptions): string;
+type DateInput = Date | string | number;
+interface FormatRelativeTimeOptions {
+  style?: 'long' | 'short' | 'narrow';
+  numeric?: 'auto' | 'always';
+  maxUnit?: 'hour' | 'day' | 'week' | 'month';
+  absoluteAfterDays?: number;
+  timeZone?: string;
+}
+export declare function formatRelativeTime(date: DateInput | null | undefined, locale: string, now?: DateInput, options?: FormatRelativeTimeOptions): string;
+export declare function formatDateTime(date: DateInput | null | undefined, locale: string, options?: Intl.DateTimeFormatOptions): string;
+interface GbtPipeLocale {
+  locale?: string;
+}
+type GbtRelativeTimePipeOptions = FormatRelativeTimeOptions & GbtPipeLocale & {
+  now?: DateInput;
+};
+type GbtBytesPipeOptions = FormatBytesOptions & GbtPipeLocale;
+type GbtDateTimePipeOptions = Intl.DateTimeFormatOptions & GbtPipeLocale;
+export declare class GbtRelativeTimePipe implements PipeTransform {
+  private readonly localeId;
+  transform(value: DateInput | null | undefined, options?: GbtRelativeTimePipeOptions): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<GbtRelativeTimePipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<GbtRelativeTimePipe, "gbtRelativeTime", true>;
+}
+export declare class GbtBytesPipe implements PipeTransform {
+  private readonly localeId;
+  transform(value: number | null | undefined, options?: GbtBytesPipeOptions): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<GbtBytesPipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<GbtBytesPipe, "gbtBytes", true>;
+}
+export declare class GbtDateTimePipe implements PipeTransform {
+  private readonly localeId;
+  transform(value: DateInput | null | undefined, options?: GbtDateTimePipeOptions): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<GbtDateTimePipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<GbtDateTimePipe, "gbtDateTime", true>;
+}
+export declare function formatNumber(value: number, locale: string, decimals?: number): string;
+export declare function formatCompact(value: number, locale: string): string;
+interface FormatDurationOptions {
+  days?: boolean;
+}
+export declare function formatDuration(ms: number, locale: string, options?: FormatDurationOptions): string;
+export declare function formatPercent(ratio: number, locale: string, decimals?: number): string;
+export declare function computeInitials(name: string): string;
+export declare function cachedIntl<T>(kind: string, locale: string, options: object | undefined, create: () => T): T;
+export type { DateInput, FormatBytesOptions, FormatDurationOptions, FormatRelativeTimeOptions, GbtBytesPipeOptions, GbtDateTimePipeOptions, GbtPipeLocale, GbtRelativeTimePipeOptions };

package/types/masmarino-gabarit-funnel-chart.d.ts

@@ -0,0 +1,78 @@
+import * as i0 from "@angular/core";
+interface FunnelStep {
+  label: string;
+  value: number;
+}
+interface RenderedStep {
+  label: string;
+  formattedValue: string;
+  part: number;
+  conversionFromPrevious: string;
+}
+export declare class FunnelChart {
+  steps: import("@angular/core").InputSignal<FunnelStep[]>;
+  label: import("@angular/core").InputSignal<string>;
+  locale: import("@angular/core").InputSignal<string>;
+  emptyMessage: import("@angular/core").InputSignal<string>;
+  tableCaption: import("@angular/core").InputSignal<string>;
+  stepColumn: import("@angular/core").InputSignal<string>;
+  valueColumn: import("@angular/core").InputSignal<string>;
+  conversionColumn: import("@angular/core").InputSignal<string>;
+  stepAnnouncement: import("@angular/core").InputSignal<(label: string, conversion: string) => string>;
+  private readonly reference;
+  protected readonly activeIndex: import("@angular/core").WritableSignal<number | null>;
+  protected onMouseLeave(event: MouseEvent): void;
+  protected readonly renderedSteps: import("@angular/core").Signal<RenderedStep[]>;
+  protected readonly activeStep: import("@angular/core").Signal<RenderedStep | null>;
+  protected readonly columns: import("@angular/core").Signal<string[]>;
+  protected readonly tableRows: import("@angular/core").Signal<(string | number)[][]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FunnelChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FunnelChart, "gbt-funnel-chart", never, {
+    "steps": {
+      "alias": "steps";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": true;
+      "isSignal": true;
+    };
+    "emptyMessage": {
+      "alias": "emptyMessage";
+      "required": true;
+      "isSignal": true;
+    };
+    "tableCaption": {
+      "alias": "tableCaption";
+      "required": true;
+      "isSignal": true;
+    };
+    "stepColumn": {
+      "alias": "stepColumn";
+      "required": true;
+      "isSignal": true;
+    };
+    "valueColumn": {
+      "alias": "valueColumn";
+      "required": true;
+      "isSignal": true;
+    };
+    "conversionColumn": {
+      "alias": "conversionColumn";
+      "required": true;
+      "isSignal": true;
+    };
+    "stepAnnouncement": {
+      "alias": "stepAnnouncement";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { FunnelStep };

package/types/masmarino-gabarit-gauge-bar.d.ts

@@ -0,0 +1,54 @@
+import * as i0 from "@angular/core";
+export declare class GaugeBar {
+  value: import("@angular/core").InputSignal<number>;
+  max: import("@angular/core").InputSignal<number>;
+  label: import("@angular/core").InputSignal<string>;
+  formattedValue: import("@angular/core").InputSignal<string>;
+  warningLabel: import("@angular/core").InputSignal<string>;
+  criticalLabel: import("@angular/core").InputSignal<string>;
+  thresholds: import("@angular/core").InputSignal<{
+    warning: number;
+    critical: number;
+  }>;
+  protected readonly percentage: import("@angular/core").Signal<number>;
+  protected readonly severity: import("@angular/core").Signal<"warning" | "critical" | null>;
+  protected readonly severityLabel: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<GaugeBar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<GaugeBar, "gbt-gauge-bar", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "formattedValue": {
+      "alias": "formattedValue";
+      "required": true;
+      "isSignal": true;
+    };
+    "warningLabel": {
+      "alias": "warningLabel";
+      "required": true;
+      "isSignal": true;
+    };
+    "criticalLabel": {
+      "alias": "criticalLabel";
+      "required": true;
+      "isSignal": true;
+    };
+    "thresholds": {
+      "alias": "thresholds";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}